Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Searching & Sorting :: write code for at least one of following task #3 #184

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Searching & Sorting :: write code for at least one of following task #3 #184

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
352 changes: 352 additions & 0 deletions Searching & Sorting :: write code for at least one of following task #3
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,352 @@
//Searching & Sorting :: write code for at least one of following task #3//

1.Binary search

public class BinarySearch {

public static void main(String[] args) {
int[] arr = {-18, -12, -4, 0, 2, 3, 4, 15, 16, 18, 22, 45, 89};
int target = 22;
int ans = binarySearch(arr, target);
System.out.println(ans);
}
static int binarySearch(int[] arr, int target) {
int start = 0;
int end = arr.length - 1;

while(start <= end) {
int mid = start + (end - start) / 2;

if (target < arr[mid]) {
end = mid - 1;
} else if (target > arr[mid]) {
start = mid + 1;
} else {
// ans found
return mid;
}
}
return -1;
}
}


2.Linear Search

public class LinearSearch {

public static void main(String[] args) {
int[] nums = {23, 45, 1, 2, 8, 19, -3, 16, -11, 28};
int target = 19;
boolean ans = linearSearch3(nums, target);
System.out.println(ans);
}
static boolean linearSearch3(int[] arr, int target) {
if (arr.length == 0) {
return false;
}

// run a for loop
for (int element : arr) {
if (element == target) {
return true;
}
}
return false;
}

// search the target and return the element
static int linearSearch2(int[] arr, int target) {
if (arr.length == 0) {
return -1;
}

// run a for loop
for (int element : arr) {
if (element == target) {
return element;
}
}
return Integer.MAX_VALUE;
}

static int linearSearch(int[] arr, int target) {
if (arr.length == 0) {
return -1;
}

// run a for loop
for (int index = 0; index < arr.length; index++) {
int element = arr[index];
if (element == target) {
return index;
}
}
return -1;
}

}


3.quick sort


class Quickst {

public static void main(String[] args)
{
int[] arr = { 10, 7, 8, 9, 1, 5 };
int n = arr.length;

quickSort(arr, 0, n - 1);
System.out.println("Sorted array: ");
printArray(arr, n);
}

public static void swap(int[] arr, int i, int j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static int partition(int[] arr, int low, int high)
{

int pivot = arr[high];
int i = (low - 1);

for (int j = low; j <= high - 1; j++) {
if (arr[j] < pivot) {
i++;
swap(arr, i, j);
}
}
swap(arr, i + 1, high);
return (i + 1);
}

public static void quickSort(int[] arr, int low, int high)
{
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

public static void printArray(int[] arr, int size)
{
for (int i = 0; i < size; i++)
System.out.print(arr[i] + " ");

System.out.println();
}
}


4.Selection sort


class Selectionsort {
public static void main(String[] args) {
int[] arr = {5, 3, 4, 1, 2};
selection(arr);
System.out.println(Arrays.toString(arr));
}
static void selection(int[] arr) {
for (int i = 0; i < arr.length; i++) {
// find the max item in the remaining array and swap with correct index
int last = arr.length - i - 1;
int maxIndex = getMaxIndex(arr, 0, last);
swap(arr, maxIndex, last);
}
}

static void swap(int[] arr, int first, int second) {
int temp = arr[first];
arr[first] = arr[second];
arr[second] = temp;
}

static int getMaxIndex(int[] arr, int start, int end) {
int max = start;
for (int i = start; i <= end; i++) {
if (arr[max] < arr[i]) {
max = i;
}
}
return max;
}
}



5.insertion sort


class Inerstionsort {

public static void main(String[] args) {
int[] arr = {5, 3, 4, 1, 2};
insertion(arr);
System.out.println(Arrays.toString(arr));
}

static void insertion(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i+1; j > 0; j--) {
if (arr[j] < arr[j-1]) {
swap(arr, j, j-1);
} else {
break;
}
}
}
}
}

6.Heap sort


class HeapSort {

public static void main(String args[])
{
int arr[] = { 12, 11, 13, 5, 6, 7 };
int N = arr.length;

HeapSort ob = new HeapSort();
ob.sort(arr);

System.out.println("Sorted array is");
printArray(arr);
}

public void sort(int arr[])
{
int N = arr.length;

for (int i = N / 2 - 1; i >= 0; i--)
heapify(arr, N, i);

for (int i = N - 1; i > 0; i--) {
// Move current root to end
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;

heapify(arr, i, 0);
}
}

void heapify(int arr[], int N, int i)
{
int largest = i; // Initialize largest as root
int l = 2 * i + 1; // left = 2*i + 1
int r = 2 * i + 2; // right = 2*i + 2

if (l < N && arr[l] > arr[largest])
largest = l;

if (r < N && arr[r] > arr[largest])
largest = r;

if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;

heapify(arr, N, largest);
}
}

static void printArray(int arr[])
{
int N = arr.length;

for (int i = 0; i < N; ++i)
System.out.print(arr[i] + " ");
System.out.println();
}
}

7. Merge sort

class MergeSort {
public static void main(String args[])
{
int arr[] = { 12, 11, 13, 5, 6, 7 };

System.out.println("Given Array");
printArray(arr);

MergeSort ob = new MergeSort();
ob.sort(arr, 0, arr.length - 1);

System.out.println("\nSorted array");
printArray(arr);
}
void merge(int arr[], int l, int m, int r)
{
int n1 = m - l + 1;
int n2 = r - m;

int L[] = new int[n1];
int R[] = new int[n2];

for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];

int i = 0, j = 0;

int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}

while (i < n1) {
arr[k] = L[i];
i++;
k++;
}

while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}


void sort(int arr[], int l, int r)
{
if (l < r) {
// Find the middle point
int m = l + (r - l) / 2;

// Sort first and second halves
sort(arr, l, m);
sort(arr, m + 1, r);

merge(arr, l, m, r);
}
}

static void printArray(int arr[])
{
int n = arr.length;
for (int i = 0; i < n; ++i)
System.out.print(arr[i] + " ");
System.out.println();
}
}