排序算法和分析史上最全

  一直都想总结下排序算法，趁今天有空，自己总结一番,本文参考了

http://www.2cto.com/kf/201109/104886.html

http://blog.csdn.net/column/details/aray.html

http://blog.csdn.net/morewindows/article/details/6678165

1：冒泡排序（交换型排序）

     （1）最常见的排序，处理小数据量很不错，大数据量耗费资源过多，时间过长，为啥这么说，请看下面

     （2）思想，对数据进行两次循环，第一层循环，每次找出一个最大的数（或最小的数），第二次循环，相邻的元素交换

    

package com.sort;

import java.util.Random;

public class MaoPaoSort {
	public static void main(String[] arg) {

		int size = 1000;
		int[] a = new int[size];
		Random random = new Random();

		for (int i = 0; i < size; i++) {
			a[i] = random.nextInt(size);
		}

		MaoPaoSort sort = new MaoPaoSort();

		Long start = System.currentTimeMillis();
		sort.sort(a);
		Long end = System.currentTimeMillis();

		for (int j = 0; j < size; j++) {
			System.out.println(a[j]);
		}

		System.out.println("Sorted " + size + " Data , Cost " + (end - start)
				+ " ms");
	}

	public void sort(int[] a) {
		int length = a.length;
		int tmp;
		for (int i = 1; i < length; i++) {
			for (int j = 0; j < length - i; j++) {
				if (a[j] > a[j + 1]) {
					tmp = a[j + 1];
					a[j + 1] = a[j];
					a[j] = tmp;
				}
			}
		}
	}
}

分析： 代码就不过多分析了，值得注意的是，

          （1）sort方法里面， 第一层循环从i=1开始，因为第二次j <  length - i,第二层不需要每次都遍历一遍数组了，因为执行完之后，最后一个数就是最大（或者最小），这都想不通就不适合搞编程了

          （2）main 方法里面，size = 1000，本机执行时间10ms，size = 10000，执行时间179ms,  size = 100000,执行时间17293ms，size= 1000000，执行时间（还未执行完）,其实是1854501 ms，30多分钟，擦

          （3）可以看出，在数据量增加的时候，时间会以几何级数增长，无法应对大数据

          （4）冒泡的时间复杂度度为o(n*n/2) = o(n^2)

2：快速排序（交换型排序）

     目前最流行的排序算法，巧妙的思想，稳定的开销

首先上图：    

 

从图中我们可以看到：

left指针，right指针，base参照数。

其实思想是蛮简单的，就是通过第一遍的遍历（让left和right指针重合）来找到数组的切割点。

第一步：首先我们从数组的left位置取出该数（20）作为基准（base）参照物。

第二步：从数组的right位置向前找，一直找到比（base）小的数，

            如果找到，将此数赋给left位置（也就是将10赋给20），

            此时数组为：10，40，50，10，60，

            left和right指针分别为前后的10。

第三步：从数组的left位置向后找，一直找到比（base）大的数，

             如果找到，将此数赋给right的位置（也就是40赋给10），

             此时数组为：10，40，50，40，60，

             left和right指针分别为前后的40。

第四步：重复“第二,第三“步骤，直到left和right指针重合，

             最后将（base）插入到40的位置，

             此时数组值为： 10，20，50，40，60，至此完成一次排序。

第五步：此时20已经潜入到数组的内部，20的左侧一组数都比20小，20的右侧作为一组数都比20大，

            以20为切入点对左右两边数按照"第一，第二，第三，第四"步骤进行，最终快排大功告成。

public void tim(int[] a, int left, int right) {
		if (left < right) {
			int index = division(a, left, right);
			tim(a, left, index - 1);
			tim(a, index + 1, right);
		}
	}
	
	public int division(int[] a, int left, int right){
		int base = left;
		
		while (left < right) {
			while (left < right && a[right] >= a[base]) {
				right--;
			}
			
			a[left] = a[right];
			
			while (left < right && a[left] <= a[base]) {
				left++;
			}
			
			a[right] = a[left];
		}
		
		a[left] = a[base];
		
		return left;
	}

10000条无序数据的运行时间比冒泡排序减少了一个数量级。

3：直接选择排序（选择排序）

     （1）常见的排序，处理小数据量很不错，同样大数据量耗费资源过多

     （2）思想，对数据进行两次循环，第一层循环，把a[i]当做最小的数，第二层循环，从i往后，如果找到比a[i]还小的，交换数值，并且min_index = j,继续执行第二层循环执行完，那么第一次循环执行一遍即取出了最大值（最小值），跟冒泡排序有些许类似

package com.sort;

import java.util.Random;

