递归与迭代

数据结构–递归与迭代

第一部分：

对于一个数组求和问题的两种思路

1. 减而治之： 时间复杂度：O(n)

<pre> 
	public class LinearRecur {  
	public static void main(String[] args) {
		int[] array = {1,2,3,4,5,6,7,8,9};
		int length = array.length;
		int sum = 0;
		sum = getSum(array, length);
		System.out.println(sum);
	}
	// 减而治之(递归),算法复杂度O(n)
	public static int getSum(int[] array, int length) {
		return length < 1 ? 0 : getSum(array, length - 1) + array[length - 1];
	}
}
</pre>

2. 分而治之：时间复杂度O(n)

<pre>
public class LinearRecur {
	public static void main(String[] args) {
		int[] array = {1,2,3,4,5,6,7,8,9};
		int low = 0; 
		int high = array.length - 1;
		int sum = 0;
		sum = getSum(array, low,high);
		System.out.println(sum);
	}
	public static int getSum(int[] array, int low, int high) {
		return high > low ? getSum(array,low,(high + low)/2) + getSum(array,(high+low)/2+1,high) : array[low];
	}	
}
</pre>

将一个数组进行倒置

1. 减而治之：将这个问题逐渐减小，求解子问题

<pre>
public class LinearRecur {
	public static void main(String[] args) {
		int[] array = {1,2,3,4,5,6,7,8,9};
		int low = 0; 
		int high = array.length - 1;
		int sum = 0;
		reverse(array, low,high);
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}
	public static void reverse(int[] array, int low, int high) {
		if (low < high) {  //问题规模的奇偶不变性
			swap(array, low, high);
			reverse(array, low + 1, high - 1);
		}else {
			return;
		}
	}
	public static void swap(int[] array, int a, int b) {
		array[a] = array[a] + array[b];
		array[b] = array[a] - array[b];
		array[a] = array[a] - array[b];
	}
}
</pre>

求一个数组中最大的两个数：

1. 迭代一：思路，先找到最大的，再从剩余的数中找最小的，无论如何时间复杂度都是O(2n-3)

<pre>
public class LinearRecur {
	public static void main(String[] args) {
		int[] array = {10,2,3,11,5,6,7,9,8};
		int low = 0; 
		int high = array.length;
		int[] index = null;
		index = getMax2(array, low, high);
		for (int i = 0; i < index.length; i++) {
			System.out.println(index[i]);
		}
	}
	//迭代法1：
	public static int[] getMax2(int[] array, int low, int high) {
		int[] index = {0,0};
		for (int i = 0; i < high; i++) {
			if (array[i] > array[index[0]]) {
				index[0] = i;
			}
		}
		
		if (index[0]==index[1]) {
			index[1] =1;
		}
		for (int i = 0; i < index[0]; i++) {
			if (array[i] > array[index[1]]) {
				index[1] = i;
			}
		}
		for (int i = index[0] + 1; i < high; i++) {
			if (array[i] > array[index[1]]) {
				index[1] = i;
			}
		}
		return index;
	}
}
</pre>

2.迭代二：迭代二的主要思想是通过将两个最大的index相应的数值与遍历过程中的数值进行比较
这种方法最好的情况：时间复杂度：O(n-1)
这种方法最坏的情况：时间复杂度：O(2n-3)

<pre>
public class LinearRecur {
	public static void main(String[] args) {
		int[] array = {100,2,3,11,5,6,7,9,8};
		int low = 0; 
		int high = array.length;
		int[] index = null;
		index = getMax2(array, low, high);
		for (int i = 0; i < index.length; i++) {
			System.out.println(index[i]);
		}
	}
	//迭代法2：
	public static int[] getMax2(int[] array, int low, int high) {
		int[] index = {0,1};
		if (array[1] > array[0]) {
			index[0] = 1;
			index[1] = 0;
 		}
		for (int i = 2; i < high; i++) {
			if (array[i]> array[index[0]]) {
				index[1] = index[0];
				index[0] = i;
			}else if(array[i]> array[index[1]]) {
				index[1] = i;
			}
		}
		return index;
	}
}
</pre>

3.方法三：递归+分治

递归基：当元素个数为2，或者3时开始返回，参考下图：

<pre>
public class LinearRecur {
	public static void main(String[] args) {
		int[] array = {100,2,3,900,5,6,70,9,800};
		int low = 0; 
		int high = array.length;
		int[] index = {0,1};
		index = getMax2(array, low, high);
		for (int i = 0; i < index.length; i++) {
			System.out.println(index[i]);
		}
	}
	//递归+分治：
	public static int[] getMax2(int[] array, int low, int high) {
		
		if(low + 2 == high) {
			int[] index = {high-1,low};
			if(array[low] >= array[high-1]) {
				index[0] = low;
				index[1] = high-1;
			}	
			return index;
		}
		if(low + 3 == high) {
			int[] index = {low, low+1};
			for (int i = low + 1; i < high; i++) {
				if (array[i]>array[index[0]]) {
					index[1] = index[0];
					index[0] = i;
				}else if (array[i] > array[index[1]]) {
					index[1] = i;
				}
			}
			return index;
		}
		int[] indexLeft = {low,high-1};
		int[] indexRight = {low,high-1};
		int[] index = {low,low+1};
		int middle = 0;
		middle = (low + high)/2;
		indexLeft = getMax2(array,low,middle);
		indexRight = getMax2(array,middle,high);
		
		index[0] = array[indexLeft[0]] > array[indexRight[0]] ? indexLeft[0] : indexRight[0];
		if (index[0] == indexLeft[0]) {
			index[1] = array[indexLeft[1]] > array[indexRight[0]] ? indexLeft[1]: indexRight[0];
		}else if(index[0] == indexRight[0]) {
			index[1] = array[indexRight[1]] > array[indexLeft[0]] ? indexRight[1]: indexLeft[0];
		}
		return index;
	}
}
</pre>