1. 首页
  2. 文章中心
  3. 排序算法

Java排序算法

74 阅读 0 评论
我是靠谱客的博主 瘦瘦爆米花，最近开发中收集的这篇文章主要介绍Java排序算法，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

排序算法

排序算法(Sort Algorithm)，是将一组数据，依指定的顺序进行排列的过程。

排序的分类

  • 内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序
  • 外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序
  • 常见的排序算法分类

在这里插入图片描述

算法的时间复杂度

度量一个算法执行时间的两种方法

  1. 事后统计的方法

    这种方法可行, 但是有两个问题：一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所得时间的统计量依赖于计算机的硬件、软件等环境因素。 这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快。

  2. 事前估算的方法

    通过分析某个算法的时间复杂度来判断哪个算法更优.

时间频度

一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。

忽略常数项

image-20220823102745721

忽略低次项

image-20220823103241402

忽略系数

image-20220823103606316

时间复杂度

  • 一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。
  • T(n) 不同，但时间复杂度可能相同。 如：T(n)=n²+7n+6 与 T(n)=3n²+2n+2 它们的T(n) 不同，但时间复杂度相同，都为O(n²)。
  • 计算时间复杂度的方法：
  1. 用常数1代替运行时间中的所有加法常数 T(n)=n²+7n+6 => T(n)=n²+7n+1
  2. 修改后的运行次数函数中，只保留最高阶项 T(n)=n²+7n+1 => T(n) = n²
  3. 去除最高阶项的系数 T(n) = n² => T(n) = n² => O(n²)

常见的时间复杂度

  1. 常数阶O(1)
  2. 对数阶O(log2n)
  3. 线性阶O(n)
  4. 线性对数阶O(nlog2n)
  5. 平方阶O(n^2)
  6. 立方阶O(n^3)
  7. k次方阶O(n^k)
  8. 指数阶O(2^n)

在这里插入图片描述

说明：

  1. 常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n^2) ＜ Ο(n^3)＜ Ο(n^k) ＜ Ο(2^n) ，随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低
  2. 从图中可见，我们应该尽可能避免使用指数阶的算法
  • 1）常数阶O(1)
    无论代码执行了多少行，只要是没有循环等复杂结构，那这个代码的时间复杂度就都是O(1)
    image-20220823112948817

上述代码在执行时，它消耗的时间并不随着某个变量的增长而增长，那么无论这类代码有多长，即使有几万几十万行，都可以用O(1)来表示它的时间复杂度。

  • 2）对数阶O(log2n)
    image-20220823113630634

说明：在while循环里面，每次都将 i 乘以 2，乘完之后，i 距离 n 就越来越近了。假设循环x次之后，i 就大于 2 了，此时这个循环就退出了，也就是说 2 的 x 次方等于 n，那么 x = log2n也就是说当循环 log2n 次以后，这个代码就结束了。因此这个代码的时间复杂度为：O(log2n) 。 O(log2n) 的这个2 时间上是根据代码变化的， 如果 i = i * 3 ，则是 O(log3n) .

image-20220823122027862

  • 3）线性阶O(n)
    image-20220823122322884

说明：线性对数阶O(nlogN) 其实非常容易理解，将时间复杂度为O(logn)的代码循环N遍的话，那么它的时间复杂度就是 n * O(logN)，也就是了O(nlogN)

  • 4）线性对数阶O(nlogN)
    image-20220823123027748

线性对数阶O(nlogN) 其实非常容易理解，将时间复杂度为O(logn)的代码循环N遍的话，那么它的时间复杂度就是 n * O(logN)，也就是了O(nlogN)

  • 5）平方阶O(n²)

说明：平方阶O(n²) 就更容易理解了，如果把 O(n) 的代码再嵌套循环一遍，它的时间复杂度就是 O(n²)，这段代码其实就是嵌套了2层n循环，它的时间复杂度就是 O(n * n)，即 O(n²) 如果将其中一层循环的n改成m，那它的时间复杂度就变成了 O(m * n)
image-20220823130950820

  • 6）立方阶O(n³)、K次方阶O(n^k)
    O(n³)相当于三层n循环，其它的类似

平均时间复杂度和最坏时间复杂度

  • 平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间。
  • 最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。 这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比最坏情况更长。
  • 平均时间复杂度和最坏时间复杂度是否一致，和算法有关.

image-20220823133603833

