排序算法

排序一：直接插入排序

　　每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。

　　1、第一趟比较前两个数,然后把第二个数按大小插入到有序表中; 

　　2、第二趟把第三个数据与前两个数从前向后扫描，把第三个数按大小插入到有序表中；

　　3、依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。

　　直接插入排序属于稳定的排序，最坏时间复杂度为O(n^2)，空间复杂度为O(1)。

下面按从小到大排序：

public class Sort {
    public static void main(String[] args) {
        int[] data = { 31, 23, 89, 10, 47, 68, 8, 22 };
        insert_sort(data);
        showData(data);
    }
    
    //打印数组
    private static void showData(int[] data) {
        for (int i = 0; i < data.length; i++) {
            System.out.println(data[i]);
        }
    }

    // 直接插入排序
    private static void insert_sort(int[] data) {
        int t;
        int j;
        for (int i = 1; i < data.length; i++) {// i表示插入次数，共进行data.length-1次插入
            t = data[i];// 把待排序元素赋给t
            j = i-1;
            while ((j >= 0) && (t < data[j])) {
                data[j+1] = data[j];
                j--;
            }// 顺序比较和移动
            data[j+1] = t;
        }
    }
        
}

排序二：折半插入排序

　　折半插入排序是对插入排序算法的一种改进，由于排序算法过程中，就是不断的依次将元素插入前面已排好序的序列中。由于前半部分为已排好序的数列，这样我们不用按顺序依次寻找插入点，可以采用折半查找的方法来加快寻找插入点的速度。

　　具体操作：在将一个新元素插入已排好序的数组的过程中，寻找插入点时，将待插入区域的首元素设置为a[low]，末元素设置为a[high]，则轮比较时将待插入元素与a[m]，其中m=(low+high)/2相比较,如果比参考元素小，则选择a[low]到a[m-1]为新的插入区域(即high=m-1)，否则选择a[m+1]到a[high]为新的插入区域（即low=m+1），如此直至low<=high不成立，即将此位置之后所有元素后移一位，并将新元素插入a[high+1]。

下面按从小到大排序：

public class Sort {
    public static void main(String[] args) {
        int[] data = { 31, 23, 89, 10, 47, 68, 8, 22 };
        binarySearchInsertion(data);
        showData(data);
    }
    
    //打印数组
    private static void showData(int[] data) {
        for (int i = 0; i < data.length; i++) {
            System.out.println(data[i]);
        }
    }

    private static void binarySearchInsertion(int data[]) {
        int middle = 0;
        for (int i = 1; i < data.length; i++) {
            int low = 0;
            int high = i - 1;
            int t = data[i];
            while (low <= high) {
                middle = (low + high) / 2;
                if (t < data[middle]) {
                    high = middle - 1;
                }else {
                    low = middle + 1;
                }
            }
            for (int j = i; j > middle; j--) {
                data[j] = data[j-1];
            }
            data[high + 1] = t;// 此处用data[low] = t;也可
        }
    }    
}

序列：

　　　　　　   31 23 89 10 47 68 8 22

　　i = 1:　　23 31 89 10 47 68 8 22

　　i = 2:　　23 31 89 10 47 68 8 22

　　i = 3:　　10 23 31 89 47 68 8 22

　　i = 4:　　10 23 31 47 89 68 8 22

　　i = 5:　　10 23 31 47 68 89 8 22

　　i = 6:　　8 10 23 31 47 68 89 22

　　i = 7:　　8 10 22 23 31 47 68 89

　　这样数组从小到大就排序好了。

排序三：希尔排序

　　希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序

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

　　一般的初次取序列的一半为增量，以后每次减半，直到增量为1。

从小到大排序：

public class Sort {
    public static void main(String[] args) {
        int[] data = { 31, 23, 89, 10, 47, 68, 8, 22 };
        shell(data);
        showData(data);
    }
    
    //打印数组
    private static void showData(int[] data) {
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] +" ");
        }
    }

    // 希尔排序
        private static void shell(int data[]) {
            int k = data.length  / 2;// k值代表前文中的增量d值 , 一般的初次取序列的一半为增量，以后每次减半，直到增量为1
            int j;
            while (k >= 1) {// 当增量k值变化到0，结束循环……
                int t;
                for (int i = k; i < data.length; i++) {
                    t = data[i];
                    j = i - k;
                    while ((j >= 0) && (t < data[j])) {
                        data[j + k]  = data[j];
                        j = j - k;
                    }
                    data[j + k] = t;
                }
                k = k / 2;
            }
        }
}

