Java几种常见的排序算法

　一、所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。

　　二、排序算法可以分为内部排序和外部排序。

　　　　内部排序是数据记录在内存中进行排序。

　　　　外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

　　　　常见的内部排序算法有:冒泡排序, 选择排序,插入排序,希尔排序,快速排序,归并排序等.

当然：实际的排序算法可不止这么一点，如果像了解其他算法可以参考：https://baike.baidu.com/item/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/5399605?fr=aladdin#3

　三、这里主要介绍常见的几种排序算法

　　1) 冒泡排序low版本

　　a、冒泡排序，是通过每一次遍历获取最大/最小值

　　b、将最大值/最小值放在尾部/头部

　　c、然后除开最大值/最小值，剩下的数据在进行遍历获取最大/最小值

　　d、代码实现

public class MaoPao {

    public static void  sort(int[] arr){
        for (int i = 1; i < arr.length; i++) {  //第一层for循环,用来控制冒泡的次数
            for (int j = 0; j < arr.length-1; j++) { //第二层for循环,用来控制冒泡一层层到最后
                //如果前一个数比后一个数大,两者调换 ,意味着泡泡向上走了一层
                if (arr[j] > arr[j+1] ){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

 冒泡的bigger版本

在这个版本中,改动了两点
第一点是加入了一个布尔值,判断第二层循环中的调换有没有执行,如果没有进行两两调换,说明后面都已经排好序了,已经不需要再循环了,直接跳出循环,排序结束.
第二点是第二层循环不再循环到arr.length - 1,因为外面的i循环递增一次,说明数组最后就多了一个排好序的大泡泡.第二层循环也就不需要到最末尾一位了,可以提前结束循环

/**
 * 终极版冒泡排序
 * 加入一个布尔变量,如果内循环没有交换值,说明已经排序完成,提前终止
 * @param arr
 */
public static void sortPlus(int[] arr){
    if(arr != null && arr.length > 1){
        for(int i = 0; i < arr.length - 1; i++){
            // 初始化一个布尔值
            boolean flag = true;
            for(int j = 0; j < arr.length - i - 1 ; j++){
                if(arr[j] > arr[j+1]){
                    // 调换
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    // 改变flag
                    flag = false;
                }
            }
            if(flag){
                break;
            }
        }
    }
}

　　2）选择排序

　   a、将第一个值看成最小值

　　b、然后和后续的比较找出最小值和下标

　　c、交换本次遍历的起始值和最小值

　　d、说明：每次遍历的时候，将前面找出的最小值，看成一个有序的列表，后面的看成无序的列表，然后每次遍历无序列表找出最小值。

　　e、代码实现

public static void main(String[] args) {

        int arr[] = {6, 5, 3, 2, 4};

        //选择
        for (int i = 0; i < arr.length; i++) {
            //默认第一个是最小的。
            int min = arr[i];
            //记录最小的下标
            int index = i;
            //通过与后面的数据进行比较得出，最小值和下标
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    min = arr[j];
                    index = j;
                }
            }
            //然后将最小值与本次循环的，开始值交换
            int temp = arr[i];
            arr[i] = min;
            arr[index] = temp;
            //说明：将i前面的数据看成一个排好的队列，i后面的看成一个无序队列。每次只需要找无需的最小值，做替换
        }
    }

　　3）插入排序

　    a、默认从第二个数据开始比较。

　　b、如果第二个数据比第一个小，则交换。然后在用第三个数据比较，如果比前面小，则插入（狡猾）。否则，退出循环

　　c、说明：默认将第一数据看成有序列表，后面无序的列表循环每一个数据，如果比前面的数据小则插入（交换）。否则退出。

　　d、代码实现

public static void main(String[] args) {

        int arr[] = {7, 5, 3, 2, 4};

        //插入排序
        for (int i = 1; i < arr.length; i++) {
            //外层循环，从第二个开始比较
            for (int j = i; j > 0; j--) {
                //内存循环，与前面排好序的数据比较，如果后面的数据小于前面的则交换
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = temp;
                } else {
                    //如果不小于，说明插入完毕，退出内层循环
                    break;
                }
            }
        }
    }

　　4）希尔排序（插入排序变种版）

　　a、基本上和插入排序一样的道理

　　b、不一样的地方在于，每次循环的步长，通过减半的方式来实现

　　c、说明：基本原理和插入排序类似，不一样的地方在于。通过间隔多个数据来进行插入排序。

　　d、代码实现

public static void main(String[] args) {

        int arr[] = {7, 5, 3, 2, 4};

        //希尔排序（插入排序变种版）
        for (int i = arr.length / 2; i > 0; i /= 2) {
            //i层循环控制步长
            for (int j = i; j < arr.length; j++) {
                //j控制无序端的起始位置
                for (int k = j; k > 0  && k - i >= 0; k -= i) {
                    if (arr[k] < arr[k - i]) {
                        int temp = arr[k - i];
                        arr[k - i] = arr[k];
                        arr[k] = temp;
                    } else {
                        break;
                    }
                }
            }
            //j,k为插入排序，不过步长为i
        }
    }

5)堆排序(后补的)

堆排序时间复杂度(O(nlogn)),不是稳定的排序法.空间复杂度O(1).

关于堆排序可自行在网上搜索详细步骤,这里只是附上代码:

public static void main(String[] args) {
        int[] arr = {1,3,9,7,3,5,0,25,15,34};
        heapSort(arr);
        for(int i = 0 ; i < arr.length;i++) {
            System.out.println("排序后: "+arr[i]);
        }
    }
    private static void heapSort(int[] arr) {
        if(arr == null || arr.length <=1) {
            return;
        }
        //建立最大堆;
        buildMaxHeap(arr);

        for(int i = arr.length-1;i>=1;i--) {
            //最大的在0位置,那么,每次交换最大值放到最后面.
            swap(arr,0,i);
            //获取0位置最大值
            maxHeap(arr,i,0);
        }
    }
    //创建大堆
    private static void buildMaxHeap(int[] arr) {

        int half = (arr.length-1)/2;//树知道一半,其他的节点就都知道
        //从向想上遍历
        for(int i = half;i>=0;i--) {
            //大堆
            maxHeap(arr,arr.length,i);
        }
    }