相关术语解释：

  1. 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；

  2. 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；

  3. 内排序：所有排序操作都在内存中完成；

  4. 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；

  5. 时间复杂度： 一个算法执行所耗费的时间。

  6. 空间复杂度：运行完一个程序所需内存的大小。

  7. n: 数据规模

  8. k: “桶”的个数

  9. In-place: 不占用额外内存

  10. Out-place: 占用额外内存

算法的空间复杂度

  1. 类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它也是问题规模n的函数。
  2. 空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况
  3. 在做算法分析时，主要讨论的是时间复杂度。从用户使用体验上看，更看重的程序执行的速度。一些缓存产品(redis, memcache)和算法(基数排序)本质就是用空间换时间.

冒泡排序

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足就让它俩互换。

img

代码实现

import java.text.SimpleDateFormat;
import java.util.Date;

public class BubbleSort {
    public static void main(String[] args) {
        //测试冒泡排序的速度O(n^2),给80000个数据，测试
        //创建80000个随机的整数放入数组
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 80000); //生成范围在[0, 80000)的数
        }

        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间是= " + date1Str);

        System.out.println("==========排序后========");
        int[] bubbleSort = bubbleSort(arr);

        Date date2 = new Date();
        String date1Str2 = simpleDateFormat.format(date2);
        System.out.println("排序后的时间是= " + date1Str2);

    }


    public static int[] bubbleSort(int[] a) {
        int n = a.length;
        if (n <= 1) {
            return a;
        }
        int temp = 0; //临时变量
        for (int i = 0; i < n - 1; i++) {
            boolean flag = false; //标识变量，表示是否进行交换（优化）
            for (int j = 0; j < n - i - 1; j++) {
                if (a[j] > a[j + 1]) {//
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;

                    flag = true;//表示有数据交换
                }
            }
            if (!flag) {
                break; //没有数据交换(说明已排好序无需再进行冒泡),提前退出
            }
        }
        return a;
    }
}

    return a;
}

//自己写一遍
package com.yhs.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 80000);
        }
        Date date01 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date01Str = simpleDateFormat.format(date01);
        System.out.println("排序前时间=" + date01Str);

        System.out.println("==========排序后=========");
        bubble(arr);

        Date date02 = new Date();
        String date02Str = simpleDateFormat.format(date02);
        System.out.println("排序后时间=" + date02Str);
    }

    public static void bubble(int[] arr) {
        if (arr.length <= 1) {
            return;
        }
        int temp = 0;
        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]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) { //在一趟排序中，一次交换都没发生过
                break;
            } else {
                flag = false; //重置flag, 进行下一次判断
            }
        }
    }
}

选择排序

选择排序将数组分成已排序区间和未排序区间。初始已排序区间为空。每次从未排序区间中选出最小的元素插入已排序区间的末尾，直到未排序区间为空。

img

代码实现

package com.yhs.sort;

import java.util.Arrays;

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {123, 4, -1, 678};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int[] arr) {
        //总共需要经过n-1论比较
        for (int i = 0; i < arr.length-1; i++) {
            int min = i;
            //每轮需要比较的次数 n-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    //记录目前能找到的最小值元素的下标
                    min = j;
                }
            }
            //将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
    }
}

//另一种写法
public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        System.out.println("排序前~~");
        System.out.println(Arrays.toString(arr));
        select(arr); //选择排序
    }

    public static void select(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i; //最小值的下标
            int min = arr[i]; //最小值
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    minIndex = j; 
                    min = arr[j];
                }
            }
            //将最小值放在arr[0]交换
            //优化
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
            System.out.println("第" + (i + 1) + "轮后~");
            System.out.println(Arrays.toString(arr));
        }
    }

插入排序

插入排序将数组数据分成已排序区间和未排序区间。初始已排序区间只有一个元素，即数组第一个元素。在未排序区间取出一个元素插入到已排序区间的合适位置，直到未排序区间为空。

img

思路分析

package com.yhs.sort;

import java.util.Arrays;

public class Insert {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        insertSort(arr);
    }

    //插入排序
    public static void insertSort(int[] arr) {
        //使用逐步推导的方法来讲解
        //第1轮 {101, 34, 119, 1} => {34, 101, 119, 1}

        //定义待插入的数
        int insertVal = arr[1];
        int insertIndex = 1 - 1; //即arr[1]的前面的数的下标

        //给insertVal 找到插入的位置
        //说明
        //1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
        //2. insertVal < arr[indexIndex] 待插入的数，还没有找到插入位置
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        //当退出while循环时，说明插入的位置找到，insertIndex + 1
        arr[insertIndex + 1] = insertVal;
        
        System.out.println("第一轮插入");
        System.out.println(Arrays.toString(arr));


        //第2轮
        insertVal = arr[2];
        insertIndex = 2 - 1;
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        arr[insertIndex + 1] =  insertVal;
        System.out.println("第二轮插入");
        System.out.println(Arrays.toString(arr));

        //第3轮
        insertVal = arr[3];
        insertIndex = 3 - 1;
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        arr[insertIndex + 1] =  insertVal;
        System.out.println("第三轮插入");
        System.out.println(Arrays.toString(arr));
    }
}

