排序方法的核心思想总结

总结一下排序算法中的核心思想

1.BubbleSort

冒泡法的核心是双重循环：

第一层循环表明需要轮次的次数，他的变量i只是标记轮换了多少次，与交换没有直接关系，在一个数组中，需要轮次数为a.length-1次，所以i的取值可设置为1—a.length-1。

第二层循环的变量表示的为a[j]与a[j+1]的比较与交换，不断地递进，而且是相邻的两个元素交换，在进行第i轮次，已经有i-1个数据排好序，并且妨碍数组的末尾，所以，第i轮次，需要j最大为a.length-1-（i-1）-1，即小于a.length-i，代码如下：

<span style="font-size:18px;"><span style="font-size:18px;">static void bubble(int[] a) {
		int temp = 0;
		for(int i=1; i<a.length; i++) {
			for(int j=0; j<a.length-i; j++) {
				if(a[j] > a[j+1]) {
					temp = a[j+1];
					a[j+1] = a[j];
					a[j] = temp;
				}
			}
		}
	}</span></span>

2.SelectedSort

选择法的核心也是双重循环：

与冒泡法不同，选择法需要设置一个最小下标min，首先默认下标i对应整个数据的最小数，将i赋给min，然后利用第二层循环，使a[min]依次与min之后的数据比较，如果在某次比较中，发现还有比a[min]小的数据，那么重新定义min的值，即min=j（把j赋给min），在进行后面的比较。

第一层循环是选定初始值i，并将其设定为min的，i不断递进，i的大小范围为0—a.length-2(因为i要与其后面的数据比较，所以，i的最大位置为倒数第二个)。当第二层循环结束后，说明已经找到比a[i]还小的值，那么交换即可。

第二层循环是在选定min之后，依次比较min之后的数据，找出min之后的比a[min]小的数据，将其下标j记录在min中。j的取值范围是i-a.length-1。代码如下：

<span style="font-size:18px;"><span style="font-size:18px;">static void select(int[] a) {
		int temp = 0;
		int min = 0;
		for(int i=0; i<a.length-1; i++) {
			min = i; 
			for(int j=i+1; j<a.length; j++) {
				if(a[min] > a[j]) {
					min = j;
				}
			}
			temp = a[i];
			a[i] = a[min];
			a[min] = temp;
		}
	}</span></span>

3.InsertSort

直接插入排序将数据分成两部分，第一部分是已经排好序的数组，放在前端，后端序列是待排序的数组。

第一重循环，选择第一个待排序的数据a[i]，赋值为temp，因数据要从0开始排序，所以i的下标取值为0—a.length-1；

选择好要排序的数据后，进入第二部分循环，这部分循环完成的是将temp从后往前依次和排好序的数据比较，如果temp小，则将比较的数据后移一位，直至找到temp需要插入的位置。代码如下：

<span style="font-size:18px;">static void insert(int[] a) {
		int temp = 0;
		int j = 0;
		for(int i=1; i<a.length; i++) {
			temp = a[i];
			for(j=i-1; j>=0 && temp<a[j]; j--) { //j永远指向当前比较的元素
				a[j+1] = a[j];
			}
			a[j+1] = temp;
		}
	}</span>

4. ShellSort

shell排序的根本是插入排序，他有三层循环：

第一层循环是定义要完成最终排序，需要多少轮次，这个是由增量delta决定的，当增量变成0的时候，排序就应该停止了，delta的初始值为delta=a.length/2。这里需要做一些说明：

假设L=a.length,希尔排序的增量就是要满足floor(L/2)*2>=L-1;

当L为奇数时，floor(L/2)*2=(L-1)/2*2=L-1>=L-1;

当L为偶数时，floor(L/2)*2=L/2*2=L>L-1;

所以，delta取值为a.length/2可以把整个数组覆盖，所以delta的取值范围应该为0<delta<=a.length/2;

第二重和第三重循环的本质为插入排序，也就是增量为delta的插入排序，代码如下：

static void shellSort(int[] a) {
		int temp = 0;
		int k = 0;
		for(int delta=a.length/2; delta>0; delta /=2) { //定义循环的次数，其由delta决定
			for(int j=delta; j<a.length; j++) {     //以下为插入排序，只不过增量为delta
				temp = a[j];
				for(k=j-delta; k>=0 && temp<a[k]; k-=delta) {
					a[k+delta] = a[k];
				}
				a[k+delta] = temp;
			}
		}
	}

5. QuickSort

