【无标题】

最新推荐文章于 2024-09-10 19:54:08 发布
最新推荐文章于 2024-09-10 19:54:08 发布
阅读量27 收藏
点赞数
文章标签： 排序算法 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47505475/article/details/132371925
版权

常用排序算法复习

排序中的对数器

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int times = 100000;
        int maxValue = 1000;
        int size = 1000;
        for (int i = 0; i < times; i++) {
            int[] arr = getRandomArr(size, maxValue);
            int[] copyArr = arr.clone();  // 深拷贝一个数组
            Arrays.sort(arr);
            bubbleSort(copyArr);
            
            if (!isEqualArr(arr, copyArr)) {
                System.out.println("fuck!!!");
                break;
            }
        }
    }
    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int n = arr.length;
        for (int j = n - 1; j >= 0; j--) {
            for (int i = 0; i < j; i++) {
                if (arr[i] > arr[i + 1]) {
                    swap(arr, i, i + 1);
                }
            }
        }
    }
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    public static int[] getRandomArr(int size, int maxValue) {
        int[] arr = new int[(int)(Math.random() * size)];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * maxValue - Math.random() * maxValue);
        }
        return arr;
    }
    // 验证两个数组的值是否相同
    public static boolean isEqualArr(int[] arr1, int[] arr2) {
        if (arr1 == null || arr2 == null) {
            return arr1 == null && arr2 == null;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        int n = arr1.length;
        for (int i = 0; i < n; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }
}

1、冒泡排序

每次将最大的冒泡到最后一个

public static void bubbleSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    int n = arr.length;
    for (int j = n - 1; j >= 0; j--) {
        for (int i = 0; i < j; i++) {
            if (arr[i] > arr[i + 1]) {
                swap(arr, i, i + 1);
            }
        }
    }
}

2、选择排序

每次选择最大的与最后一个交换

public static void selectSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    int n = arr.length;
    for (int j = n - 1; j > 0; j--) {
        int maxIndex = j;
        for (int i = 0; i <= j; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i;
            }
        }
        swap(arr, j, maxIndex);
    }
}
public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

3、插入排序

每到一个结尾就对其及其之前的进行排序

public static void insertSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    int n = arr.length;
    for (int j = 1; j < n; j++) {
        for (int i = j; i > 0; i--) {
            if (arr[i] < arr[i - 1]) {
                swap(arr, i - 1, i);
            } else {
                break;
            }
        }
    }
}
public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

4、希尔排序

将整个序列通过指定增量gap分成若干段，分别进行插入排序，gap不断缩小，最后为1，排序完成

public static void shellSort(int[] arr) {
    if(arr == null || arr.length < 2) {
        return;
    }
    int n = arr.length;
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        // 插入排序
        for (int j = gap; j < n; j += gap) {
            for (int i = j; i >= gap; i-= gap) {
                if (arr[i] < arr[i - gap]) {
                    swap(arr, i, i - gap);
                } else {
                    break;
                }
            }
        }
    }
}

5、归并排序

不断二分，然后合并

public static void mergeSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    merge(arr, 0, arr.length - 1);
}
public static void merge(int[] arr, int l, int r) {
    if (l == r) {
        return;
    }
    int mid = l + ((r - l) >> 1);
    merge(arr, l, mid);
    merge(arr, mid + 1, r);
    int[] temp = new int[r - l + 1];
    int p1 = l;
    int p2 = mid + 1;
    int p = 0;
    while (p1 <= mid && p2 <= r) {
        temp[p++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
    }
    while (p1 <= mid) {
        temp[p++] = arr[p1++];
    }
    while (p2 <= r) {
        temp[p++] = arr[p2++];
    }
    for (int i = 0; i < temp.length; i++) {
        arr[i + l] = temp[i];
    }
}

6、快速排序

不断partition，不断递归即可

public static void fastSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    partition(arr, 0, arr.length - 1);
}
public static void partition(int[] arr, int l, int r) {
    if (l >= r) {
        return;
    }
    int randomIndex = l + (int)(Math.random() * (r - l));
    swap(arr, r, randomIndex);
    int num = arr[r];
    int left = l - 1;
    int right = r;
    int i = l;
    while (i < right) {
        if (arr[i] < num) {
            swap(arr, i++, ++left);
        } else if (arr[i] > num) {
            swap(arr, i, --right);
        } else {
            i++;
        }
    }
    swap(arr, r, right);
    partition(arr, l, left);
    partition(arr, right + 1, r);
}
public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

7、堆排序

