some recursion examples

recurssions examples/MergeSort.java

@@ -0,0 +1,60 @@
+package recurssion;
+
+public class MergeSort {
+
+	public static void main(String[] args) {
+		int[] one = { 11, 33, 55, 66 }, two = { 5, 7, 9, 14, 22 };
+		int[] arr = merge(one, two);
+		// for (int val : arr) {
+		// System.out.print(val + " ");
+		// }
+		int[] three = { 2, 54, 6, 23, 7, 2, 67, 44, 77, 99, 0 };
+		three = mergesort(three, 0, three.length - 1);
+		for (int val : three) {
+			System.out.print(val + " ");
+		}
+	}
+
+	public static int[] merge(int[] one, int[] two) {
+		int i = 0, j = 0, k = 0;
+		int[] arr = new int[one.length + two.length];
+		while ((i < one.length) && (j < two.length)) {
+			if (one[i] > two[j]) {
+				arr[k] = two[j];
+				++j;
+				++k;
+			} else {
+				arr[k] = one[i];
+				++i;
+				++k;
+			}
+		}
+		while (j < two.length) {
+
+			arr[k] = two[j];
+			++j;
+			++k;
+		}
+		while (i < one.length) {
+
+			arr[k] = one[i];
+			++i;
+			++k;
+		}
+		return arr;
+	}
+
+	public static int[] mergesort(int arr[], int lo, int hi) {
+		if (hi == lo) {
+			int[] b = new int[1];
+			b[0] = arr[lo];
+			return b;
+		}
+		int mid = (lo + hi) / 2;
+		int[] fhalf = mergesort(arr, lo, mid);
+		int[] shalf = mergesort(arr, mid + 1, hi);
+
+		int arr1[] = merge(fhalf, shalf);
+		return arr1;
+	}
+}

recurssions examples/QuickSort.java

@@ -0,0 +1,43 @@
+package recurssion;
+
+public class QuickSort {
+
+	public static void main(String[] args) {
+
+		int[] arr = { 5, 11, 33, 66, 22 };
+		qsort(arr, 0, arr.length - 1);
+		for (int val : arr) {
+			System.out.print(val + " ");
+		}
+
+	}
+
+	public static void qsort(int[] arr, int low, int hi) {
+		if (low >= hi)
+			return;
+
+		int left = low, right = hi;
+		int mid = (low + hi) / 2;
+		int pivit = arr[mid];
+		while (left <= right) {
+			while (arr[left] < pivit) {
+				++left;
+			}
+			while (arr[right] > pivit) {
+				--right;
+			}
+
+			if (left <= right) {
+				int temp = arr[right];
+				arr[right] = arr[left];
+				arr[left] = temp;
+				right--;
+				left++;
+			}
+		}
+
+		qsort(arr, low, right);
+		qsort(arr, left, hi);
+
+	}
+}

recurssions examples/a6q10.java

@@ -0,0 +1,28 @@
+package recurssion;
+
+public class a6q10 {
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 33, 55, 33, 11, 22, 44 };
+		int[] ind = indices(arr,33, 0, 0);
+		for(int val:ind)
+			System.out.print(val+"\t");
+	}
+
+	private static int[] indices(int[] arr, int data,int vidx, int count) {
+		if(vidx==arr.length)
+		{
+			int[] ind=new int[count];
+			return ind;
+		}
+
+		if(arr[vidx]==data)
+			++count;
+		int[] ind=	indices(arr, data,vidx+1, count);
+		if(arr[vidx]==data)
+	ind[count-1]=vidx;
+
+	return ind;
+	}
+
+}

recurssions examples/a6q11.java

@@ -0,0 +1,22 @@
+package recurssion;
+
+public class a6q11 {
+	public static boolean palindrome(int[] arr,int vidx)
+	{
+		if(vidx==arr.length/2)
+			return true;
+		boolean bool=false;
+		if(arr[vidx]==arr[arr.length-1-vidx])
+		{
+		bool=palindrome(arr,vidx+1);
+		}
+
+			return bool;
+	}
+
+	public static void main(String[] args) {
+int[] arr={1,2,3,2,1,9};
+	System.out.println(palindrome(arr,0));
+	}
+
+}

recurssions examples/a6q12.java

@@ -0,0 +1,28 @@
+package recurssion;
+
+public class a6q12 {
+	public static void swap(int[] arr,int i,int j)
+	{
+
+			int temp=arr[i];
+			arr[i]=arr[j];
+			arr[j]=temp;
+
+	}
+	public static void rev(int[] arr, int vidx) {
+		if (vidx == arr.length / 2)
+			return;
+		swap(arr,vidx,(arr.length - 1 - vidx));
+		rev(arr, vidx + 1);
+	}
+
+	public static void main(String[] args) {
+		int[] arr = { 1, 2, 3, 4, 5,6 };
+		rev(arr, 0);
+		for(int val:arr)
+		{
+			System.out.print(val+" ");
+		}
+	}
+
+}