public class XuanZeSort {
	public static void main(String[] arg) {

		int size = 1000;
		int[] a = new int[size];
		Random random = new Random();

		for (int i = 0; i < size; i++) {
			a[i] = random.nextInt(size);
		}

		MaoPaoSort sort = new MaoPaoSort();

		Long start = System.currentTimeMillis();
		sort.sort(a);
		Long end = System.currentTimeMillis();

		for (int j = 0; j < size; j++) {
			System.out.println(a[j]);
		}

		System.out.println("Sorted " + size + " Data , Cost " + (end - start)
				+ " ms");
	}

	public void sort(int[] a) {
		int length = a.length;
		int tmp;
		int min_index = 0;
		for (int i = 1; i < length; i++) {
			min_index = i - 1;
			
			for (int j = i; j < length; j++) {
				if(a[j] < a[min_index]){
					tmp = a[min_index];
					a[min_index] = a[j];
					a[j] = tmp;
					min_index = j;
				}
			}
			
		}
	}
}

分析：

          （1）main 方法里面，size = 1000，本机执行时间11ms，size = 10000，执行时间181ms,  size = 100000,执行时间17316ms，size= 1000000，执行时间很长

          （3）可以看出，在数据量增加的时候，时间会以几何级数增长，无法应对大数据，适用于小数据

    （4）选择排序的时间复杂度度为o(n*n/2) = o(n^2)

4：堆排序（选择排序）

要知道堆排序，首先要了解一下二叉树的模型。

下图就是一颗二叉树，具体的情况我后续会分享的。

那么堆排序中有两种情况（看上图理解）：

    大根堆：  就是说父节点要比左右孩子都要大。

    小根堆：  就是说父节点要比左右孩子都要小。

 

那么要实现堆排序,必须要做两件事情：

   第一：构建大根堆。

           首先上图：

           

首先这是一个无序的堆，那么我们怎样才能构建大根堆呢？

     第一步： 首先我们发现，这个堆中有2个父节点(2,,3);

     第二步： 比较2这个父节点的两个孩子（4，5），发现5大。

     第三步： 然后将较大的右孩子（5）跟父节点（2）进行交换，至此3的左孩子堆构建完毕，

                 如图：

                         

     第四步： 比较第二个父节点（3）下面的左右孩子（5，1），发现左孩子5大。

     第五步： 然后父节点（3）与左孩子（5）进行交换，注意，交换后，堆可能会遭到破坏，

                 必须按照以上的步骤一，步骤二，步骤三进行重新构造堆。

           

最后构造的堆如下:

                 

 

   第二：输出大根堆。

             至此，我们把大根堆构造出来了，那怎么输出呢？我们做大根堆的目的就是要找出最大值，

         那么我们将堆顶（5）与堆尾（2）进行交换，然后将（5）剔除根堆，由于堆顶现在是（2），

         所以破坏了根堆，必须重新构造，构造完之后又会出现最大值，再次交换和剔除，最后也就是俺们

         要的效果了，

public void heapSort(int[] a){
		if (a == null || a.length == 0) {
			System.out.println("error");
		}
		
		int arrayLength = a.length;
		for (int i = arrayLength / 2 - 1; i >= 0; i--) {
			makeMaxHeap(a, i, arrayLength - 1);
		}
		
		//output
		
	}
	
	public void makeMaxHeap(int[] a, int parent, int length){
		
		int leftChild = 2 * parent + 1;
		int rightChild = leftChild + 1;
		
		if (rightChild <= length) {
			if (a[leftChild] < a[rightChild]) {
				swap(a, leftChild, rightChild);
			}
		}
		
		if (a[leftChild] > a[parent]) {
			swap(a, leftChild, parent);
		}
		
		if (rightChild <= length) {
			if (a[leftChild] < a[rightChild]) {
				swap(a, leftChild, rightChild);
			}
		}
	}
	
	public void swap(int[] a, int left, int right){
		int tmp = a[left];
		a[left] = a[right];
		a[right] = tmp;
	}

堆排序的时间复杂度：O(NlogN)

5：直接插入排序

直接插入排序：

       这种排序其实蛮好理解的，很现实的例子就是俺们斗地主，当我们抓到一手乱牌时，我们就要按照大小梳理扑克，30秒后，

   扑克梳理完毕，4条3，5条s，哇塞......  回忆一下，俺们当时是怎么梳理的。

       最左一张牌是3，第二张牌是5，第三张牌又是3，赶紧插到第一张牌后面去，第四张牌又是3，大喜，赶紧插到第二张后面去，

   第五张牌又是3，狂喜，哈哈，一门炮就这样产生了。

 

     怎么样，生活中处处都是算法，早已经融入我们的生活和血液。

     

     下面就上图说明：

             

      看这张图不知道大家可否理解了，在插入排序中，数组会被划分为两种，“有序数组块”和“无序数组块”，

     

      对的，第一遍的时候从”无序数组块“中提取一个数20作为有序数组块。

              第二遍的时候从”无序数组块“中提取一个数60有序的放到”有序数组块中“，也就是20，60。

              第三遍的时候同理，不同的是发现10比有序数组的值都小，因此20，60位置后移，腾出一个位置让10插入。

                      然后按照这种规律就可以全部插入完毕。

