冒泡排序与归并排序

冒泡排序与归并排序

冒泡排序

1. 方法一：思想是相邻元素逐个比较，然后将最大的放在后面。每遍历完一次，就会有一个元素就位，所以时间复杂度为O(n^2)

<pre>
public class LinearRecur {
	public static void main(String[] args) {
		int[] b = {7,6,10,9,12,15};
		int low = 0;
		int high = b.length; 
		int index = 0;
		bubbleSort(b, low, high);
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
	}
	public static void bubbleSort(int[] array, int low, int high) {
		while (low < high--) {
			for (int i = 0; i < high; i++) {
				if (array[i+1] < array[i]) {
					array[i] = array[i+1] + array[i];
					array[i+1]= array[i] - array[i+1];
					array[i] = array[i] - array[i+1];
				}
			}
		}
	}
}
</pre>	

2.方法二：排序时，很可能其中的元素已经大部分就位了，由此我们每一次遍历，通过一个flag标志位检查该组元素是否已经就位，如果已经就位，我们就结束。结果如图所示：

<pre>
public class LinearRecur {
	public static void main(String[] args) {
		int[] b = {7,6,10,9,12,15};
		int low = 0;
		int high = b.length; 
		int index = 0;
		bubbleSort(b, low, high);
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
	}
	public static void bubbleSort(int[] array, int low, int high) {
		boolean flag = true;
		while (flag & low < high--) {
			flag = false;
			for (int i = 0; i < high; i++) {
				if (array[i+1] < array[i]) {
					array[i] = array[i+1] + array[i];
					array[i+1]= array[i] - array[i+1];
					array[i] = array[i] - array[i+1];
					flag = true;
				}
			}
		}
	}
}	
</pre>

3.方法三：排序时，可能后一部分元素一次排序后就大部分已经就位了，而在这种情况下，利用flag进行的排序并没有很好的利用这组元素的这一特性。基于此，我们对该算法进行改进。结果如图所示：

<pre>
public class LinearRecur {
	public static void main(String[] args) {
		int[] b = {7,15,10,9,12,1};
		int low = 0;
		int high = b.length; 
		int index = 0;
		bubbleSort(b, low, high);
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
	}
	public static void bubbleSort(int[] array, int low, int high) {
		int index = 0;
		while ( low < high--) {
			for (int i = 0; i < high; i++) {
				if (array[i+1] < array[i]) {
					array[i] = array[i+1] + array[i];
					array[i+1]= array[i] - array[i+1];
					array[i] = array[i] - array[i+1];
					index = i+1;
				}
			}
			high = high < index ? high:index; 
		}
	}
}
</pre>

4.算法稳定性：只有在下面情况下，所用算法才是稳定的

归并排序

归并排序：归并排序是利用分治与递归的思想，先将序列分为多个子序列，然后子序列递归排序，并且归并子序列。主要思路如下图所示：

<pre>
public class LinearRecur {
	public static void main(String[] args) {
		int[] b = {1,18,10,9,12,0};
		int low = 0;
		int high = b.length; 
		int index = 0;
		mergeSort(b, low, high);
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
	}
	public static void mergeSort(int[] array, int low, int high) {
		if (high - low == 1) {
			return;
		}
		int middle = (low + high) / 2;
		mergeSort(array, low, middle);
		mergeSort(array, middle, high);
		merge(array, low, middle, high);
	}
	public static void merge(int[] array, int low, int middle, int high) {
		//先为[low,middle)的数组开辟一段空间，存储其中的元素
		int[] a = new int[middle - low];
		for (int i = low; i < middle; i++) {
			a[i-low] = array[i];
		}
		for (int i = 0, j = middle, k = low; i < (middle-low) || j < high ;) {
			if(i < middle-low && (high <= j || a[i] <= array[j])) {
				array[k++] = a[i++];
			}
			if(j < high && (middle-low <= i || array[j] < a [i])) {	
				array[k++] = array[j++];  
			}
		}
	}
}