数据结构基础--排序

最新推荐文章于 2024-08-07 09:01:28 发布

XiaoNvShenYo

最新推荐文章于 2024-08-07 09:01:28 发布

阅读量278

点赞数 1

分类专栏：学习文章标签：数据结构排序算法算法

本文链接：https://blog.csdn.net/weixin_43955543/article/details/121731661

版权

学习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

七个基本排序

常用排序算法对比

冒泡排序

基本思想：
通过对排序序列从前向后（下标较小元素开始），依次比较相邻元素的值，若逆序则交换，使值较大的元素逐渐从前向后移动。
代码实现：

/**
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
//        sort(arr);
        sortByFlag(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    public static void sort(int[] arr){
        int temp;
        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]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.println("第"+(i+1)+"次排序:"+Arrays.toString(arr));
        }
    }
    
    /**
     * 优化后的冒泡排序
     */
    public static void sortByFlag(int[] arr){
        int temp;
        //使用flag来判断元素是否进行过交换，若未进行过交换则表示该数组已经有序
        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;
                }
            }
            System.out.println("第"+(i+1)+"次排序:"+Arrays.toString(arr));
            if (!flag){ break; }
            flag = false;
        }
    }
}

选择排序

基本思想：
第一次遍历从数组(0…n)中选择最小值( arr[min] )与数组第一位( arr[0] )进行交换;
第二次遍历从数组(1…n)中选择最小值( arr[min] )与数组第一位( arr[1] )进行交换;
第三次遍历从数组(2…n)中选择最小值( arr[min] )与数组第一位( arr[2] )进行交换;
…
依次执行，总共需要通过n-1次遍历，得到一个从小到大排序的有序序列

2.代码实现：

/**
 * 选择排序
 */
public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {4,3,5,8,1,9};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int[] arr){
        int temp;
        int min; //min记录最小值的元素下标
        for (int i=0; i< arr.length-1; i++){
            min = i;
            for (int j=i+1; j< arr.length; j++){
                if (arr[j] < arr[min]){
                    min = j;
                }
            }
            if (i != min){
                temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
    }
}

插入排序

基本思想：
把 n 个待排序的元素看成一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 n-1 个元素，每次从无序表中取出第一个元素，依次插入到有序表的适当位置。
代码实现：

/**
 * 插入排序
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {4,3,1,8,6,9,-1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int[] arr){
        int j;
        int cur;
        for (int i=1; i< arr.length; i++){
            j = i-1;
            cur = arr[i]; //用来保存当前待插入的数组下标为i的值
            while (j >= 0 && arr[j] > cur){
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = cur;
            System.out.println("第"+i+"次排序:"+Arrays.toString(arr));
        }
    }
}

希尔排序

基本思想：
希尔排序也是一种插入排序，是由简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
将序列按下标的一定增量分组，对每组使用直接插入排序算法排序。
代码实现：

/**
 * 希尔排序
 */
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8,9,1,7,2,3,5,4,6,0};
//        sort(arr);
        sort2(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 使用交换方式
     */
    public static void sort(int[] arr){
        int temp;
        for (int gap=arr.length/2; gap>0; gap/=2){
            for (int i=gap; i<arr.length; i++){
                for (int j = i-gap; j >= 0; j-=gap){
                    if (arr[j] > arr[j + gap]){
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
            System.out.println("第"+gap+"次排序:"+ Arrays.toString(arr));
        }
    }

    /**
     * 使用移位方式---推荐！
     */
    public static void sort2(int[] arr){
        for (int gap=arr.length/2; gap>0; gap/=2){
            for (int i=gap; i<arr.length; i++){
                int j = i;
                if (arr[j] < arr[j-gap]){
                    int cur = arr[j]; //用来保存当前待插入的数组下标为i的值
                    while (j - gap >= 0 && arr[j-gap] > cur){
                        arr[j] = arr[j-gap];
                        j -= gap;
                    }
                    arr[j] = cur;
                }
            }
            System.out.println("第"+gap+"次排序:"+ Arrays.toString(arr));
        }
    }
}

快速排序

基本思想：
对冒泡排序的一种改进。通过一趟排序将要排序的数据分成独立的两部分，其中一部分的数据比另一部分的数据都小，再递归进行此排序方法，以此达到整个数据变成有序序列。
代码实现：

/**
 * 快速排序
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[800000];
        for (int i=0; i< arr.length; i++){
            arr[i] = (int)(Math.random()*80000);
        }
        long start = System.currentTimeMillis();
        sort(arr, 0, arr.length-1);
        long end = System.currentTimeMillis();
//        System.out.println(Arrays.toString(arr));
        System.out.println(end-start);
    }

    public static void sort(int[] arr, int left, int right){
        //当左索引大于等于右索引时，直接退出
        if (left >= right){return;}
        int l = left;
        int r = right;
        int temp = arr[left]; //取起始索引对应的值作为基准数据
        while (l < r){
            //当右索引元素大于等于基准数据时，右索引向前移动
            while (l < r && arr[r] >= temp){
                r--;
            }
            //退出上面的循环，表示右索引元素小于基准数据，将其赋值给arr[l]
            //这里不需要担心数组值丢失，已经在开始时赋值给temp
            arr[l] = arr[r];
            //当左索引小于等于基准数据时，左索引向后移动
            while (l < r && arr[l] <= temp){
                l++;
            }
            //退出上面的循环，表示左索引元素大于基准数据，将其赋值给arr[r]
            //这里不需要担心数组值丢失，已经在循环前赋值给arr[l]
            arr[r] = arr[l];
        }
        //退出循环时表示 l==r 并且当前位置则为temp的正确索引位置
        arr[l] = temp;
        //对temp所在的左索引进行递归
        sort(arr, left, r-1);
        //对temp所在的右索引进行递归
        sort(arr, l+1, right);
    }
}

归并排序

基本思路：
采用经典的分治策略。将序列通过递归不断分成最小单位子序列，对子序列进行排序后再合并，形成最终序列。
代码实现：

/**
 * 归并排序
 */
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = new int[800000];
        int[] temp = new int[arr.length];
        for (int i=0; i< arr.length; i++){
            arr[i] = (int)(Math.random()*80000);
        }
        long start = System.currentTimeMillis();
        sort(arr, 0, arr.length - 1, temp);
        long end = System.currentTimeMillis();
//        System.out.println(Arrays.toString(arr));
        System.out.println(end-start);
    }

    public static void sort(int[] arr, int left, int right, int[] temp){
        if (left < right){
            int mid = (left + right) / 2;
            //向左递归进行分解
            sort(arr, left, mid, temp);
            //向右递归进行分解
            sort(arr, mid+1, right, temp);
            //合并
            merge(arr, left, mid, right, temp);
        }
    }

    /**
     * 合并
     * @param arr 原始数组
     * @param left 左索引
     * @param mid 中间索引
     * @param right 右索引
     * @param temp 临时变量
     */
    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int l = left;
        int m = mid + 1;
        int t = 0;
        while (l <= mid && m <= right){
            if (arr[l] <= arr[m]){
                temp[t++] = arr[l++];
            }else {
                temp[t++] = arr[m++];
            }
        }
        while (l <= mid){
            temp[t++] = arr[l++];
        }
        while (m <= right){
            temp[t++] = arr[m++];
        }

        t = 0;
        l = left;
        while (l < right){
            arr[l++] = temp[t++];
        }
    }
}

