排序算法

快速排序
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
动图演示

代码实现

  public static void quickSort(int[] arr,int left,int right){
        int l = left; //左下标
        int r = right; //右下标
        //pivot 中轴值
        int pivot = arr[(left + right) / 2];
        int temp = 0;//临时变量 作为交换时使用
        //while 循环目的是让比pivot 值小的放到左边
        //比 pivot大的放右边
        while ( l < r){
            //在pivot左边一直找 直到找到比pivot大的值 就退出
            while (arr[l] < pivot){
                l += 1;
            }
            //在pivot右边一直找 直到找到比pivot小的值 就退出
            while (arr[r] > pivot){
                r -= 1;
            }
            //如果 l>=r 说明pivot 的左右值 已经按照左边全部是 小于等于pivot值。右边全部是 大于等于pivot值
            if(l >= r){
                break;
            }
            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            //交换完成后 发现arr[l] == pivot相等 --，前移
            if(arr[l] == pivot){
                r -= 1;
            }
            //交换完成后 发现arr[r] == pivot相等 ++，后移
            if(arr[r] == pivot){
                l += 1;
            }
        }
        //如果 l == r 必须l++ ， r-- ，否则就会栈溢出
        if(l==r){
            l += 1;
            r -= 1;
        }
        //向左递归
        if(left < r){
            quickSort(arr,left,r);
        }
        //向右递归
        if(right > l){
            quickSort(arr,l,right);
        }
    }

插入排序：
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

动图演示

代码实现

    public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length  ; i++) {
            int insertVal = arr[i];//要比较元素的位置
            int insertIndex = i - 1;//要比较的前一个元素
            
            //insertIndex >= 0 比较的前一个元素 防止下标越界
            //insertVal < arr[insertIndex] 如果要比较的元素 小于上个元素 就不用进入
            while (insertIndex >= 0 && insertVal < arr[insertIndex]){
                //如果要比较的元素 满足循环条件时 就将比较的元素替换为前一个元素
                //然后 --再找到替换后的前一个元素 进行比较 以此类推
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex --;
            }
            //比较完成后 循环条件不满足后 把比较的值替换了
            arr[insertIndex + 1] = insertVal;
        }
    }

选择排序：
选择排序(Selection-sort)是一种简单直观的排序算法。
它的工作原理：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
然后，再从剩余未排序元素中继续寻找最小（大）元素。
然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

动图演示

代码实现

    public static void selectSort(int[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i; //假定最小数下标
            int min = arr[i]; //假定最小值
            for (int j = i + 1; j < arr.length; j++) {
                //如果假定最小值 大于下一个比较的元素
                if(min > arr[j]){
                    min = arr[j]; //重置min 将小于假定最小值给替换
                    minIndex = j; //重置minIndex 将假定最小值下标也替换
                }
            }
            //如果最小值下标 就等于假定比较值 就说明假定的就是最小的 所以不用交换
            //如果不等于 就交换一下位置
            if(minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }

冒泡排序：

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

动图演示：

代码实现

    public static void bubbleSort(int[] arr){
        int temp = 0;
        //标识变量，表示是否交换过
        //优化冒泡 如果没有进行交换过 说明已经排序完成就不需要进行多余的比较了
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if(arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if(!flag){
                break; //如果没有交换过，说明已经排序完成
            } else{
                flag = false; //重置flag 进行下次判断
            }
        }
    }