排序算法及实现

于 2023-08-20 17:08:27 发布
阅读量322 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dolly_baby/article/details/132393758
版权

排序算法及实现

一、排序的分类

  1. 内部排序

内部排序把需要处理的数据加载到内存后排序。内部排序包括插入排序、选择排序、交换排序、归并排序、基数排序。插入排序分为直接插入排序和希尔排序。选择排序分为简单选择排序和堆排序。交换排序分为冒泡排序和快速排序。

  1. 外部排序

外部排序数据量很大，无法全部加载到内存中。

二、算法时间复杂度

  1. 事后统计方法
  2. 事前估算方法，分析时间复杂度
  3. 算法时间复杂度

一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间越多。一个算法中语句执行的次数称为语句频度或时间频度，记为T(n)。一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用==T(n)==表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的某个常数，则称f(n)是T(n)的同数量级函数，记为T(n)=O(f(n))，称为算法的时间复杂度。用常数1替代运行时间中的所有加法常数；修改后的运行次数函数中，只保留最高阶项；去除最高阶项的系数。平均时间复杂度是所有可能的输入实例均以等概率出现的情况下该算法的运行时间。一般讨论最坏时间复杂度。

  1. 算法空间复杂度

算法的空间复杂度定义为该算法所耗费的存储空间，它也是问题规模n的函数。空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。算法分析主要讨论的是时间复杂度。一些缓存产品和基数排序本质就是用空间换时间。

排序方法平均时间最差情形稳定度额外空间备注
冒泡O(n2)O(n2)稳定O(1)n小时较好
交换O(n2)O(n2)不稳定O(1)n小时较好
选择O(n2)O(n2)不稳定O(1)n小时较好
插入O(n2)O(n2)稳定O(1)大部分已排序时较好
基数O(logRB)O(logRB)稳定O(n)B是真数（0-9），R是基数。
希尔O(nlogn)O(nx) 1<x<2不稳定O(1)n是所选分组
快速O(nlogn)O(n2)不稳定O(nlogn)n大时较好
归并O(nlogn)O(nlogn)稳定O(1)n大时较好
堆O(nlogn)O(nlogn)不稳定O(1)n大时较好

三、 冒泡排序

通过对待排序序列从前向后，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底的气泡一样逐渐向上冒。

import java.util.Arrays;

public class BubbleSort {

    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
        System.out.println("排序前数组:" + Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("排序后数组:" + Arrays.toString(arr));

        //排序性能测试
        long t1 = System.currentTimeMillis();
        int[] benchMarkArr = new int[80000];
        for(int i=0;i<80000;i++){
            benchMarkArr[i] = (int) (Math.random() * 80000 * 10);
            bubbleSort(benchMarkArr);
        }

        long t2 = System.currentTimeMillis();
        System.out.println("排序时间:" + (t2 - t1));
    }

    /**
     * 冒泡排序：第i轮需要进行n-1-i次比较，如果已经有序了则直接退出排序
     * @param arr 待排序数组
     */
    private static void bubbleSort(int[] arr){
        //表示是否需要交换
        boolean flag = false;
        //外层循环控制是第几趟
        for(int i=0;i<arr.length;i++){
            //内层循环控制每趟需要比较的次数
            for(int j=0;j<arr.length-1-i;j++){
                int tmp;
                if(arr[j] > arr[j+1]){
                    flag = true;
                    tmp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = tmp;
                }
            }

            if(!flag){
                break;
            }else{
                //重置flag进行下次判断
                flag = false;
            }
        }
    }

    /**
     * 冒泡排序优化
     * @param arr 待排序数组
     */
    private static void bubbleSortV2(int[] arr){
        int n = arr.length - 1;
        do {
            //表示最后一次交换索引位置
            int last = 0;
            for (int i = 0; i < n; i++) {
                System.out.println("比较次数:" + i);
                if (arr[i] > arr[i + 1]) {
                    int tmp = arr[i + 1];
                    arr[i + 1] = arr[i];
                    arr[i] = tmp;
                    last = i;
                }
            }
            n = last;
        } while (n != 0);
    }
}

