排序算法（java）（持续更新）

---

前言

文章主要用于记录自己学习笔记和理解，如有错误欢迎指出，与君共勉

此文章内容会持续完善，欢迎关注^ _ ^

---

一、冒泡排序

基本思想：
冒泡排序，类似于水中冒泡，较大的数沉下去，较小的数慢慢冒起来，假设从小到大，即为较大的数慢慢往后排，较小的数慢慢往前排。

直观表达，每一趟遍历，将一个最大的数移到序列末尾。

算法过程：

• 比较相邻的元素，如果前一个比后一个大，交换之
• 第一趟排序第1个和第2个一对，比较与交换，随后第2个和第3个一对比较交换，这样直到倒数第2个和最后1个，将最大的数移动到最后一位
• 第二趟将第二大的数移动至倒数第二位
• 以此类推…

    public int[] bubbleSort(int[] arr){
        if(arr == null || arr.length<2)return arr;
        //冒泡次数
        for (int i = 0; i < arr.length-1; i++) {
            //是否有序标志
            boolean flag = true;
            //冒泡步骤，两两比较，满足条件则按照顺序交换位置
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    arr[j+1]^=arr[j];
                    arr[j]^=arr[j + 1];
                    arr[j+1]^=arr[j];
                    //进行过交换，则代表数据本来是无序的,
                    flag = false;
                }
            }
            //如果一次冒泡过程没有发生过交换，则说明本身就是有序的，可以跳过后续的冒泡排序
            if(flag)break;
        }
        return arr;
    }

二、选择排序

基本思想：
首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到第二个元素位置。以此类推，直到所有元素均排序完毕。
算法过程：

• 比较未排序的元素，取最小的放到未排序的起始位置
• 第一趟排序，所有的元素挨个比较，找出最小的元素，与第一个元素做交换
• 第二趟排序，第二个元素到最后一个元素中，找出最小的元素，与第二个元素做交换
• 以此类推…

    //方法一
    public int[] selectSort1(int[] arr){
        if(arr == null || arr.length<2)return arr;
        for (int i = 0; i < arr.length - 1; i++) {
            int index = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[j] < min){
                    index = j;
                    min = arr[j];
                }
            }
            if(index != i){
                arr[i]^=arr[index];
                arr[index]^=arr[i];
                arr[i]^=arr[index];
            }
        }
        return arr;
    }
    //方法二跟冒泡排序差不多
    public int[] selectSort2(int[] arr){
        if(arr == null || arr.length<2)return arr;
        for (int i = 0; i < arr.length - 1; i++) {
            int index = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[j] < min){
                  arr[i]^=arr[j];
                  arr[j]^=arr[i];
                  arr[i]^=arr[j];
                }
            }
        }
        return arr;
    }

三、插入排序

基本思想：
插入排序是指在待排序的元素中，假设前面n-1(其中n>=2)个数已经是排好顺序的，现将第n个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程，称为插入排序 。
算法过程：

• 1.从第一个元素开始，该元素可以认为已经被排序
• 2.取下一个元素tem，从已排序的元素序列从后往前扫描
• 3.如果该元素大于tem，则将该元素移到下一位
• 4.重复步骤3，直到找到已排序元素中小于等于tem的元素
• 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置
• 重复2-5步骤，以此类推

	//写法一
    public int[] insertSort1(int[] arr){
        if(arr == null || arr.length<2)return arr;
        for (int i = 1; i < arr.length; i++) {
            int cur = arr[i];
            for (int j = i-1; j >-1; j--) {
                if(cur<arr[j]){
                    arr[j+1]=arr[j];
                }else{
                    arr[j+1]=cur;
                    break;
                }
                if(j == 0)arr[0] = cur;
            }
        }
        return arr;
    }
	//写法二
    public int[] insertSort2(int[] arr){
        if(arr == null || arr.length<2)return arr;
        for (int i = 1; i < arr.length; i++) {
            int cur = arr[i];
            int index = i;
            while(index>0 && cur<arr[index-1]){
                index--;
                arr[index+1]=arr[index];
            }
            arr[index] = cur;
        }
        return arr;
    }

四、希尔排序

基本思想：
写入排序又叫分组插入排序，它是在插入排序的基础上做了优化。先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

一般初次取序列的一半为增量，以后每次减半，直到增量为1。
算法过程如下图：

如图，
1.先计算增量长度，按照增量做分组
2.相同组内进行插入排序
3.重复步骤1-2，每次增量为上次增量的一半，直到增量为1后，进行一次插入排序为止

    public int[] shellSort(int[] arr){
        if(arr == null || arr.length<2)return arr;
        for (int length = arr.length/2; length>0 ; length/=2) {
            for (int i = length; i < arr.length; i++) {
                int cur = arr[i];
                int index = i;
                while(index-length>=0 && cur<arr[index-length]){
                    index-=length;
                    arr[index + length] = arr[index];
                }
                arr[index] = cur;
            }
        }
        return arr;
    }

五、快速排序

基本思想：
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选
用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

算法过程：

• 1 设置两个变量i、j，排序开始的时候：i=0，j=N-1；
• 2 以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
• 3 从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；
• 4 从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；
• 5 重复第3、4步，直到 i= =j；(3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。