各种排序算法

githuab链接：

https://github.com/William-Hai/ArraySortAlgorithm

插入排序

直接插入排序

详解链接：

http://blog.csdn.net/lemon_tree12138/article/details/50968422

回忆：
时间复杂度？（三种），空间复杂度，稳定性？
外层循环多少次？内层主要功能？循环条件？

public static void insertSort(int[] arr){
        for(int i=1;i<arr.length;i++){//插入次数
            int j=i-1;
            int waitinsert = arr[i];//待插入元素
            while(j>=0 && arr[j]>waitinsert){//比较大小是否后移,j-1是比较的索引
                arr[j+1]=arr[j];//后移
                j--;
            }
            arr[j+1]=waitinsert;//后移后，指针前移了。所以j+1
        }
}

int[] a= {4,3,6,5,9,0,8,1,7,2};
3 4 6 5 9 0 8 1 7 2 //    a[1]
3 4 5 6 9 0 8 1 7 2 //    a[3](a[2]有序不插入)
0 3 4 5 6 9 8 1 7 2 //    a[5](a[4]有序不插入)
0 3 4 5 6 8 9 1 7 2 //    a[6]
0 1 3 4 5 6 8 9 7 2 //    a[7]
0 1 3 4 5 6 7 8 9 2 //    a[8]
0 1 2 3 4 5 6 7 8 9 //    a[9]

---

希尔排序

参考链接1：
http://www.cnblogs.com/jingmoxukong/p/4303279.html
参考链接2：
http://blog.csdn.net/lemon_tree12138/article/details/51127533

gap=5时，即分5组：
{9,4}
{1,8}
…
（从上述两个5看出，不稳定）
从插入排序到希尔排序的演变

1. 缩小增量排序，每个组中采用插入排序。
2. 增量为1时结束排序。

比直接插入多以下步骤：
1.首先设定步长，然后while循环，指只到步长为1；
2.接下来相当于步长次的直接插入操作；
3.接下来写直接插入排序即可，只是步长不是1了。

public static void shellSort(int[] arr){
        int gap = arr.length/3+1;
        //int gap=arr.length/2;
        while(gap>=1){

            for(int k=0;k<gap;k++){//1.确定插入排序的次数，步长gap，即gap次

                //2.对于其中的每一次，从后一次开始，以下是直接插入排序
                for(int i=gap+k;i<arr.length;i=i+gap){
                    //3.将待插入的元素存为临时变量
                    int waitinsert=arr[i];
                    int j=i-gap;//第一次比较，从j前一个元素开始
                    while(j>=0 && arr[j]>waitinsert){
                        arr[j+gap]=arr[j];
                        j=j-gap;
                    }
                    arr[j+gap]=waitinsert;
                }

            }
            System.out.println(Arrays.toString(arr));
            if(gap==1) break;
            gap=gap/3+1;
            //gap=gap/2;
        }
    }

    public static void main(String[] args) {
        int[] a={4,3,6,5,9,0,8,1,7,2};
        shellSort(a);
    }

[4, 0, 6, 1, 7, 2, 8, 5, 9, 3]
[4, 0, 6, 1, 7, 2, 8, 3, 9, 5]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

选择排序

算法原理

重点：选择交换

(1)从待排序序列中，找到关键字最小的元素；

(2)如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；

(3)从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束。

算法实现

public static void simpleSelect(int[] arr) {
    for(int i=0;i<arr.length;i++){//遍历次数,第i个元素与后边所有的比

        int minIndex=i;
        for(int j=i+1;j<arr.length;j++){//找一个最小的位置
            if(arr[j]<arr[minIndex]){
                minIndex=j;
            }
        }

        if(i!=minIndex){//本身不是最小的，就交换
            int t=arr[minIndex];
            arr[minIndex]=arr[i];
            arr[i]=t;
        }
    }
}

算法复杂度

交换排序

冒泡排序

算法原理

冒泡排序（Bubble Sort）是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　— 《大话数据结构》
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

算法实现

public static void bubble(int[] arr){
    for(int i=1;i<arr.length;i++){
        for(int j=0;j<arr.length-i;j++){
            if(arr[j+1]<arr[j]){
                int t=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=t;
            }
        }
    }
}

算法复杂度

排序方法	时间复杂度			空间复杂度	稳定性	复杂性
	平均情况	最坏情况	最好情况
冒泡排序（教科书版）	O(n2)	O(n2)	O(n)	O(1)	稳定	简单