基数排序

基本思路：
基数排序属于分配式排序，属于稳定性的排序，效率最高的稳定性排序法。
将所有待比较的数值统一为同样的数位长度，数位较短的数前面补0，然后从最低位开始，依次进行一次排序；以此从最低位序一直到最高位序完成以后，就变成了有序序列。
代码实现：

/**
 * 基数排序
 */
public class RadixSort {
    public static void main(String[] args) {
        int[] arr = new int[800000];
        for (int i=0; i< arr.length; i++){
            arr[i] = (int)(Math.random()*1000000);
        }
//        System.out.println(Arrays.toString(arr));
        long start = System.currentTimeMillis();
        sort(arr);
        long end = System.currentTimeMillis();
//        System.out.println(Arrays.toString(arr));
        System.out.println(end-start);
    }

    public static void sort(int[] arr){
        int max = arr[0];
        for (int a : arr) {
            max = Math.max(a, max); //取出序列中的最大元素值
        }
        int maxLength = (max + "").length(); //得到最大元素值的位数
        int[][] bucket = new int[10][arr.length]; //创建一个二维数组【0-9个空间】【每个空间最多arr.length位数】
        int[] bucketElemCount = new int[10]; //用于存放每个空间存放有多少个值

        for (int i=0, n=1; i<maxLength; i++, n*=10){
            for (int item : arr) {
                int num = item / n % 10; //取个位数、十位数、百位数、千位数......
                bucket[num][bucketElemCount[num]] = item;
                bucketElemCount[num]++;
            }
            //取出放回原数组
            int index = 0;
            //遍历按顺序取出每个桶的元素数据放入原数组中
            for (int k=0; k< bucketElemCount.length; k++){
                if (bucketElemCount[k] > 0){
                    for (int j=0; j<bucketElemCount[k]; j++){
                        arr[index++] = bucket[k][j];
                    }
                    bucketElemCount[k] = 0;
                }
            }
        }
    }
}