需要注意的是，我们必须从后面开始移位

//O(log n^2)
	public void insertSort(int[] a){
		int j = 0;
		int tmp = 0;
		for (int i = 1; i < a.length; i++) {
			j = i;
			tmp = a[j];
			while (j > 0 && a[j] < tmp) {
				a[j] = a[j - 1];
				j--;
			}
			a[j] = tmp;
		}
	}

分析：

          （1）main 方法里面，如果数据本来有序，那么时间很短，适用于有序数据

          （4）选择排序的时间复杂度度为o(n*n/2) = o(n^2)

希尔排序：

        观察一下”插入排序“：其实不难发现她有个缺点：

              如果当数据是”5, 4, 3, 2, 1“的时候，此时我们将“无序块”中的记录插入到“有序块”时，估计俺们要崩盘，

       每次插入都要移动位置，此时插入排序的效率可想而知。

   

      shell根据这个弱点进行了算法改进，融入了一种叫做“缩小增量排序法”的思想，其实也蛮简单的，不过有点注意的就是：

  增量不是乱取，而是有规律可循的。

首先要明确一下增量的取法：

      第一次增量的取法为： d=count/2;

      第二次增量的取法为:  d=(count/2)/2;

      最后一直到: d=1;

看上图观测的现象为：

        d=3时：将40跟50比，因50大，不交换。

                   将20跟30比，因30大，不交换。

                   将80跟60比，因60小，交换。

        d=2时：将40跟60比，不交换，拿60跟30比交换，此时交换后的30又比前面的40小，又要将40和30交换，如上图。

                   将20跟50比，不交换，继续将50跟80比，不交换。

        d=1时：这时就是前面讲的插入排序了，不过此时的序列已经差不多有序了，所以给插入排序带来了很大的性能提高。

//O(log n^1.5)
	public void shellSort(int[] a){
		int range = a.length / 2;
		for (; range > 0; range = range / 2) {
			int j = 0;
			int tmp = 0;
			for (int i = 0; i < a.length / range; i += range) {
				j = i;
				tmp = a[j];
				while (j > 0 && a[j - range] > tmp) {
					a[j] = a[j - range];
					j -= range;
				}
				a[j] = tmp;
			}
		}
	}

归并排序：

       个人感觉，我们能容易看的懂的排序基本上都是O (n^2)，比较难看懂的基本上都是N(LogN)，所以归并排序也是比较难理解的，尤其是在代码

 编写上，本人就是搞了一下午才搞出来，嘻嘻。

 

首先看图：

归并排序中中两件事情要做：

            第一： “分”,  就是将数组尽可能的分，一直分到原子级别。

            第二： “并”，将原子级别的数两两合并排序，最后产生结果。

代码：

/**
 *  Copyright 2014 By Eclipse
 * 
 *  All right reserved
 *
 *  Created on 2014-2-8 下午1:08:42
 *
 *  By Administrator
 */
package com;

/**
 *  Copyright 2014 By Eclipse
 * 
 *  All right reserved
 *
 *  Created on 2014-2-8 下午1:08:42
 *
 *  By Administrator
 */
public class MergeSort {
         public static void main(String[] args){
        	 int[] a = {4545,5656,9, 8, 7, 6, 5, 4, 3, 2, 1};
        	 int[] tmp = null;
        	 mergeSort(a, tmp, 0, a.length-1);
        	 
        	 for(int i = 0; i< a.length; i++){
        		 System.out.println(a[i]);
        	 }
         }
         
         public static void mergeSort(int[] a, int[] tmpArray, int left, int right){
        	 if(left < right){
        		 int middle = (left + right) / 2;
        		 mergeSort(a, tmpArray, left, middle);
        		 mergeSort(a, tmpArray, middle + 1, right);
        		 merge(a, tmpArray, left, middle + 1, right);
        	 }
         }

		/**
		 * @param a
		 * @param left
		 * @param right
		 */
		private static void merge(int[] a, int[] tmpArray, int left, int middle, int right) {
			tmpArray = new int[right - left + 1];
			
			int leftEnd = middle - 1;
			int rightStart = middle;
			int index = 0;
			
			while(left <= leftEnd && rightStart <= right){
				if(a[left] > a[rightStart]){
					tmpArray[index++] = a[rightStart++];
				}else{
					tmpArray[index++] = a[left++];
				}
			}
			
			while(left <= leftEnd){
				tmpArray[index++] = a[left++];
			}
			
			while(rightStart <= right){
				tmpArray[index++] = a[rightStart++];
			}
			
			for(int i = tmpArray.length - 1; i >= 0 ; i--){
				a[right] = tmpArray[i];
				right--;
			}
		}
}