四、简单选择排序

简单选择排序是一种简单的排序方法。第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]~arr[n-1]中最小值，与arr[1]交换，依次类推。总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

import java.util.Arrays;

public class PickupSort {

    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
        pickupSortV2(arr);
    }

    private static void pickupSort(int[] arr) {
        for(int i=0;i<arr.length-1;i++){
            //index定义为最小值的下标，i表示每轮选择的最小元素要交换的目标索引
            int index = i;
            int min = arr[i];
            for(int j=i+1;j<arr.length;j++){
                if(min > arr[j]){
                    min = arr[j];
                    index = j;
                }
            }

            if(index != i){
                arr[index] = arr[i];
                arr[i] = min;
            }

            System.out.println("第" + (i+1) + "轮排序结果:" + Arrays.toString(arr));
        }
    }

    private static void pickupSortV2(int[] arr){
        int s;
        for(int i=0;i<arr.length-1;i++){
            s = i;
            for(int j=s+1;j<arr.length;j++){
                if(arr[j] < arr[s]){
                    s = j;
                }
            }

            int tmp;
            if(s != i){
                tmp = arr[s];
                arr[s] = arr[i];
                arr[i] = tmp;
            }

            System.out.println("第" + (i+1) + "轮排序结果:" + Arrays.toString(arr));
        }
    }
}

五、直接插入排序

把n个待排序的元素看成一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响。

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
        insertSortV2(arr);
    }

    private static void insertSort(int[] arr) {
        //把序列分成有序数组和无需数组，其中第0位默认有序
        for(int i=1;i<arr.length;i++){
            //i表示待插入元素的索引，tmp表示待插入的值
            int tmp = arr[i];
            int j = i;
            while(j > 0 && tmp < arr[j-1]){
                arr[j] = arr[j-1];
                j--;
            }

            //发生了交换
            if(j != i){
                arr[j] = tmp;
            }

            System.out.println("第" + (i+1) + "轮排序结果:" + Arrays.toString(arr));
        }
    }

    private static void insertSortV2(int[] arr){
        for(int i=1;i<arr.length;i++){
            //i表示待插入元素的索引，tmp待插入的元素值
            int tmp = arr[i];
            int j = i - 1; //表示已排序取余的元素索引
            while(j>=0){
                if(arr[j] > tmp){
                    arr[j+1] = arr[j];
                }else{
                    break; //退出循环，减少比较次数
                }
                j--;
            }
            arr[j+1]=tmp;
            System.out.println("第" + i + "轮排序结果:" + Arrays.toString(arr));
        }
    }
}

六、希尔排序

把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量的减少，每组包含的关键词越来越多，当增量减至1时，整个文件被分成一组，算法便终止。

import java.util.Arrays;

public class ShellSort {

    public static void main(String[] args) {
        //int[] arr = {53, 3, 542, 748, 14, 214};
        long t1 = System.currentTimeMillis();
        int[] arr = new int[800];
        for(int i=0;i<800;i++){
            arr[i] = (int) (Math.random() * 800 * 10);
        }

        shellSort(arr);
        System.out.println("希尔排序耗时：" + (System.currentTimeMillis() - t1));
    }

    //使用移位法
    private static void shellSort(int[] arr) {
        for(int gap = arr.length/2; gap > 0; gap /= 2){
            for(int i = gap; i < arr.length; i++){
                int j = i;
                int tmp = arr[j];
                if(arr[j] < arr[j-gap]){
                    while(j - gap >= 0 && tmp < arr[j-gap]){
                        arr[j] = arr[j-gap];
                        j -= gap;
                    }

                    arr[j] = tmp;
                }
            }

            System.out.println(Arrays.toString(arr));
        }
    }
}

七、快速排序

快速排序是对冒泡排序的一种改进。基本思想是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据都变成有序序列。

import java.util.Arrays;