快速排序有点类似于二分法，实际上是分治策略的应用，所以，他需要用到递归的方法。

快速排序需要注意的就是数组合法性的判断，详见代码：

	static void quickSort(int[] a) {
		quickSort(a, 0, a.length-1);
	}
	
	static void quickSort(int[] a, int begin, int end) {
		if(begin>=0 && begin<a.length && end>=0 && end<a.length && begin<end) {
			//这些判定必不可少，考略极端条件下，即序列是有序递增序列，最后i=j=0;那么递归时,i-1必然导致数组越界，同理，如果递减数组，j+1也会越界
			int i = begin, j = end;
			int temp = a[i];
			while(i != j) {
				while(i<j && temp < a[j]) {
					j--;
				}
				if(i<j) {  // 必须保证i<j，否则，加入如果这时i=j，那么下面的代码会造成i=i+1，这个时候i ！= j，这个时候，i会一直不等于j
					a[i++] = a[j];
				}
				
				while(i<j && temp > a[i]) {
					i++;
				}
				if(i < j) {
					a[j--] = a[i];
				}
			}
			
			a[i] = temp;
			quickSort(a, begin, i-1);// 有i-1,见上if判定
			quickSort(a, i+1, end);
		}
	}

6.Merge排序

归并排序的核心是完成两路数组的归并，归并排序都是基于两路归并完成的。归并排序需要另外一个和待排序数组a等长的数组b，所以他的空间复杂度是O(n)。

归并排序应该分层，从三个层次理解：第一层是两路数组的归并，需要参数为数组a，b，begin1，begin2，和每个数组的长度n，代码如下：

static void merge(int[] a, int[] b, int begin1, int begin2, int n) {
		int i=begin1, j=begin2, k=begin1;
		while(i<begin1+n && j<begin2+n && j<a.length) {//完成两路数据的合并，当某一路到头时，结束
			if(a[i] > a[j]) {
				b[k++] = a[j++];
			}
			else{
				b[k++] = a[i++];
			}
		}
		
		while(i < begin1+n && i < a.length) { //将某个数组剩余部分复制过去
			b[k++] = a[i++];
		}
		while(j < begin2+n && j < a.length) {
			b[k++] = a[j++];
		}
	}

第二层对a完成一趟的两路数组合并，代码如下：

static void merge(int[] a, int[] b, int k) {
		
		for(int i=0; i<a.length; i+=2*k) { //这里的步长为2K，因为两路数据合并后，下个数组要从i+2k开始
			merge(a,b,i,i+k,k);
		}
	}

第三层是实现不同步长的多趟合并，这里主要是设置步长：

static void merge(int[] a) {
		int[] b = new int[a.length];
		int begin1, begin2;
		int k = 1;
		
		while(k<a.length) {
			merge(a,b,k);
			k*=2;         //当k>a.length，下面的代码实际就是将b复制到a。
			merge(b,a,k); //这里要将b中的数据在转到a中，无论这里的k值多少，都能转换成功。
			k*=2;
		}
	}

7.堆排序

堆排序主要分成两步，第一步，把堆调成最小堆，第二步，进行堆排序。

调堆的过程是从最底层开始的，也就是说，从parent=a.length/2-1开始，这里parent必然是最后一个叶子的父亲，先将parent复制到temp中保存起来，然后判定一下左右子树的大小，找出最小子树，然后与parent比较，如果parent更小，说明不需移动，可以直接返回，如果最小子树更小，那么需要把子树复制到parent上，然后将parent和child下移，继续这个循环，直到找到最后的子树，将temp复制过去即可。

堆排序利用了调堆方法，先选出最小值，与最末尾的数值交换，之后数组个数减一，进行调堆，代码如下：

private static void heapSort(int[] a) {
		int temp = 0;
		
		for(int i=a.length/2-1; i>=0; i--) {
			sift(a,i,a.length-1);
		}
		
		for(int j=a.length-1; j>0; j--) {
			temp = a[0];
			a[0] = a[j];
			a[j] = temp;
			sift(a,0,j-1);
		}
	}
	
	private static void sift(int[] a, int parent, int end) {
		int child = 2*parent + 1;
		int temp = a[parent];
		while(child <= end) {
			if(child < end && a[child] > a[child+1]) {
				child++;
			}
			if(temp > a[child]) {
				a[parent] = a[child];
				parent = child;
				child = parent*2+1;	
			}
			else break;
		}
		a[parent] = temp;
	}