代码实现

public static void insert(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int insertIndex = i - 1;
        int insertVal = arr[i];

        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        if(insertIndex + 1 !=  i) {
        	arr[insertIndex + 1] = insertVal;
        }
        System.out.println("第" + i + "轮");
        System.out.println(Arrays.toString(arr));
    }
}

//方法2 
    public static void insert02(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > temp) {
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = temp;
            System.out.println(Arrays.toString(arr));
        }
    }

希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

  • 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
  • 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

希尔排序【交换式】

思路分析

package com.yhs.sort;

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
    }

    //使用逐步推导的方式编写希尔排序
    public static void shellSort(int[] arr) {
        int temp = 0;
        // 希尔排序第1轮
        // 因为第1轮排序，是将10个数据分成了10/2=5组
        for (int i = 5; i < arr.length; i++) {
            for (int j = i - 5; j >= 0; j -= 5) {
                if (arr[j] > arr[j + 5]) {
                    temp = arr[j];
                    arr[j] = arr[j+5];
                    arr[j + 5] = temp;
                }
            }
            System.out.println(Arrays.toString(arr));
        }

        // 希尔排序第2轮
        // 因为第1轮排序，是将10个数据分成了5/2=2组
        System.out.println("============第2轮============");
        for (int i = 2; i < arr.length; i++) {
            for (int j = i - 2; j >= 0; j -= 2) {
                if (arr[j] > arr[j + 2]) {
                    temp = arr[j];
                    arr[j] = arr[j+2];
                    arr[j + 2] = temp;
                }
            }
            System.out.println(Arrays.toString(arr));
        }

        // 希尔排序第3轮
        // 因为第3轮排序，是将10个数据分成了2/2=1组
        System.out.println("============第3轮============");
        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0; j -= 1) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println(Arrays.toString(arr));
        }
    }
}

代码实现

package com.yhs.sort;

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
    }

    public static void shellSort02(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(Arrays.toString(arr));
        }
    }

}

希尔排序【移位式】

public static void shellSort(int[] arr) {
    int temp;
    int j;
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < arr.length; i++) {
            temp = arr[i];
            for (j = i; j >= gap && temp < arr[j - gap]; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}


//while写法
public static void shellSortPlus(int[] arr) {
        //增量gap，并逐步缩小增量
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //从第gap个元素，逐个对其所在的组进行直接插入排序
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]) { //【这里我不明白为什么还要一个if循环】
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        //移动
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    //当退出while循环时，就给temp找到新插入的位置
                    arr[j] = temp;
                }
            }
        }
    }

快速排序

快排的思想: 如果要排序数组中下标从p到r之间的一组数据,我们选择p到r之间的任意一个数据作为pivot (分区点) 。我们遍历p到r之间的数据,将小于pivot的放到左边,将大于pivot的放到右边,将pivot放到中间。经过这一步骤之后,数组p到r之间的数据就被分成了三个部分,前面p到q-1之间都是小于pivot的,中间是pivot,后面的q+1到r之间是大于pivot的。

算法步骤

  1. 从数列中挑出一个元素，称为 “基准”（pivot）;
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

img

img

img

代码实现

//写法1
public static void QuickSort(int[] arr, int L, int R) {
    if (L > R) {
        return;
    }
    int left = L;
    int right = R;
    int pivot = arr[left];
    while (left < right) {
        while (left < right && pivot <= arr[right]) {
            right--;
        }
        if (pivot > arr[right]) {
            arr[left] = arr[right];
            left++;
        }
        if (left == right) {
            arr[left] = pivot;
            break;
        }

        while (left < right && arr[left] < pivot) {
            left++;
        }
        if (pivot < arr[left]) {
            arr[right] = arr[left];
            right--;
        }
        if (left == right) {
            arr[left] = pivot;
            break;
        }
    }
    QuickSort(arr, L, right - 1);
    QuickSort(arr, right + 1, R);
}