    private static void maxHeap(int[] arr, int heapSize, int index) {
        int left =2*index+1 ;
        int right = 2*index+2;
        int largest = index;

        if(left < heapSize && arr[left] > arr[index]) {
            largest = left;
        }
        if(right < heapSize && arr[right] > arr[largest]) {
            largest = right;
        }
        if(index != largest) {
            swap(arr,largest,index);
            maxHeap(arr,heapSize,largest);
        }

    }

    private static void swap(int[] arr, int index1, int index2) {
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }

6）快速排序

　　a、确认列表第一个数据为中间值，第一个值看成空缺（低指针空缺）。

　　b、然后在剩下的队列中，看成有左右两个指针（高低）。

　　c、开始高指针向左移动，如果遇到小于中间值的数据，则将这个数据赋值到低指针空缺，并且将高指针的数据看成空缺值（高指针空缺）。然后先向右移动一下低指针，并且切换低指针移动。

　　d、当低指针移动到大于中间值的时候，赋值到高指针空缺的地方。然后先高指针向左移动，并且切换高指针移动。重复c、d操作。

　　e、直到高指针和低指针相等时退出，并且将中间值赋值给对应指针位置。

　　f、然后将中间值的左右两边看成行的列表，进行快速排序操作。

　　g、代码实现

public class Sort {
     public static void main(String[] args) {

        int arr[] = {7, 5, 3, 2, 4, 1, 8, 9, 6};

        //快速排序
        int low = 0;
        int high = arr.length - 1;
        quickSort(arr, low, high);
    }
    public static void quickSort(int[] arr,int begin,int end) {
        //先定义两个参数接收排序起始值和结束值
        int a = begin;
        int b = end;
        //先判断a是否大于b

        if (a >= b) {
            //没必要排序
            return;
        }
        //基准数,默认设置为第一个值
        int x = arr[a];

        //循环
        while (a < b) {
            //从后往前找,找到一个比基准数x小的值,赋给arr[a]
            //如果a和b的逻辑正确--a<b ,并且最后一个值arr[b]>x,就一直往下找,直到找到后面的值大于x
            while (a < b && arr[b] >= x) {
                b--;
            }
            //跳出循环,两种情况,一是a和b的逻辑不对了,a>=b,这时候排序结束.二是在后面找到了比x小的值
            if (a < b) {
                //将这时候找到的arr[b]放到最前面arr[a]
                arr[a] = arr[b];
                //排序的起始位置后移一位
                a++;
            }

            //从前往后找,找到一个比基准数x大的值,放在最后面arr[b]
            while (a < b && arr[a] <= x) {
                a++;
            }
            if (a < b) {
                arr[b] = arr[a];
                //排序的终止位置前移一位
                b--;
            }
        }
        //跳出循环 a < b的逻辑不成立了,a==b重合了,此时将x赋值回去arr[a]
        arr[a] = x;
        //调用递归函数,再细分再排序
        quickSort(arr,begin,a-1);
        quickSort(arr,a+1,end);
    }
}

//另一种表达快排
public static void quickSort(int[] arr) {
    qsort(arr, 0, arr.length - 1);
}

private static void qsort(int[] arr, int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high);        // 将数组分为两部分
        qsort(arr, low, pivot - 1);                   // 递归排序左子数组
        qsort(arr, pivot + 1, high);                  // 递归排序右子数组
    }
}