构建大根堆，每次取出堆的根，然后拿堆的最后一个元素替换堆根并调整堆即可

 public static void heapSort(int[] arr) {
     if (arr == null || arr.length < 2) {
         return;
     }
     int n = arr.length;
     //        向上堆化
     //        for (int i = 0; i < n; i++) {
     //            heapifyUp(arr, i);
     //        }
     int heapSize = n - 1;
     //        向下堆化
     for (int i = n - 1; i >= 0; i--) {
         heapifyDown(arr, i, heapSize);
     }
     while (heapSize > 0) {
         swap(arr, 0, heapSize--);
         heapifyDown(arr, 0, heapSize);
     }
 }
public static void heapifyUp(int[] arr, int index) {
    // 向上堆化，找父节点
    while (arr[index] > arr[(index - 1) / 2]) {
        swap(arr, index, (index - 1) / 2);
        index = (index - 1) / 2;
    }
}
public static void heapifyDown(int[] arr, int index, int heapSize) {
    // 向下堆化
    int leftIndex = 2 * index + 1;
    while (leftIndex <= heapSize) {
        int largeChildIndex = leftIndex + 1 <= heapSize && arr[leftIndex + 1]
            > arr[leftIndex] ? leftIndex + 1 : leftIndex;
        int largeIndex = arr[largeChildIndex] > arr[index] ? largeChildIndex : index;
        if (largeIndex == index) {
            break;
        }
        swap(arr, index, largeIndex);
        index = largeChildIndex;
        leftIndex = 2 * index + 1;
    }
}
public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

8、桶排序

8.1 最简单的桶排序

1、将待排序元素划分到不同的桶。先扫描一遍序列求出最大值 maxV 和最小值 minV ，设桶的个数为 k ，则把区间 [minV, maxV] 均匀划分成 k 个区间，每个区间就是一个桶。将序列中的元素分配到各自的桶。
2、对每个桶内的元素进行排序。可以选择任意一种排序算法。
3、将各个桶中的元素合并成一个大的有序序列。
假设数据是均匀分布的，则每个桶的元素平均个数为 n/k 。假设选择用快速排序对每个桶内的元素进行排序，那么每次排序的时间复杂度为 O(n/klog(n/k)) 。总的时间复杂度为 O(n)+O(k)O(n/klog(n/k)) = O(n+nlog(n/k)) = O(n+nlogn-nlogk 。当 k 接近于 n 时，桶排序的时间复杂度就可以金斯认为是 O(n) 的。即桶越多，时间效率就越高，而桶越多，空间就越大。

public static void bucketSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    bucketSortProcess(arr, 10);
}
public static void bucketSortProcess(int[] arr, int k) {
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for (int n : arr) {
        max = Math.max(n, max);
        min = Math.min(n, min);
    }
    List<Integer>[] bucketList = new List[k];  
    for (int i = 0; i < k; i++) {
        bucketList[i] = new ArrayList<Integer>();
    }
    for (int n : arr) {
        int index = (k - 1) * (n - min) / (max - min);
        bucketList[index].add(n);
    }
    int index = 0;
    for (int i = 0; i < k; i++) {
        Collections.sort(bucketList[i]);
        for (int num : bucketList[i]) {
            arr[index++] = num;
        }
    }
}

8.2 基数排序

从低到高对每一位进行排序，每一次排序都要保证稳定性