recurssions examples/a6q14.java

@@ -0,0 +1,35 @@
+package recurssion;
+
+public class a6q14 {
+	public static void swap(int[] arr, int i, int j) {
+
+		int temp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = temp;
+
+	}
+
+	public static void sort(int[] arr, int vidx, int index) {
+		if (vidx == 1)
+			return;
+
+		if (index < vidx - 1) {
+			sort(arr, vidx, index + 1);
+			if (arr[index] > arr[index + 1])
+				swap(arr, index, index + 1);
+		}
+		if (index == vidx - 1)
+			sort(arr, vidx - 1, 0);
+	}
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 55, 33, 11, 22, 44 };
+		sort(arr, arr.length, 0);
+
+		for (int val : arr) {
+			System.out.print(val + " ");
+		}
+
+	}
+
+}

recurssions examples/a6q15.java

@@ -0,0 +1,36 @@
+package recurssion;
+
+public class a6q15 {
+	public static void swap(int[] arr, int i, int j) {
+
+		int temp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = temp;
+
+	}
+
+	public static void sort(int[] arr, int vidx, int index) {
+		if (vidx == arr.length)
+			return;
+
+		if (index == 0)
+			sort(arr, vidx + 1, vidx + 1);
+
+		if (index > 0) {
+			sort(arr, vidx, index - 1);
+			if (arr[index] < arr[index - 1])
+				swap(arr, index, index - 1);
+		}
+	}
+
+	public static void main(String[] args) {
+		int[] arr = { 66, 55, 33, 11, 22, 44 };
+
+		sort(arr, 1, 1);
+		for (int val : arr) {
+			System.out.print(val + " ");
+		}
+
+	}
+
+}

recurssions examples/a6q2.java

@@ -0,0 +1,28 @@
+package recurssion;
+
+public class a6q2 {
+
+	public static int print(int i, int j) {
+		if (i == 0)
+			return 0;
+		else if (j == 0) {
+
+			print(i - 1, i - 1);
+			System.out.println();
+			return 0;
+		}
+		if (j > 0) {
+			print(i, j - 1);
+			System.out.print("*\t");
+
+			return 0;
+		}
+		return 0;
+	}
+
+	public static void main(String[] args) {
+		int k = print(3, 3);
+
+	}
+
+}

recurssions examples/a6q3.java

@@ -0,0 +1,29 @@
+package recurssion;
+
+public class a6q3 {
+
+	public static int print(int i ,int j)
+	{
+		if(i==0)
+			return 0;
+		else if(j==0)
+		{
+			System.out.println();
+			print(i-1,i-1);
+
+		return 0;
+		}
+		if(j>0)
+		{
+		System.out.print("*\t");
+		print(i,j-1);
+		return 0;
+		}
+	return 0;	
+	}
+	public static void main(String[] args) {
+int k=print(3,3);
+
+	}
+
+}

recurssions examples/a6q4.java

@@ -0,0 +1,42 @@
+package recurssion;
+
+public class a6q4 {
+
+	public static int print(int i, int j) {
+		if (i == -1) {
+			return 1;
+		}
+		if (j >= i) {
+			print(i - 1, 0);
+			System.out.println();
+			return 1;
+		}
+		if (j < i) {
+
+			int n = print(i, j + 1);
+			System.out.print(n);
+			n = (n * (i - j) )/ (j + 1);
+			return n;
+		}
+		return 1;
+	}
+
+	public static void printfor(int n) {
+		if (n == -1)
+			return;
+		printfor(n - 1);
+		System.out.println();
+		int num = 1;
+		for (int j = 0; j <= n; ++j) {
+			System.out.print(num + "\t");
+			num = num * (n - j) / (j + 1);
+		}
+	}
+
+	public static void main(String[] args) {
+
+		print(4, 0);
+		// printfor(6);
+	}
+
+}

recurssions examples/a6q6.java

@@ -0,0 +1,20 @@
+package recurssion;
+
+public class a6q6 {
+	public static boolean check(int[] arr, int vidx) {
+		if (vidx == arr.length - 1)
+			return true;
+		if (arr[vidx] > arr[vidx + 1])
+			return false;
+		else
+		return(check(arr, vidx + 1));
+
+
+	}
+
+	public static void main(String[] args) {
+		int[] arr1 = { 1, 2, 3, 4, 5, 6 }, arr2 = { 1, 4, 5, 2, 0 };
+		System.out.println(check(arr2,0));
+	}
+
+}