算法-排序算法汇总

冒泡排序

思路：
采用的是双循环的方法，冒泡排序按照理解是吧大的往后移，每一循环一次将最大的
移到后面，最后一个位置即固定了。当然冒泡可以冒小泡，这样就是方向排序，排出来的是逆序

代码：

   /**
     * 冒泡排序
     * @param a
     */
    protected static void bubbleSort(int[] a) {
        for (int i = 1; i < a.length; i++) {
            for (int j = 0; i < a.length - j; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

优化：

待优化

插入排序

思路：
插入排序保证在插入的时候前面的数据是有序的（不能保证前面额数据顺序是最后的顺序）

1. 插入第一个时候，在之前是没有元素的，当前元素会认为自己是最小的元素
2. 后移一个元素，当前元素会和之前的元素比较（从最近的元素开始比较）
   2-1. 当前元素大于之前邻近的元素，那么位置就不会改变
   2-2.如果小于邻近的之前的元素，那么，就和之前的元素换位置（这样做会导致频繁的换位置，这里可以优化）

代码

    /**
     * 插入排序
     * @param a
     */
    public static void insertSort(int[] a) {
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0 && a[j] < a[j - 1]; j--) {
                int temp = a[j];
                a[j] = a[j - 1];
                a[j - 1] = temp;
            }
        }
    }

优化
待优化

快速排序

思路：
需要经过多次找中间值来进行排序。

1. 第一次从第一个元素开始排序，从右边第一个进行比较定义temp保存当前要比较的值
   1-1.如果右边一个比temp的值元素要大，那就right向左移动一个元素再进行比较
   1-2.如果右边一个元素比temp的值要小，那么就将temp所在的位置的值设置为比较的那个元素
   2.将temp的下表指到比较元素的那个下标
2. 从左边选第一个元素来和temp的值进行比较
   3-1.如果比较的值比temp的值要小，那么顺序就是对的，只需将left向右移动一位
   3-2.如果比较的值比temp的值要大，那么顺序就是错的，需要将temp的位置赋值比较的那个元素
   循环上面的步骤，当周到left >= right，即temp的左边一定小于temp，temp的右边一定大于temp。
   如下
   
   从上可以的知元素4的位置已经确定，再多次几次循环即可确定整个数组，上述排序每次执行完成
   只会确定一个元素的位置，在从中间元素进行分组左右，进行排序。
   代码：

/**
*获取中间值
**/
 protected static int findPos(int[] a, int low, int high){

        int temp = a[low];
        while (low<high){
            while (low<high && a[high]>=temp){
                high--;
            }
            a[low] = a[high];
            while (low<high && a[low]<=temp){
                low++;
            }
            a[high] = a[low];
        }
        a[low] = temp;
        return low;
    }
 
     //最终排序（完全顺序调用上面的quickSort方法）
    protected static void quickSort(int[] a, int low, int high){
        if (low>high){
            return;
        }
        int pos = findPos(a,low,high);
        quickSort(a,low,pos-1);
        quickSort(a,pos+1,high);
    }  

优化：
有待优化

希尔排序

思路
希尔排序是优化版的插入排序，
代码

public static int[] shellSort2(int a[]) {
        int step = a.length / 2;
        int temp = 0;
        while (step > 0) {
            //分成的组数,5-2,2-5,1-10
            for (int i = step; i < a.length; i++) {
                for (int j = i - step; j >= 0; j -= step) {
                    if (a[j] > a[j + step]) {
                        temp = a[j];
                        a[j] = a[j + step];
                        a[j + step] = temp;
                    }
                }
            }
            step = step / 2;
        }
        return a;
    }

/*移步法，*/
    public static int[] shellSort(int a[]) {
        for (int grap = a.length / 2; grap >= 1; grap /= 2) {
            for (int j = grap; j < a.length; j++) {
                if (a[j] <= a[j - grap]) {
                    int temp = a[j];
                    int k = j - grap;
                    while (k >= 0 && a[k] > temp) {
                        a[k + grap] = a[k];
                        k -= grap;
                    }
                    a[k + grap] = temp;
                }

            }
        }
        return a;
    }

优化