public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {-9, 78, 0, 23, -567, 70};
        //quickSort(arr, 0, arr.length-1);
        quickSortV3(arr, 0, arr.length-1);
        System.out.println("排序结果：" + Arrays.toString(arr));

    }

    private static void quickSort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int pivot = arr[(left + right)/2];
        while(l < r){
            while(arr[l] < pivot){
                l++;
            }

            while(arr[r] > pivot){
                r--;
            }

            if(l >= r){
                break;
            }

            swap(arr, l, r);
            if(arr[l] == pivot){
                l++;
            }

            if(arr[r] == pivot){
                r--;
            }
        }

        if(l == r){
            l++;
            r--;
        }

        if(left < r){
            quickSort(arr, left, r);
        }

        if(right > l){
            quickSort(arr, l, right);
        }
    }

    private static void quickSortV2(int[] arr, int low, int high){
        if(low >= high){
            return;
        }

        int p = partition(arr, low, high); //获得第一次分区后的索引值
        quickSortV2(arr, low, p-1); //左边分区的范围确定
        quickSortV2(arr, p+1, high);
    }

    private static void quickSortV3(int[] arr, int low, int high){
        if(low >= high){
            return;
        }

        int p = partitionV2(arr, low, high); //获得第一次分区后的索引值
        quickSortV3(arr, low, p-1); //左边分区的范围确定
        quickSortV3(arr, p+1, high);
    }

    /**
     *
     * @param arr 待排序数组
     * @param low 下边界
     * @param high 上边界
     * @return 基准点元素所在的正确的索引，用来确定下一轮分区的边界
     */
    private static int partition(int[] arr, int low, int high){
        int pivot = arr[high]; //基准点元素
        int i = low;
        for(int j=low;j<high;j++){
            if(arr[j] < pivot){
                if(i != j) {
                    swap(arr, i, j);
                }
                i++;
            }
        }

        if(i != high) { //优化点：i与high相等时没必要交换
            swap(arr, high, i);
        }
        System.out.println(Arrays.toString(arr) + " i=" + i);
        return i;
    }

    private static int partitionV2(int[] arr, int low, int high){
        int pivot = arr[low];
        int i = low;
        int j = high;
        while(i < j){
            //j从右往左找比基准点小的数，i从左向右找到比基准点大的数
            while(i < j && arr[j] > pivot) j--;
            while(i < j && arr[i] <= pivot) i++;
            swap(arr, i, j);
        }
        swap(arr, low, j);
        System.out.println(Arrays.toString(arr) + ",j=" + j);
        return j;
    }

    private static void swap(int[] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

八、归并排序

归并排序时利用归并的思想实现的排序方式，该算法采用经典的分治策略分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案修补在一起，即分而治之。

import java.util.Arrays;

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = {-9, 78, 0, 23, -567, 70};
        mergeSort(arr);
        System.out.println("归并排序后数组:" + Arrays.toString(arr));
    }

    private static void mergeSort(int[] arr){
        sort(arr, 0, arr.length - 1);
    }

    private static void sort(int[] arr, int left, int right){
        if(left >= right){
            return;
        }

        int mid = (left + right)/2;
        sort(arr, left , mid);
        sort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }

    private static void merge(int[] arr, int left, int mid, int right){
        //创建一个临时数组
        int[] tmp = new int[arr.length];
        int i = left;
        int j = mid + 1;
        int t = 0;

        //1.把左右两边数据按照规则填充到tmp数组,直到左右两边的有序序列有一边处理完毕为止
        while(i <= mid && j<= right){
            if(arr[i] <= arr[j]){
                tmp[t++] = arr[i++];
            }else{
                tmp[t++] = arr[j++];
            }
        }

        //2.把有剩余数据的一边所有数据依次填充到tmp
        while(i <= mid){
            tmp[t++] = arr[i++];
        }

        while(j <= right){
            tmp[t++] = arr[j++];
        }

        //3.把tmp中的数据移入arr数组
        t = 0;
        int temp = left;
        while(temp <= right){
            arr[temp++] = tmp[t++];
        }
    }
}

九、基数排序