private static int partition(int[] arr, int low, int high) {
    int pivot = arr[low];               // 枢轴记录
    while (low < high) {
        while (low < high && arr[high] >= pivot) --high;
        arr[low] = arr[high];           // 交换比枢轴小的记录到左端
        while (low < high && arr[low] <= pivot) ++low;
        arr[high] = arr[low];           // 交换比枢轴小的记录到右端
    }
    // 扫描完成，枢轴到位
    arr[low] = pivot;
    // 返回的是枢轴的位置
    return low;
}

　　7）归并排序

　　a、将列表按照对等的方式进行拆分

　　b、拆分小最小快的时候，在将最小块按照原来的拆分，进行合并

　　c、合并的时候，通过左右两块的左边开始比较大小。小的数据放入新的块中

　　d、说明：简单一点就是先对半拆成最小单位，然后将两半数据合并成一个有序的列表。

　　e、代码实现

public static void main(String[] args) {

        int arr[] = {7, 5, 3, 2, 4, 1，6};

        //归并排序
        int start = 0;
        int end = arr.length - 1;
        mergeSort(arr, start, end);
    }

    public static void mergeSort(int[] arr, int start, int end) {
        //判断拆分的不为最小单位
        if (end - start > 0) {
            //再一次拆分，知道拆成一个一个的数据
            mergeSort(arr, start, (start + end) / 2);
            mergeSort(arr, (start + end) / 2 + 1, end);
            //记录开始/结束位置
            int left = start;
            int right = (start + end) / 2 + 1;
            //记录每个小单位的排序结果
            int index = 0;
            int[] result = new int[end - start + 1];
            //如果查分后的两块数据，都还存在
            while (left <= (start + end) / 2 && right <= end) {
                //比较两块数据的大小，然后赋值，并且移动下标
                if (arr[left] <= arr[right]) {
                    result[index] = arr[left];
                    left++;
                } else {
                    result[index] = arr[right];
                    right++;
                }
                //移动单位记录的下标
                index++;
            }
            //当某一块数据不存在了时
            while (left <= (start + end) / 2 || right <= end) {
                //直接赋值到记录下标
                if (left <= (start + end) / 2) {
                    result[index] = arr[left];
                    left++;
                } else {
                    result[index] = arr[right];
                    right++;
                }
                index++;
            }
            //最后将新的数据赋值给原来的列表，并且是对应分块后的下标。
            for (int i = start; i <= end; i++) {
                arr[i] = result[i - start];
            }
        }
    }

//个人感觉这个更好理解
public static void main(String[] args) {
         int[] arr = {1,3,9,7,3,5,-3,0,25,15,34};
         mergeSort(arr,0,arr.length-1);
         for(int i = 0 ; i < arr.length;i++) {
                System.out.println(arr[i]);
         }
    }
    public static void mergeSort(int[] a,int left,int right) {
        if(left < right) {
            int middle = (left+right)/2;
            mergeSort(a,left,middle);
            mergeSort(a,middle+1,right);
            merge(a,left,middle,right);//合并
        }
    }

    private static void merge(int[] a, int left, int middle, int right) {
        int[] tempArray = new int[a.length];
        int rightStart = middle+1;
        int tmp = left;
        int index = left;
        //比较两个小数组相应下标位置数组的大小,小的先放进新数组
        while(left <= middle && rightStart <= right) {
            if(a[left] <= a[rightStart]) {
                tempArray[index++] = a[left++];
            }else {
                tempArray[index++] = a[rightStart++];
            }
        }

        while(left <= middle) {
            //左边剩下的拷贝剩余的数
            tempArray[index++] = a[left++];
        }
        while(rightStart <= right) {
            //拷贝剩余的数
            tempArray[index++] = a[rightStart++];
        }

        while(tmp <= right) {
            a[tmp] = tempArray[tmp++];
        }
    }

归并(后补的,更好理解)

　　7)其他排序

比如Arrays工具类提供的排序方法。它内部实现也是快速排序

private static void arraysSort(int[] a){
    Arrays.sort(a);
  }

还有就是将数组转为list,使用集合的排序方法,但是这无异于兜圈子,因为集合底层也是数组

private static void listSort(int[] a){
    List<Integer> integers = Ints.asList(a);
    Collections.sort(integers);
    integers.toArray(new Integer[a.length]);
  }

参考博客:https://www.cnblogs.com/ll409546297/p/10956960.html