java中常见的排序算法

近期闲来无事，索性就整理下java中常见或常用的排序算法。

1.冒泡排序：这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

由于是相邻的两个元素比较，交换也发生在这两个元素之间。两个元素相等前后顺序并没有发生改变，所以冒泡排序是一种稳定的排序算法。

   

 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]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

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

比如序列5 3 3 4 3 8 9 10 11， 
现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱 ，不稳定发生在中枢元素和a[j]交换的时刻，所以快速排序是一个不稳定的排序算法。

public static void quicklySort(int[] arr, int first, int last) {
        //递归出口
        if (first > last) {
            return;
        }
        //左侧下标
        int left = first;
        //右侧下标
        int right = last;
        //基准值
        int temp = arr[first];
        while (left != right) {
            //先从右侧比较是否有小于基准值
            while (arr[right] >= temp && left < right) {
                right--;
            }
            //再从左侧比较是否有大于基准值
            while (arr[left] <= temp && left < right) {
                left++;
            }
            //如果左右侧出现上述情况，则交换左右位置
            if (left < right) {
                int t = arr[left];
                arr[left] = arr[right];
                arr[right] = t;
            }
        }
    
           arr[first] = arr[left];
           arr[left] = temp;
        
        //对左侧数据进行递归排序
        quicklySort(arr, first, left - 1);
        //对右侧数据进行递归排序
        quicklySort(arr, left + 1, last);
    }

3.插入排序：要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序。

遇见一个和插入元素相等的，那么插入元素时，只是把要插入的元素放在相等元素的后面，所以相等元素的前后位置并未发生改变，所以插入排序是一种稳定的排序算法。

 public static void insertSort(int[] arr) {
        //要插入的数
        int num = 0;
        //因为第一次不用插入，所以从1开始
        for (int i = 1; i < arr.length; i++) {
            num = arr[i];
            //序列元素个数
            int j = i - 1;
            //从后往前循环，若arr[j]大于num则向后移动
            while (j >= 0 && arr[j] > num) {
                arr[j + 1] = arr[j];
                j--;
            }
            //找到位置，插入当前元素
            arr[j + 1] = num;
        }
    }

4.选择排序：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了

例如：序列3 8 3 2 9，我们知道第一遍选择第1个3会和2交换，那么原序列中两个3的相对前后顺序就被破坏了，所以选择排序是一种不稳定排序算法。

public static void selectSort(int[] arr) {
        //首先确定循环次数，并且记住当前数字和当前位置。
        for (int i = 0; i < arr.length - 1; i++) {
            //假设 temp为最小值下标
            int temp = i;
            //每一轮开始先和那个元素开始比较 i+1
            for (int j = i + 1; j < arr.length; j++) {
                //记下目前找到的最小值所在的位置
                if (arr[j] < arr[temp]) {
                    temp = j;
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if (i != temp) {
                int n = arr[i];
                arr[i] = arr[temp];
                arr[temp] = n;
            }
        }
    }