基数排序属于分配式排序，又称桶子法（bucket sort）。通过键值的各个位的值，将要排序的元素分配至某些桶中，达到排序的作用。基数排序属于稳定性的排序，效率较高，是桶排序的扩展。将所有待比较的数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序数列。

import java.util.Arrays;

/**
 * 基数排序：桶排序的扩展，是分配式的排序，通过将数字的各个位的值，将要排序的元素分配到这些桶中，达到
 * 排序的目的。基数排序是稳定排序，效率较高。
 */
public class RadixSort {

    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
        radixSort(arr);

        long t1 = System.currentTimeMillis();
        int[] benchMarkArr = new int[80000];
        for(int i=0;i<8000;i++){
            benchMarkArr[i] = (int) (Math.random() * 80000 * 10);
            radixSort(benchMarkArr);
        }

        long t2 = System.currentTimeMillis();
        System.out.println("排序时间:" + (t2 - t1));
    }

    /**
     * 基本思想：把所有待排序的数统一为同样的数位长度，数位较短的数前面补零。
     * 然后从最低为开始依次排序，这样从最低位排序一直到最高位排序完成以后，
     * 数列就变成了一个有序数列。
     */
    private static void radixSort(int[] arr){
        if(arr == null){
            return;
        }

        //第一轮（针对每个排序数的各位进行排序）
        //定义一个二维数组表示10个桶，每个桶就是一维数组，为了防止放入数据时溢出，一维数组大小就是数组大小
        int[][] bucket = new int[10][arr.length];
        //记录每个桶中实际存放元素的个数，bucketElemCounts[0]记录0号桶中元素的个数
        int[] bucketElemCounts = new int[10];
        //一维数组中最大位的位数
        int max = arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }

        int maxLength = (max + "").length();

        for(int i=0, n=1; i<maxLength; i++,n*=10) {
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素对应的位，放入到对应的桶中
                int digitOfElem = arr[j]/n % 10;
                bucket[digitOfElem][bucketElemCounts[digitOfElem]] = arr[j];
                bucketElemCounts[digitOfElem]++;
            }
            //按照桶的顺序，一维数组的下标依次取出数据，放入原来的数组
            int index = 0;
            for (int k = 0; k < bucketElemCounts.length; k++) {
                if(bucketElemCounts[k] != 0){
                    for(int l=0;l<bucketElemCounts[k];l++){
                        arr[index++] = bucket[k][l];
                    }
                }

                //处理后重置桶
                bucketElemCounts[k] = 0;
            }

            System.out.println("第" + (i+1) + "轮排序：" + Arrays.toString(arr));
        }
    }

}

十、堆排序

堆排序是利用堆这种数据结构而设计的一种排序方法，堆排序是一种选择排序，最坏、最好、平均时间复杂度均为O(nlogn)，它也是不稳定排序。堆是二叉树，每个节点的值都大于或等于其左右孩子节点的值，称为大顶堆，没有要求节点的左孩子和右孩子的值大小关系；每个节点的值都小于或等于其左右孩子节点的值，称为小顶堆。堆排序的步骤是把待排序序列构造成一个大顶堆；此时整个序列的最大值就是堆顶的根节点；将其与末尾元素进行交换，此时末尾就为最大值；然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值，如此反复执行，就能得到一个有序序列了。

import java.util.Arrays;

/**
 * 堆排序
 */
public class HeapSort {
    public static void main(String[] args) {
        int[] arr = {4, 6, 8, 5, 9, 10, 13};
        heapSort(arr);
        System.out.println("堆排序结果：" + Arrays.toString(arr));
    }

    private static void heapSort(int[] arr){
        //从最后一个非叶子节点从右至左，从下至向上调整最大堆
        for(int i=arr.length/2-1;i>=0;i--){
            adjustHeap(arr, i, arr.length);
        }

        //把栈顶元素与末尾元素进行交换，然后继续调整堆
        for(int i=arr.length-1; i>0;i--){
            swap(arr, 0, i);
            adjustHeap(arr, 0, i);
        }
    }