//写法2 【中间的数作为pivot】
public static void Quick(int[] arr, int L, int R) {
    if (L > R) {
        return;
    }
    int left = L;
    int right = R;
    int pivot = arr[(left + right) / 2];
    do {
        while (arr[left] < pivot) {
            left++;
        }
        while (arr[right] > pivot) {
            right--;
        }
        if (left <= right) {
            pivot = arr[left];
            arr[left] = arr[right];
            arr[right] = pivot;
            left++;
            right--;
        }
    } while (left <= right); //这里若没有= 需要更改下面递归时的区间范围
    if (L < right) {  //若未找到两个数的边界，则递归搜索左右区间
        Quick(arr, L, right);
    }
    if (left < R) {
        Quick(arr, left, R);
    }
}

归并排序

如果要排序一个数组,我们先把数组从中间分成前后两部分,然后对前后两部分分别排序,再将排好序的两部分合并在一起,这样整个数组就都有序了。

img

代码实现

import java.util.Arrays;

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {8,4,5,7,1,3,6,2};
        int[] temp = new int[arr.length];
        mergeSort(arr, 0, arr.length-1, temp);
        System.out.println(Arrays.toString(arr));
    }


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


    /**
     * @param arr 排序的原始数组
     * @param L 左边有序序列的初始索引
     * @param mid 中间索引
     * @param R 右边的索引
     * @param temp 中转数组
     */
    public static void merge(int[] arr, int L, int mid, int R, int[] temp) {
        int i = L; //初始化i，左边有序序列的初始索引
        int j = mid + 1; //初始化j，右边有序序列的初始索引
        int t = 0; //指向temp数组的当前索引

        //(一)
        //先把左右两边（有序）的数据按照规则填充到temp数组
        //直到左右两边的有序序列，有一边处理完毕为止
        while (i <= mid && j <= R) {
            //如果左边有序序列的当前元素，小于等于右边有序序列的当前元素
            //即将左边当前元素，拷贝到temp数组
            //然后 t++, i++;
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                i++;
                t++;
            } else { //反之，将右边有序序列的当前元素，拷贝到temp数组
                temp[t] = arr[j];
                j++;
                t++;
            }
        }
        //(二)
        //把有剩余数据的一边，一次填充到temp
        while (i <= mid) { //左边有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[i];
            t++;
            i++;
        }
        while (j <= R) { //右边有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[j];
            t++;
            j++;
        }

        //(三)
        //将temp数组的元素拷贝到arr
        //注意并不是每次都拷贝
        t = 0;
        int tempLeft = L;
        //第一次合并 tempLeft = 0： R = 1 // tempLeft = 2 R = 3; // tempLeft = 0, R = 3
        //最后一次 tempLeft = 0 right = 7；
        while (tempLeft <= R) {
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }
        
        /* 从 temp 数组中 copy 数据到原数组 */
//        for (i = 0; i < t; i++) {
//            arr[L + i] = temp[i];
//        }
    }
}

image-20220827152835153

计数排序

import java.util.Arrays;

public class CountSort {
    public static void main(String[] args) {
        int[] arr = {2, 1, 4, 7, 0, 5, 5, 4, 9, 2, 1, 0, 6, 4};
        countSort(arr);
    }

    public static void countSort(int[] arr) {
        int[] result = new int[arr.length];

        int[] count = new int[findMax(arr) + 1];

        for (int i = 0; i < arr.length; i++) {
            count[arr[i]]++;
        }
        System.out.println("记数数组=" + Arrays.toString(count));

        //累加数组
        //记录相同数据的最后一个位应该存放的位置
        for (int i = 1; i < count.length; i++) {
            count[i] = count[i] + count[i - 1];
        }
        System.out.println("累加数组=" + Arrays.toString(count));

        //倒叙迭代原始数组
        for (int i = arr.length - 1; i >= 0; i--) {
            result[--count[arr[i]]] = arr[i];
        }
        System.out.println("排序后的数组=" + Arrays.toString(result));
    }


    public static int findMax(int[] arr) { //找出数组中的最大值，为计数数组的大小做准备
        int max = arr[0];
        for (int j = 1; j < arr.length; j++) {
            if (max < arr[j]) {
                max = arr[j];
            }
        }
        return max;
    }
}

基数排序

本质是一种多关键字的排序

有低位优先和高位优先两种

import java.util.Arrays;