快速排序

算法原理

基准数、左游标、右游标

分析1：

首先设置一个临时变量用来存放随机取出数组中的一个数，一般我们取数组的第一个元素也就是说temp=a[0]，同时设置两个游标分别指向数组第一个元素和最后一个元素。

算法的基本运算步骤为：

1. 依次比较数组的后游标所指与temp的大小，如果temp< a[j]，则j–，直到遇到第一个temp>a[j]，则停止移动

2. 依次比较数组的前游标所指与temp的大小，如果temp > a[i]，则i++，直到遇到第一个temp < a[i]，则停止移动

3. a[i]与a[j]交换

4. 判断i是否等于j，如果不相等则循环1、2、3步，直到i等于j，则完成一次快速排序。

分析2：

分别从初始序列“6 1 2 7 9 3 4 5 10 8”两端开始“探测”。
先从右往左找一个小于6的数，再从左往右找一个大于6的数，然后交换他们。这里可以用两个变量i和j，分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“哨兵i”和“哨兵j”。刚开始的时候让哨兵i指向序列的最左边（即i=0），指向数字6。让哨兵j指向序列的最右边，指向数字8。

首先哨兵j开始出动。因为此处设置的基准数是最左边的数，所以需要让哨兵j先出动，这一点非常重要（请自己想一想为什么）。哨兵j一步一步地向左挪动（即j–），直到找到一个小于6的数停下来。
接下来哨兵i再一步一步向右挪动（即i++），直到找到一个数大于6的数停下来。最后哨兵j停在了数字5面前，哨兵i停在了数字7面前。

现在交换哨兵i和哨兵j所指向的元素的值。交换之后的序列如下：
6 1 2 5 9 3 4 7 10 8

到此，第一次交换结束。接下来开始哨兵j继续向左挪动（再友情提醒，每次必须是哨兵j先出发）。他发现了4（比基准数6要小，满足要求）之后停了下来。哨兵i也继续向右挪动的，他发现了9（比基准数6要大，满足要求）之后停了下来。此时再次进行交换，交换之后的序列如下：

6 1 2 5 4 3 9 7 10 8

第二次交换结束，“探测”继续。哨兵j继续向左挪动，他发现了3（比基准数6要小，满足要求）之后又停了下来。哨兵i继续向右移动，糟啦！此时哨兵i和哨兵j相遇了，哨兵i和哨兵j都走到3面前。说明此时“探测”结束。我们将基准数6和3进行交换。交换之后的序列如下：

3 1 2 5 4 6 9 7 10 8

到此第一轮“探测”真正结束。此时以基准数6为分界点，6左边的数都小于等于6，6右边的数都大于等于6。回顾一下刚才的过程，其实哨兵j的使命就是要找小于基准数的数，而哨兵i的使命就是要找大于基准数的数，直到i和j碰头为止。

OK，解释完毕。现在基准数6已经归位，它正好处在序列的第6位。此时我们已经将原来的序列，以6为分界点拆分成了两个序列，左边的序列是“3 1 2 5 4”，右边的序列是“9 7 10 8”。接下来还需要分别处理这两个序列。因为6左边和右边的序列目前都还是很混乱的。不过不要紧，我们已经掌握了方法，接下来只要模拟刚才的方法分别处理6左边和右边的序列即可。

参考链接：
http://blog.csdn.net/yzllz001/article/details/50982841　　　　　　　　　　　　

算法实现

实现重点：基准数、左游标、右游标

public static void fastSort(int[] a, int leftIndex,int rightIndex){

        if(leftIndex>=rightIndex){//很重要，递归结束条件
            return;
        }

        int key=a[leftIndex];//基准数选取，选法有很多
        int i=leftIndex;
        int j=rightIndex;
        while(i!=j){
            while(a[j]>=key && i<j){
                j--;
            }
            while(a[i]<=key && i<j){
                i++;
            }
            if(i<j){
                int t=a[i];
                a[i]=a[j];
                a[j]=t;
            }
        }
        //while执行完毕，即i=j时，基数归位
        a[leftIndex]=a[i];
        a[i]=key;

        //继续处理左边的和右边的，递归过程
        fastSort(a, leftIndex, i-1);
        fastSort(a, i+1, rightIndex);

    }
    public static void main(String[] args) {
        int[] a={4,3,6,5,9,0,8,1,7,2};
        fastSort(a, 0, 9);
        System.out.println(Arrays.toString(a));
    }