各种排序算法

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(n²) O(n²) 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));    }