public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {421, 240, 115, 532, 305, 430, 124};
        int i = maxNum(arr); //过滤数组求最高位数
        radixSort(arr, i);
    }

    //编写方法计算数组中最大值的位数
    public static int maxNum(int[] arr) {
        int num = 1; //记录位数
        int max = arr[0];
        for (int k = 0; k < arr.length; k++) {
            if (max < arr[k]) {
                max = arr[k];
            }
        }
        while (max / 10 != 0) {
            max /= 10;
            num++;
        }
        return num;
    }


    /**
     * @param arr 需要排序的数组
     * @param n 数组中最大值的位数
     */
    public static void radixSort(int[] arr, int n) {
        int[] result = new int[arr.length];
        int[] count = new int[10];

        for (int i = 0; i < n; i++) {
            int division = (int) Math.pow(10, i);
            System.out.println(division);
            for (int j = 0; j < arr.length; j++) {
                int num = arr[j]/division % 10;
                System.out.print(num + " ");
                count[num]++;
            }
            System.out.println();
            System.out.println(Arrays.toString(count));

            //累加数组
            for (int m = 1; m < count.length; m++) {
                count[m] = count[m] + count[m-1];
            }
            System.out.println("累加数组=" + Arrays.toString(count));

            for (int s = arr.length - 1; s >= 0; s--) {
                int num = arr[s]/division % 10;
                result[--count[num]] = arr[s];
            }

            System.arraycopy(result, 0, arr, 0, arr.length);
            Arrays.fill(count, 0);
        }

        System.out.println( "排序结果=" + Arrays.toString(result));
    }
}

桶排序

桶排序,顾名思义,会用到“桶" ,核心思想是将要排序的数据分到几个有序的桶里,每个桶里的数据再单独进行排序。桶内排完序之后,再把每个桶里的数据按照顺序依次取出,组成的序列就是有序的了。

对排序的数据要求苛刻:

  1. 要排序的数据需要很容易就能划分成m个桶,并且,桶与桶之间有着天然的大小顺序。

  2. 数据在各个桶之间的分布是比较均匀的。

  3. 桶排序比较适合用在外部排序中。所谓的外部排序就是数据存储在外部磁盘中,数据量比较大,内存有限，无法将数据全部加载到内存中。

img

堆排序

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏、最好、平均时间复杂度均为O(nlogn),它也是不稳定排序

堆是具有一下性质的完全二叉树：每个结点的值都大于或等于左右孩子结点的值，称为大栈堆，注意：没有要求站点在左孩子的值和右孩子的值的大小

每个结点的值都小于或等于其他左右孩子结点的值，称为小栈堆

import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args) {
        int arr[] = {4, 6, 8, 5, 9};
        heapSort(arr);
    }

    public static void heapSort(int[] arr) {
        //将无序序列构建成一个堆，根据升序降序选择大顶堆或小顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }

        //将堆顶元素和堆尾元素交换，将最大元素”沉“到数组末端
        //重新调整结构，使其满足堆定义，然后继续交换堆顶元素和当前末尾元素，反复执行调整+交换步骤
        for (int j = arr.length - 1; j > 0; j--) {
            int temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            adjustHeap(arr, 0, j);
        }
        System.out.println(Arrays.toString(arr));
    }


    /**
     * @param arr    待调整的数组
     * @param i      表示非叶子结点在数组中的索引
     * @param length 表示堆多少个元素进行调整，length 是在逐渐减少
     */
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && arr[k] < arr[k + 1]) {
                k++;
            }
            if (arr[k] > temp) {
                arr[i] = arr[k];
                i = k;
            } else {
                break;
            }
        }
        //当for循环结束后，我们已经将以1为父结点的树的最大值，放在了（局部）最顶端
        arr[i] = temp; //将temp值放到调整后的位置
    }
}

最后

以上就是瘦瘦爆米花为你收集整理的Java排序算法的全部内容，希望文章能够帮你解决Java排序算法所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(49)

相关文章

贪心算法解决背包问题
贪心算法解决背包问题
ARTS-9-算法练习-动态规划之字符串匹配
ARTS-9-算法练习-动态规划之字符串匹配
算法优化策略
算法优化策略
【文献翻译】七种FD发现算法（未完成）摘要1. 函数依赖关系2. FD算法概述3. 七种FD发现算法4. 评价5. 总结
【文献翻译】七种FD发现算法（未完成）摘要1. 函数依赖关系2. FD算法概述3. 七种FD发现算法4. 评价5. 总结
Java排序算法
Java排序算法
LeetCode 53.最大子序和前言一、题目二、思路总结
LeetCode 53.最大子序和前言一、题目二、思路总结
动态规划
动态规划
Java实现算法导论中朴素字符串匹配算法
Java实现算法导论中朴素字符串匹配算法

评论列表共有 0 条评论

立即
投稿
返回
顶部