public static int getBit(int num) {
    if (num == 0) {
        return 1;
    }
    int ans = 0;
    while (num != 0) {
        ans++;
        num /= 10;
    }
    return ans;
}
public static int getDigit(int num, int index) {
    // 返回一个数字十进制的某一位，从后往前数（从1开始）
    index --;
    while (index != 0) {
        num /= 10;
        index--;
    }
    return num % 10;
}
public static void radixSortInPositive(int[] arr) {
    // 对正数进行基数排序
    if (arr == null || arr.length < 2) {
        return;
    }
    int mostBit = 1;  // 获取数组中的数字最大的有多少位
    for (int n : arr) {
        mostBit = Math.max(mostBit, getBit(n));
    }
    int[] temp = new int[arr.length];  // 辅助数组
    for (int i = 1; i <= mostBit; i++) {
        int[] countArr = new int[10];
        for (int n : arr) {
            countArr[getDigit(n, i)]++;
        }
        for (int j = 1; j < 10; j++) {
            countArr[j] += countArr[j - 1];
        }
        // 此时必须要保证排序的稳定性
        // 因为百位数的排序过程中要保留十位数的排序结果
        for (int j = arr.length - 1; j >= 0; j--) {
            temp[--countArr[getDigit(arr[j], i)]] = arr[j];
        }
        for (int j = 0; j < temp.length; j++) {
            arr[j] = temp[j];
        }
    }
}
public static void radixSortInNegative(int[] arr) {
    // 对负数进行基数排序
    if (arr == null || arr.length < 2) {
        return;
    }
    int mostBit = 1;  // 获取数组中的数字最大的有多少位
    for (int n : arr) {
        mostBit = Math.max(mostBit, getBit(n));
    }
    int[] temp = new int[arr.length];  // 辅助数组
    for (int i = 1; i <= mostBit; i++) {
        int[] countArr = new int[10];
        for (int n : arr) {
            countArr[-getDigit(n, i)]++;
        }
        for (int j = 1; j < 10; j++) {
            countArr[j] += countArr[j - 1];
        }
        for (int j = arr.length - 1; j >= 0; j--) {
            temp[--countArr[-getDigit(arr[j], i)]] = arr[j];
        }
        for (int j = 0; j < temp.length; j++) {
            arr[j] = temp[j];
        }
    }
    for (int i = 0; i < arr.length; i++) {
        temp[i] = arr[arr.length - 1 - i];
    }
    for (int i = 0; i < arr.length; i++) {
        arr[i] = temp[i];
    }
}
public static void radixSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    int positiveNum = 0;
    int negativeNum = 0;
    for (int n : arr) {
        if (n >= 0) {
            positiveNum++;
        } else {
            negativeNum++;
        }
    }
    int[] positiveArr = new int[positiveNum];
    int[] negativeArr = new int[negativeNum];
    positiveNum = 0;
    negativeNum = 0;
    for (int n : arr) {
        if (n >= 0) {
            positiveArr[positiveNum++] = n;
        } else {
            negativeArr[negativeNum++] = n;
        }
    }
    radixSortInPositive(positiveArr);
    radixSortInNegative(negativeArr);
    for (int i = 0; i < negativeNum; i++) {
        arr[i] = negativeArr[i];
    }
    for (int i = 0; i < positiveNum; i++) {
        arr[i + negativeNum] = positiveArr[i];
    }

}

8.3 计数排序

使用一个长度为max-min+1的数组，每一个元素都是计数器，然后统计原始数组中各个数字的个数（计数排序）

public static void countSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for (int n : arr) {
        max = Math.max(max, n);
        min = Math.min(min, n);
    }
    int N = max - min + 1;
    int[] countArr = new int[N];
    for (int n : arr) {
        countArr[n - min]++;
    }
    int j = 0;
    for (int i = 0; i < N; i++) {
        while (countArr[i] != 0) {
            arr[j++] = i + min;
            countArr[i]--;
        }
    }
}

桶排序总结

  • 计数排序就是当桶的个数为max-min+1的桶排序
  • 基数排序是对每一位进行桶排序

排序的稳定性

排序前后两个相等的数相对位置不变，则这种排序是稳定的，反之不稳定

各种排序对比