序列：

31 23 89 10 47 68 8 22

31 23 89 10 47 68 8 22

31 23 89 10 47 68 8 22

31 23 8 10 47 68 89 22

31 23 8 10 47 68 89 22

8 23 31 10 47 68 89 22

8 10 31 23 47 68 89 22

8 10 31 23 47 68 89 22

8 10 31 23 47 68 89 22

8 10 31 23 47 68 89 22

8 10 31 22 47 23 89 68

8 10 31 22 47 23 89 68

8 10 31 22 47 23 89 68

8 10 22 31 47 23 89 68

8 10 22 31 47 23 89 68

8 10 22 23 31 47 89 68

8 10 22 23 31 47 89 68

8 10 22 23 31 47 68 89

最后排序也就出来了。

排序四：冒泡排序

冒泡排序算法：

　　1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。

　　2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

　　3、针对所有的元素重复以上的步骤，除了最后一个。

　　4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class Sort {
    public static void main(String[] args) {
        int[] data = { 31, 23, 89, 10, 47, 68, 8, 22 };
        bubbleSort(data);
        showData(data);
    }

    // 打印数组
    private static void showData(int[] data) {
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + " ");
        }
    }

    // 冒泡排序
    private static void bubbleSort(int[] data) {
        boolean exchange;// 交换标志
        int t;
        for (int i = 1; i < data.length; i++) {// 最多做n-1趟排序
            exchange = false;// 本趟排序开始前，交换标志应为假
            for (int j = 1; j <= data.length - i; j++) {
                // 对当前无序区R[i..n]自下向上扫描
                if (data[j] < data[j - 1]) {// 交换记录
                    t = data[j]; // t仅做暂存单元
                    data[j] = data[j - 1];
                    data[j - 1] = t;
                    exchange = true; // 发生了交换，故将交换标志置为真
                }
            }
            if (!exchange) {// 本趟排序未发生交换，提前终止算法
                return;
            }
        }
    }
}

排序五：快速排序

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

下面从小到大排序：

public class Sort {
    public static void main(String[] args) {
        int[] data = { 31, 23, 89, 10, 47, 68, 8, 22 };
        quickSort(data, 0, data.length - 1);
        showData(data);
    }

    // 打印数组
    private static void showData(int[] data) {
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + " ");
        }
    }

    // 快速排序
        private static void quickSort(int[] data, int low, int high) {
            // 对data[low..high]快速排序,low,high表示下标数
            int k;                // 划分后的基准记录的位置
            if (low < high) {    // 仅当区间长度大于1时才须排序
                k = quickPass(data, low, high);    // 对R[low..high]做划分
                quickSort(data, low, k - 1);    // 对左区间递归排序
                quickSort(data, k + 1, high);    // 对右区间递归排序
            }
        }
        
        private static int quickPass(int data[], int i, int j) {
            int t = data[i];    // 用区间的第1个记录作为基准
            while (i < j) {        // 从区间两端交替向中间扫描，直至i=j为止
                while (i < j && data[j] >= t) {    // t相当于在位置i上
                    j--;        // 从右向左扫描，查找第1个关键字小于t的记录data[j]
                }
                if (i < j) {    // 表示找到的data[j]的关键字<t
                    data[i++] = data[j];    // 相当于交换data[i]和data[j]，交换后i指针加1
                }
                while (i < j && data[i] <= t) {    // t相当于在位置j上
                    i++;        // 从左向右扫描，查找第1个关键字大于t的记录data[i]
                }
                if (i < j) {    // 表示找到了data[i]，使data[i]>t
                    data[j--] = data[i];    // 相当于交换data[i]和data[j]，交换后j指针减1
                }
            }
            data[i] = t;        // 基准记录已被最后定位
            return i;
        }
}

序列：

交换后：22 23 8 10 31 68 47 89 

交换后：10 8 22 23 31 68 47 89 

交换后：8 10 22 23 31 68 47 89 

交换后：8 10 22 23 31 47 68 89 

最后快速排序就结束了，从小到大为：8 10 22 23 31 47 68 89 。