    /**
     * 把一个数组（二叉树）调整成一个大顶堆
     * @param arr 待排序数组
     * @param i 非叶子节点在数组中的索引
     * @param len 堆多少个元素进行调整
     */
    private static void adjustHeap(int[] arr, int i, int len){
        int current = arr[i];
        //k指向i的左子节点
        for(int k=2*i+1;k<len;k=k*2+1){
            if(k+1 < len && arr[k] < arr[k+1]){
                k++;
            }

            if(arr[k] > current){
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }

        arr[i] = current;
    }


    private static void swap(int[] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}
快乐江小鱼
关注
专栏目录
数据结构与算法—常见的几种排序算法及实现（java）
zeng_ll的博客
02-25 1963
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。 以下我们将介绍几种常见的排序，几种排序算法的时间复杂度及稳定性如下： 1、冒泡排序 冒泡排序的效率很低，但是算法实现起来很简单，因此很适合作为研究排序的入门算法。 基本思想 对当前还未排好序的...
广州大学 数据结构实验报告 实验四 查找和排序算法实现
05-23
实验报告的主题聚焦于数据结构中的查找和排序算法实现，这是计算机科学中基础且重要的部分，尤其是在处理大量数据时。以下是对这些算法的详细说明： 1. **插入排序**：插入排序的基本思想是将一个记录插入到已经排...
6种排序算法的排序系统
01-10
能选择六种排序任意一个排序算法进行排序，并输出结果 1：自定义一个大小和元素的数组。 2：有六种排序算法供选择。 3：用所选择的算法进行排序 4：能循环使用。
十大排序算法基本原理及其实现
weixin_61543874的博客
07-09 1112
十大排序算法基本原理及其实现
常用排序算法与实现
lx1997530的博客
03-07 243
1. 插入排序 1.1直接插入排序
常见排序算法及其实现
最新发布
m0_52025138的博客
08-09 337
我相信在每一个程序员进行编程入门的过程中，当涉及到算法学习时，排序算法定首当其冲！所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。同时，排序算法在实际过程中也有着非同小可的作用，如经过排序的数据可以显著提高搜素效率、使数据更易观察和理解等；因此笔者的这篇博客，主要来记录与总结一下笔者最近对常见排序算法的学习要点以及它们的实现（C语言实现）。
几种排序算法的实现
wangjiaoni的专栏
07-08 1890
/**////////////////////////////////////////////////////////////////////////////////////////////////**//*利用随机函数产生N个随机整数（2000以上），对这些数进行多种方法进行排序。要求：至少采用三种方法实现（提示，可采用插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）。并
详解计数排序算法及C语言程序中的实现
12-25
关于计数排序算法 当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。 由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待...
利用前端动画实现算法可视化，比如各种排序算法动画实现.zip
06-01
这个名为"利用前端动画实现算法可视化，比如各种排序算法动画实现.zip"的资源包，旨在帮助我们利用前端技术来动态演示算法的过程，特别是各种排序算法。这不仅能够帮助初学者更好地理解算法的工作原理，也对专业...
Verilog/C++实现排序算法：Verilog/C++实现排序算法：冒泡排序、选择排序、并行全比较排序、串行全比较排序
06-27
本文将探讨如何使用这两种语言实现几种基本的排序算法：冒泡排序、选择排序，以及两种全比较排序（并行和串行）。 首先，让我们了解一下排序算法。排序是计算机科学中最基础的操作之一，它涉及到将一组数据按照特定...
各种排序算法小结和实现
小胡——uYou的专栏
05-10 927
各种排序算法想必大家都不陌生，定义我就不多介绍了，直接写下自己的一些小结。快速排序：可以算的上应用最广的排序算法。其排序思路是随机选取一个数字作为标志，使得小于它的数在它左边，大于它的数在它的右边，然后递归对两边的数据排序。 归并排序：应用分之的思想，先将要排序的分为两列，然后分别进行排序，然后合并到另一 个数组中，最后再进行把它复制回来。 冒泡排序：是稳定排序，适用于排列的数组较小而且基
排序系统
墨海灬流弈的博客
12-29 371
备注： 内部包含6种排序方式。 #include<iostream> using namespace std; typedef int ElementType; //交换 void Swap(ElementType *a,ElementType *b) { ElementType t=*a; *a=*b; *b=t; } //输出 void puts(ElementType A[],int N) { int i=0; for(i=0;i<N;i++) { cout&lt
【数据结构】常见八大排序的实现
m0_51064412的博客
07-27 1184
文章目录一. 排序相关的概念二. 常见排序算法的实现1. 直接插入排序2. 希尔排序 一. 排序相关的概念 排序概念 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 排序的稳定性 在未排序前，a下标对应的值和b下标对应的值相等（a < b），排序后如果这两个位置的相等值仍然保持和排序前一样的前后顺序则说明该排序稳定。 内部排序 数据元素全部放在内存中的完成的排序。 外部排序 数据元素太多不能同时放在内存中完成排序，只能放到文件或磁盘中（存在文件或磁盘中就不能
简单的排序系统（C语言）
weixin_45876091的博客
08-20 417
简单的排序系统（C语言） #include<stdio.h> #include"stdlib.h" #define MAXSIZE 100 /线性表中最大元素个数/ typedef int KeyType1; /关键字类型/ typedef struct { KeyType Key; /关键字域/ }LineList; void bubble(LineList a[],int n) //冒泡排序 { int i,j,temp; for(i=0;i<n
Java实现七种【排序算法】+图解+完整代码+分析
Zhou_LC的博客
12-13 4428
参考书目：《大话数据结构》 一、冒泡排序（优化版）： 0.基本思想：一种交换排序，两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录位置。 1.思路图解： 2.代码实现： public class BubbleSort { public static void sort(int[] a) { int i, j; boolean flag = true; int n = a.length - 1; for (i = 1;
基于C语言实现的6种排序算法的排序系统
qq_41522951的博客
01-10 2873
排序系统 题目：自定义一个大小和元素自设的数组，能选择六种排序任意一个排序算法进行排序，并输出结果 需求分析： 需求1：需要设定一个大小和元素都可以自设的数组。 需求2：需要六种排序算法。 需求3：需要设定一个选择结构。 需求4：能循环使用 （没说自己加的） 设计流程 （1） 选择是否进入系统 （2） 输入要设计数组得大小 （3） 给数组中输入元素 （4） 选择排序得方法 （5） 输出结果 （6）...
"设计一个排序系统"(python)
LeoLee
03-09 711
题目描述：设计一个排序系统，能够让每个进入队伍的用户都能看的自己在队列中所处的位置和变化，队伍可能随时有人加入和退出；当有人退出影响到用户的位置排名时需要及时反馈到用户。 from collections import deque class User: def __init__(self, id, name): self.id = id # 唯一标识一个用户 ...
数据结构排序系统C实现（低时间、空间复杂度）
xjzjyx_的博客
04-07 632
一、需求 1.实现插入排序有关算法（直接插入排序、折半插入排序、希尔排序） 2.实现交换排序有关算法（冒泡排序、快速排序） 3.实现选择排序有关算法（简单选择排序、堆排序） 4.其他排序算法（归并排序、基数排序） 二、解决方案 1.采用顺序存储结构，待排关键字个数可变 2.采用顺序表判空函数和清空函数，实现一块内存多次使用，实现最低空间复杂度 三、代码 #include "pch.h" #incl...
实验七 排序算法的实现
m0_63708766的博客
06-09 349
（1）以下是一个通过随机数来测试排序算法运行时间的程序，中间留出了加入排序算法的部分。），在无序状态下进行多次运行，记录运行时间，并比较测试结果。（2） 从选择、交换、插入排序算法中任选。1、掌握插入排序算法和交换排序算法。3)随机数种子函数srand( )2、掌握各种排序算法的优劣。2)时间函数clock（）1）随机函数rand（）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

快乐江小鱼

知识创造财富，余额还是小数

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

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

打赏作者

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

抵扣说明：

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

余额充值