排序名称时间复杂度空间复杂度稳定性
冒泡排序O(n^2)O(1)稳定
选择排序O(n^2)O(1)稳定
插入排序O(n)~O(n^2)O(1)稳定
希尔排序O(nlog(n))O(K)稳定
归并排序O(nlog(n))O(n)稳定
快速排序O(nlog(n))O(log(n))~O(n)不稳定
堆排序O(nlog(n))O(1)不稳定
桶排序O(nlog(n/K))O(n)稳定
基数排序O(n)O(K)稳定
计数排序O(Kn)O(n+K)稳定
稽函数
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Qt-无标题窗口
学而思
05-21 7591
        今天学习了下无标题窗口，于是来记录下我的学习过程首先建立一个Qt Widgets Application继承QWidget类创建完后直接运行就得到了如下效果那么，既然是无标题窗口就要去掉窗口栏啊，于是加上setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);去掉标题栏，但是这样整个窗口就不能移动...
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
C#中实现无标题栏窗体拖动的代码
热门推荐
百锦再的博客
01-18 1万+
事件来实现拖动功能。当鼠标按下时，我们标记鼠标正在拖动，并保存当前坐标。在鼠标移动时，如果鼠标正在拖动，我们更新窗体的位置，使其跟随鼠标移动。当鼠标释放时，我们取消拖动标记。请注意，在窗体上添加了对应事件处理程序的窗体控件属性应该设置为对应的事件处理程序方法。在窗体设计视图，选择属性窗格，在事件选项卡中为。在C#中实现无标题栏窗体拖动的代码可以通过处理鼠标事件来实现。这样，当你在运行窗体时，你就可以通过鼠标拖动窗体来改变其位置。事件分别选择对应的处理程序方法。在这个示例代码中，我们通过处理。
C# 移动无标题栏无边框窗体的3种方法
SabreWulf
03-13 2279
目录 第一种：手工移动 第二种：调用系统API 1.引入下面代码 前提需要引入命名空间using System.Runtime.InteropServices 2.增加鼠标按下事件发送消息，让系统误以为按下是标题栏 第三种，重写 WndProc 第一种：手工移动 直接通过修改窗体位置从而达到移动窗体的效果 //定义一个位置信息Point用于存储鼠标位置 private Point mPoint; /// <summary>
Qt实现改变无标题栏窗体大小及移动窗体
danshiming的博客
11-10 3494
Qt实现鼠标左键拖动无标题栏窗体右下角改变窗体大小及移动窗体
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
Delphi实现拖动按钮移动无标题栏窗口
05-11
摘要:Delphi源码,界面编程,窗体拖动,无标题栏 无标题栏的窗体的拖动功能实现，Delphi添加一个可拖动窗体的按钮，通过对此按钮的控制可移动窗体，实现按住标题栏移动窗口的功能，无标题栏也就不能显示最大化、最小化...
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
visual c++取掉对话框窗口的 -无标题 字样的方法
08-04
在Visual C++编程环境中，创建窗口应用程序时，默认情况下，窗口标题栏可能会显示“-无标题”字样，这通常是由于没有正确设置窗口类或没有自定义窗口标题所导致的。要解决这个问题，我们需要深入理解Windows API中的...
C语言进阶版第8课—指针（2）
weixin_70620792的博客
09-07 690
其他任何地方使用数组名，数组名都表示首元素的地址。sizeof（数组名）指针数组模拟二维数组。
CSP-J 算法基础 排序算法的基本概念
m0_62599305的博客
09-10 765
排序算法是计算机科学中最基础的算法之一，广泛应用于数据处理、搜索、优化等各种场景。排序的目的是将一组数据按一定的顺序（通常是升序或降序）排列，以便后续的高效处理。常见的排序算法有很多种，每种算法都有其特点和适用场景。本文将介绍排序算法的基本概念，并总结这些算法的优缺点和应用场景。排序算法的稳定性就是看相同值的元素在排序后是否保持原来的顺序。稳定排序算法确保了相同值元素的相对位置不会改变，而不稳定排序算法则可能会改变它们的相对顺序。理解这一点可以帮助你选择合适的排序算法来满足特定的需求。有序度。
Java数据结构（八）——插入排序、希尔排序
xiaokuer_的博客
09-07 946
文章介绍了两种插入式排序方法：插入排序和希尔排序。
排序算法-std::sort的使用（待学习第一天）
qq_33867768的博客
09-07 562
你还可以通过传递一个比较函数或比较谓词来改变排序规则。// 使用自定义比较函数对vector进行排序// 输出排序后的vectorreturn 0;// 使用lambda表达式对vector进行排序});// 输出排序后的vectorreturn 0;
数据结构（六）----排序
weixin_73579966的博客
09-07 778
上面这三个是比较基础的排序算法，通常归在一起比较，从性能上来说，插入>冒泡>选择（诶嘿冒泡居然还不是倒数第一）下面将要介绍的则是一些改进的、有技术含量的排序了完结撒花！！！相信如果你掌握了本讲的所有排序算法并且能熟练手撕出来，你绝对是面试中的佼佼者1。
CSP-J 算法基础 选择排序
最新发布
m0_62599305的博客
09-10 276
选择排序（Selection Sort）是一种简单直观的排序算法，其工作原理是每次从未排序的部分中选出最小（或最大）的元素，将其与当前的第一个元素交换位置，然后缩小未排序部分的范围。每一轮都会找到剩余部分中的最小元素，逐步构建一个有序的数组。选择排序的时间复杂度为 O(n²)，不适合大数据集，但由于其实现简单，通常被用于教学和理解基本排序算法的入门。选择排序通过每轮选择未排序部分中的最小元素并将其放到已排序部分末尾的方式完成排序。
归并排序/计数排序
m0_51952310的博客
09-07 962
归并排序/计数排序的实现代码和大致思路：
CSP-J 算法基础之插入排序
m0_62599305的博客
09-10 219
插入排序（Insertion Sort）是一种简单且高效的排序算法，特别适用于数据规模较小的情况。它的工作原理类似于将扑克牌整理成顺序，通过逐步将每张牌插入到已排序部分的适当位置。插入排序在处理小规模数据时具有较好的性能，并且易于实现。由于其时间复杂度为 O(n²)，在大规模数据集上效率较低。然而，插入排序在数据接近有序时表现尤为出色，是一种直观且易于理解的排序算法。插入排序通过逐步将元素插入到已排序部分来实现有序排列。每一轮通过比较，找到适当的位置插入当前元素，并通过元素的移动来为它腾出空间。
C语言代码练习(第十八天)
2201_75306399的博客
09-09 643
C语言代码练习
设置无标题 android
05-02
在Android应用中，设置无标题是一种简洁和美观的设计方式，可以为用户提供更流畅的使用体验。以下是一些实现设置无标题的方法： 1. 在Android的Manifest文件中，找到对应Activity的标签，并添加”android:theme="@...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

稽函数

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值