数据结构 Java数据结构 --- 十大排序

于 2024-05-03 15:29:34 发布
阅读量880 收藏 8
点赞数 11
分类专栏： 程序员 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84103616/article/details/138417345
版权

array[end] = array[0];

array[0] =tmp;

siftDown(array,0,end);

end–;

}

}

4.3 性能分析

| 时间复杂度(平均) | 时间复杂度(最坏) | 时间复杂度(最好) | 空间复杂度 | 稳定性 |

| — | — | — | — | — |

| O(n * log(n)) | O(n * log(n)) | O(n * log(n)) | O(1) | 不稳定 |

5.冒泡排序

=========================================================================

5.1 动图演示

在这里插入图片描述

5.2 代码实现

public static void BubbleSort(int[] array){

for (int i = 0; i < array.length - 1; i++) {

boolean flg = false;

for (int j = 0; j < array.length - 1 - i ; j++) {

if(array[j+1] < array[j]){

int tmp = array[j];

array[j] = array[j+1];

array[j+1] = tmp;

flg = true;

}

}

if(!flg){

break;

}

}

}

5.3 性能分析

| 时间复杂度(平均) | 时间复杂度(最坏) | 时间复杂度(最好) | 空间复杂度 | 稳定性 |

| — | — | — | — | — |

| O(n^2) | O(n^2) | O(n) | O(1) | 稳定 |

6.快速排序

=========================================================================

6.1 原理

  1. 从待排序区间选择一个数，作为基准值(pivot)；

  2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可

以包含相等的）放到基准值的右边；

  1. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间

的长度 == 0，代表没有数据。

6.2 动图演示

在这里插入图片描述

6.3 实现方法

6.3.1 Hoare法:

在这里插入图片描述

6.3.2 挖坑法:

在这里插入图片描述

6.4 代码实现

//Hoare法

public static void swap(int[] array,int i,int j){

int tmp = array[i];

array[i] = array[j];

array[j] = tmp;

}

public static int partition1(int[] array,int low,int high) {

int i = low;

int tmp = array[low];

while (low < high){

while (low < high && array[high] >= tmp){

high–;

}

while (low < high && array[low] <= tmp){

low++;

}

swap(array,low,high);

}

swap(array,i,low);

return low;

}

//挖坑法

public static int partition2(int[] array,int low,int high) {

int tmp = array[low];

while (low < high){

while (low < high && array[high] >= tmp){

high–;

}

array[low] = array[high];

while (low < high && array[low] <= tmp){

low++;

}

array[high] = array[low];

}

array[low] = tmp;

return low;

}

public static void quick(int[] array,int start,int end){

if(start >= end) return;

int pivot = partition1(array,start,end);

quick(array,start,pivot-1);

quick(array,pivot+1,end);

}

public static void quickSort(int[] array){

quick(array,0,array.length-1);

}

6.5 快排优化

6.5.1 三数取中法

public static void swap(int[] array,int i,int j){

int tmp = array[i];

array[i] = array[j];

array[j] = tmp;

}

public static int partition2(int[] array,int low,int high) {

int tmp = array[low];

while (low < high){

while (low < high && array[high] >= tmp){

high–;

}

array[low] = array[high];

while (low < high && array[low] <= tmp){

low++;

}

array[high] = array[low];

}

array[low] = tmp;

return low;

}

public static void selectPivotMedianOFThree(int[] array,int start,int end,int mid){

if(array[mid] > array[start]){

swap(array,start,mid);

}//此时mid下标的值肯定小于start下标的值 array[mid] <= array[start]

if(array[mid] > array[end]){

swap(array,mid,end);

}//此时mid下标的值肯定小于end下标的值 array[mid] <= array[end]

if(array[start] > array[end]){

swap(array,start,end);

}//此时有 array[mid] <= array[start] <= array[end]

}

public static void quick1(int[] array,int start,int end){

if(start >= end) return;

int mid = (start + end) / 2;

selectPivotMedianOFThree(array,start,end,mid);

int pivot = partition2(array,start,end);

quick1(array,start,pivot-1);

quick1(array,pivot+1,end);

}

public static void quick1Sort(int[] array){

quick1(array,0,array.length - 1);

}

6.5.2 加上直接插入排序

public static void swap(int[] array,int i,int j){

int tmp = array[i];

array[i] = array[j];

array[j] = tmp;

}

public static void insertSort2(int[] array,int start,int end){

for (int i = start + 1; i <= end; i++) {

int j = i + 1;

int tmp = array[i];

while (j >= 0){

if(array[j] > tmp){

array[j+1] = array[j];

}else {

break;

}

}

array[j+1] = tmp;

}

}

