Java实现：排序算法汇总

巨齿小鲨

已于 2022-04-22 16:46:24 修改

阅读量620

点赞数

分类专栏：数据结构和算法 Java 文章标签： java 数据结构排序算法

于 2022-04-16 10:18:29 首次发布

本文链接：https://blog.csdn.net/m0_63211569/article/details/124208019

版权

Java 同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

数据结构和算法

10 篇文章 0 订阅

订阅专栏

O(n^2)

选择排序是不稳定的，冒泡排序、插入排序是稳定的；
在这三个排序算法中，选择排序交换的次数是最少的；
在数组几乎有序的情况下，插入排序的时间复杂度接近线性级别。

冒泡

一边比较一边向后两两交换，将最大值 / 最小值冒泡到最后一位；

经过优化的写法：使用一个变量记录当前轮次的比较是否发生过交换，如果没有发生交换表示已经有序，不再继续排序；

public static void bubbleSort(int[] arr) {
    // 初始时 swapped 为 true，否则排序过程无法启动
    boolean swapped = true;
    for (int i = 0; i < arr.length - 1; i++) {
        // 如果没有发生过交换，说明剩余部分已经有序，排序完成
        if (swapped==false) break;
        // 设置 swapped 为 false，如果发生交换，则将其置为 true
        swapped = false;
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // 如果左边的数大于右边的数，则交换，保证右边的数字最大
                swap(arr, j, j + 1);
                // 表示发生了交换
                swapped = true;
            }
        }
    }
}
// 交换元素
private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

选择

简单选择排序

选择排序的思想是：双重循环遍历数组，每经过一轮比较，找到最小元素的下标，将其交换至首位


public static void selectionSort(int[] arr) {
    int minIndex;
    for (int i = 0; i < arr.length - 1; i++) {
        minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[minIndex] > arr[j]) {
                // 记录最小值的下标
                minIndex = j;
            }
        }
        // 将最小元素交换至首位
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

二元选择排序

class Solution {
    public int[] sortArray(int[] nums) {
        //二元选择排序
        //同时找最大最小值
        int min;
        int max;
        for(int i=0;i<nums.length/2;i++){
            min=i;
            max=i;
            //获取最大最小值下标
            for(int j=i+1;j<nums.length-i;j++){
                if(nums[j]<=nums[min]){
                    min=j;
                }
                if(nums[j]>nums[max]){
                    max=j;
                }
            }
            //当max=min时，必定为max=min=i，且[i,length-i]都等于nums[i]
            if(min==max) break;

            //交换最小值
            swap(nums,i,min);

            //当max=i时，此时i的值已经交换到min处
            if(max==i) max=min;

            //交换最大值
            swap(nums,nums.length-i-1,max);
        }
        return nums;
    }
    
    //交换
    public void swap(int[] nums,int i,int j){
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
}

插入

在新数字插入过程中，与前面的数字不断比较，前面的数字不断向后挪出位置，当新数字找到自己的位置后，插入一次即可。

class Solution {
    public int[] sortArray(int[] nums) {
        if(nums.length<2) return nums;
        //交换法插入排序
        //从第二个数开始
        for(int i=1;i<nums.length;i++){
            int cur=nums[i];
            //插入位置之前的数字
            int j=i-1;
            //把比插入数大的数都移到后面
            while(j>=0 && nums[j]>cur){
                //插入的数比它前面的数小
                //把前面的数移到后面
                nums[j+1]=nums[j];
                j--;
            }
            // 两种情况会跳出循环：
            //1. 遇到一个小于或等于cur的数字，跳出循环，cur就坐到它后面。
            //2. 已经走到数列头部，仍然没有遇到小于或等于cur的数字，也会跳出循环，此时j等于 0，cur就坐到数列头部。   
            nums[j+1]=cur;
        }
        return nums;
    }
}