经典排序算法

直接插入排序(Straight Insertion Sort)

思想：每一趟将一个待排序的记录，按照其关键字的大小向前查找，插入到有序队列的合适位置里，直到所有记录插入完成。

如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的

	//插入排序
	/***
	 * temp作为哨兵，一直向前找，知道找到一个比temp小的位置；
	 * 将身后的元素一次后移，再把temp插入到当前位置
	 * @param array
	 */
	public static void InsertSort(int[] array)
	{
		for(int i = 1; i <= array.length - 1; i++)
		{
			if(array[i] < array[i - 1])
			{
				int temp = array[i]; 
				int j = i - 1;
				while(j > -1 && temp < array[j])
				{
					array[j + 1] = array[j];
					j--;
				}
				array[j + 1] = temp;
			}
		}
	}
	

　　

 希尔排序(Shell Sort)

思想：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量

  =1(  <  …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

public static void ShellSort(int[] array, int dis)
    {
        for(int dk = dis; dk >= 1; dk = dk / 2)
        {
            for(int i = dk; i < array.length; i++)
            {
                if(array[i] < array[i - dk])
                {
                    int temp = array[i];
                    int j = i - dk;
                    while(j > -1 && temp < array[j])
                    {
                        array[j + dk] = array[j];
                        j -= dk;
                    }
                    array[j + dk] = temp;
                }
            }
        }
    }
    

选择排序(Selection Sort)

思想：在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

    public static void SelectSort(int[] array)
    {
        for(int i = 0; i < array.length; i++)
        {
            int min = array[i];
            int index = i;
            for(int j = i; j < array.length; j++)
            {
                if(array[j] < min)
                {
                    min = array[j];
                    index = j;
                }
            }
            if(i != index)
            {
                int temp = array[i];
                array[i] = min;
                array[index] = temp;
            }
        }
    }

冒泡排序(Bubble Sort)

思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换

冒泡排序算法的运作如下：（从后往前）

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

/**
     * 冒泡排序
     * 在要排序的一组数中，对当前还未排好序的范围内的全部数，
     * 自上而下对相邻的两个数依次进行比较和调整，
     * 让较大的数往下沉，较小的往上冒。
     * 即：每当两相邻的数比较后发现它们的排序与排序要求相反时，
     * 就将它们互换
     * @param a
     */
    public static void BubbleSort(int[] array)
    {
        for(int i = 0; i < array.length; ++i)
        {
            for(int j = 0; j < array.length - i - 1; j++)
            {
                if(array[j] > array[j + 1])
                {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
    }

快速排序(QuickSort)

思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

方法：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

    /**
     * @param a
     */
    public static void QuickSort(int[] array, int low, int high)
    {
        if(low < high)
        {
            int piv = partition(array, low, high);
            QuickSort(array, low, piv - 1);
            QuickSort(array, piv + 1, high);
        }
        
    }
    public static  int partition(int[] array, int low, int high)
    {
        int pivKey = array[low];
        while(low < high)
        {
            while(low < high && pivKey < array[high])
                --high;
            pivKey = pivKey + array[high];//此三行是为了交换两个变量的值。。。。。
            array[high] = pivKey - array[high];
            pivKey = pivKey - array[high];
            while(low < high && pivKey > array[low])
                ++low;
            pivKey = pivKey + array[low];
            array[low] = pivKey - array[low];
            pivKey = pivKey - array[low];
        }
        return low;
    }