public static int partition2(int[] array,int low,int high) {

int tmp = array[low];

while (low < high){

while (low < high && array[high] >= tmp){

high–;

}

array[low] = array[high];

while (low < high && array[low] <= tmp){

low++;

}

array[high] = array[low];

}

array[low] = tmp;

return low;

}

public static void selectPivotMedianOFThree(int[] array,int start,int end,int mid){

if(array[mid] > array[start]){

swap(array,start,mid);

}//此时mid下标的值肯定小于start下标的值 array[mid] <= array[start]

if(array[mid] > array[end]){

swap(array,mid,end);

}//此时mid下标的值肯定小于end下标的值 array[mid] <= array[end]

if(array[start] > array[end]){

swap(array,start,end);

}//此时有 array[mid] <= array[start] <= array[end]

}

public static void quick2(int[] array,int start,int end){

if(start >= end) return;

if(end - start + 1 <= 100){

insertSort2(array,start,end);

return;

}

int mid = (start + end)/2;

selectPivotMedianOFThree(array,start,end,mid);

int pivot = partition2(array,start,end);

quick2(array,start,pivot-1);

quick2(array,pivot+1,end);

}

public static void quick2Sort(int[] array){

quick2(array,0,array.length - 1);

}

6.6 非递归的实现

6.6.1 非递归思路

  1. 首先调用partition,找到pivot

  2. 然后把pivot的 左区间 和 右区间 的下标放到栈立马

  3. 判断栈是否为空,不为空,弹出栈顶的2个元素(注意:入栈的顺序 决定了出栈的顺序中的第一个元素是high的还是low的)

  4. 然后再进行调用partition,找pivot,

  5. 重复以上操作.

6.6.2 非递归代码实现

public static void quickSort4(int[] array){

Stack stack = new Stack<>();

int low = 0;

int high = array.length - 1;

int pivot = partition2(array,low ,high);

//左边有2个元素即以上

if(pivot > low + 1){

stack.push(0);

stack.push(pivot - 1);

}

//右边有2个元素即以上

if(pivot < high - 1){

stack.push(pivot + 1);

stack.push(high);

}

while (!stack.isEmpty()){

high = stack.pop();

low = stack.pop();

pivot = partition2(array,low,high);

//左边有2个元素即以上

if(pivot > low + 1){

stack.push(0);

stack.push(pivot - 1);

}

//右边有2个元素即以上

if(pivot < high - 1){

stack.push(pivot + 1);

stack.push(high);

}

}

}

6.7 性能分析

| 时间复杂度(平均) | 时间复杂度(最坏) | 时间复杂度(最好) | 空间复杂度 | 稳定性 |

| — | — | — | — | — |

| O(n * log(n)) | O(n^2) | O(n * log(n)) | O(log(n))~O(n) | 不稳定 |

7.归并排序

=========================================================================

7.1 原理

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子 序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

在这里插入图片描述

在这里插入图片描述

7.2 动图演示

在这里插入图片描述

7.3 代码实现—递归

public static void merge(int[] array,int low ,int high ,int mid){

int s1 = low;

int e1 = mid;

int s2 = mid+1;

int e2 = high;

int[] tmp = new int[high - low + 1];

int k = 0;

while (s1 <= e1 && s2 <= e2){

if(array[s1] <= array[s2]){

tmp[k++] = array[s1++];

}else {

tmp[k++] = array[s2++];

}

}

while (s1 <= e1){

tmp[k++] = array[s1++];

}

while (s2 <= e2){

tmp[k++] = array[s2++];

}

for (int i = 0; i < tmp.length; i++) {

array[i+low] = tmp[i];

}

}

public static void mergeSortInternal(int[] array,int low ,int high){

if(low >= high) return;

int mid = (low + high) / 2;

mergeSortInternal(array,low,mid);

mergeSortInternal(array,mid+1,high);

merge(array,low,high,mid);

}

public static void mergeSort(int[] array){

mergeSortInternal(array,0,array.length - 1);

}

7.4 代码实现—非递归

public static void merge1(int[] array,int gap){

int[] tmp = new int[array.length];

int k = 0;

int s1 = 0;

int e1 = s1 + gap - 1;

int s2 = e1 + 1;

int e2 = s2 + gap - 1 > array.length ? array.length - 1 : s2 + gap - 1;

while (s2 < array.length){

while (s1 <= e1 && s2 <= e2){

if(array[s1] <= array[s2]){

tmp[k++] = array[s1++];

}else {

tmp[k++] = array[s2++];

}

}

while (s1 <= e1){

tmp[k++] = array[s1++];

}

while (s2 <= e2){

tmp[k++] = array[s2++];

}

s1 = e2 + 1;

e1 = s1 + gap - 1;

s2 = e1 + 1;

e2 = s2 + gap - 1 > array.length ? array.length - 1 : s2 + gap - 1;

}

while (s1 <= array.length - 1){

tmp[k++] = array[s1++];

}

for (int i = 0; i < tmp.length; i++) {

array[i] = tmp[i];

}

}

public static void mergeSort1(int[] array){

for (int i = 1; i < array.length; i*=2) {

merge1(array,i);

}

}

7.5 性能分析

| 时间复杂度(平均) | 时间复杂度(最坏) | 时间复杂度(最好) | 空间复杂度 | 稳定性 |

| — | — | — | — | — |

| O(n * log(n)) | O(n * log(n)) | O(n * log(n)) | O(n) | 稳定 |

8.计数排序

=========================================================================

当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。

8.1 算法的步骤：

（1）找出待排序的数组中最大和最小的元素

（2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项

（3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）

（4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

8.2 动图演示

在这里插入图片描述

8.3 代码实现:

public static void CountingSort(int[] array){

int maxValue = GetMaxValue(array);

int bucketLen = maxValue + 1;

int[] bucket = new int[bucketLen];

for (int value:array) {

bucket[value]++;

}

int index = 0 ;

for (int i = 0; i < bucketLen; i++) {

while(bucket[i] > 0){

array[index++] = i;

bucket[i]–;

}

}

}

public static int GetMaxValue(int[] array){

int maxValue = array[0];

for (int i = 0; i < array.length; i++) {

if(maxValue < array[i]){

maxValue = array[i];

}

}

return maxValue;

}

8.4 性能分析

| 时间复杂度(平均) | 时间复杂度(最坏) | 时间复杂度(最好) | 空间复杂度 | 稳定性 |

| — | — | — | — | — |

| O(n+k) | O(n+k) | O(n+k) | O(k) | 稳定 |

9.桶排序

========================================================================

9.1 原理

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

为了使桶排序更加高效，我们需要做到这两点：

  1. 在额外空间充足的情况下，尽量增大桶的数量

  2. 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

9.2 算法的步骤:

  1. 设置一个定量的数组当作空桶；

  2. 遍历输入数据，并且把数据一个一个放到对应的桶里去；

  3. 对每个不是空的桶进行排序；

  4. 从不是空的桶里把排好序的数据拼接起来。

9.3 画图解析

在这里插入图片描述

9.4 代码实现

public static void bucketSort(int[] arr) {

if (arr.length == 0) {

return;

}

int minValue = arr[0];

int maxValue = arr[0];

for (int value : arr) {

if (value < minValue) {

minValue = value;

} else if (value > maxValue) {

maxValue = value;

}

}

//得到最大和最小元素

int bucketNum = (maxValue - minValue) / arr.length + 1;//桶的数量

ArrayList<ArrayList> bucket = new ArrayList<>(bucketNum);

for (int i = 0; i < bucketNum; i++) {

bucket.add(new ArrayList<>());

}

//将元素放入到桶中

for (int i = 0; i < arr.length; i++) {

int num = (arr[i] - minValue) / arr.length;

面试准备+复习分享：

为了应付面试也刷了很多的面试题与资料，现在就分享给有需要的读者朋友，资料我只截取出来一部分哦

秋招｜美团java一面二面HR面面经，分享攒攒人品

在这里插入图片描述

9.4 代码实现

public static void bucketSort(int[] arr) {

if (arr.length == 0) {

return;

}

int minValue = arr[0];

int maxValue = arr[0];

for (int value : arr) {

if (value < minValue) {

minValue = value;

} else if (value > maxValue) {

maxValue = value;

}

}

//得到最大和最小元素

int bucketNum = (maxValue - minValue) / arr.length + 1;//桶的数量

ArrayList<ArrayList> bucket = new ArrayList<>(bucketNum);

for (int i = 0; i < bucketNum; i++) {

bucket.add(new ArrayList<>());

}

//将元素放入到桶中

for (int i = 0; i < arr.length; i++) {

int num = (arr[i] - minValue) / arr.length;

面试准备+复习分享：

为了应付面试也刷了很多的面试题与资料，现在就分享给有需要的读者朋友，资料我只截取出来一部分哦

[外链图片转存中…(img-Ra9jzad6-1714721363330)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

2401_84103616
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值