七种基本的排序算法

最新推荐文章于 2022-03-17 14:54:56 发布
最新推荐文章于 2022-03-17 14:54:56 发布
阅读量128 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 工作日志 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingchengxiaoye/article/details/115035515

排序时间复杂度

image-20210320141338807

1、冒泡排序

1.1、实现思路

image-20210319084323614

1.2、实现代码

public class Demo1 {
    public static void main(String[] args) {
        int [] a=new int[80000];
        for (int i = 0; i < 80000; i++) {
            a[i]= (int)(Math.random()*80000);
        }
        Date date = new Date();
        sort(a);
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        String format1 = simpleDateFormat.format(date1);
//        System.out.println(Arrays.toString(a));
        System.out.println(format);
        System.out.println(format1);
    }

    public static void sort(int[] a) {
        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) {
                break;
            } else {
                flag = false;
            }

        }
    }
}

1.3、时间复杂度

  • O(n^2)

2、选择排序

2.1、实现思路

image-20210319093618801

2.2、代码实现

public class Demo2 {
    public static void main(String[] args) {
        int [] a=new int[80000];
        for (int i = 0; i < 80000; i++) {
            a[i]= (int)(Math.random()*80000);
        }
        Date date = new Date();
        sort(a);
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        String format1 = simpleDateFormat.format(date1);
        //        System.out.println(Arrays.toString(a));
        System.out.println(format);
        System.out.println(format1);
    }

    public static void sort(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 (arr[j] < min) {
                    minIndex = j;//重置最小值
                    min = arr[j];//重置最小索引
                }
            }
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }

    }
}

3、插入排序

3.1、实现思路

image-20210319145332603

3.2、代码实现

public class Demo3 {
    public static void main(String[] args) {
        int[] arr={7,3,1,5,8};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int insertVal=arr[i];
            int insertIndex=i-1;
            while (insertIndex>=0&&insertVal<arr[insertIndex]){
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;
            }
            arr[++insertIndex]=insertVal;
        }
    }
}

4、希尔排序

4.1、实现思路

image-20210319161521389

4.2、代码实现

4.2.1、交换式

public class Demo4 {
    public static void main(String[] args) {
        int [] arr={2,1,7,3,8,4};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] arr){
        int temp=0;
        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;
                    }
                }
            }
        }
    }
}

4.2.2、移位式

public static void shellSort2(int[] arr){
        for (int gap = arr.length/2; gap >0 ; gap /=2){
            for (int i = gap; i < arr.length; i++) {
                int j=i;
                int temp=arr[i];
                if (arr[j]<arr[j-gap]){
                    while (j-gap>=0&&temp<arr[j-gap]){
                        arr[j]=arr[j-gap];
                        j-=gap;
                    }
                    arr[j]=temp;
                }
            }
        }
    }

4.3、总结

移位式的效率明显优于交换式，所以推荐使用移位式

5、快速排序

5.1、实现思路

image-20210319174317813

image-20210319174341783

5.2、代码实现

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

        while (r > l) {
            while (arr[l] < pivot) {
                ++l;
            }

            while (arr[r] > pivot) {
                --r;
            }
            if (l >= r) {
                break;
            }
            int temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

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

        }

        if (l == r) {
            --r;
            ++l;
        }
        if (r>left){
            quickSort(arr,left,r);
        }
        if (l<right){
            quickSort(arr,l,right);
        }
    }

6、归并排序

6.1、实现思路

image-20210320114236704

image-20210320104317842

image-20210320104252720

6.2、代码实现

public class Demo6 {
    public static void main(String[] args) {
        int[] arr = new int[8000000];

        for(int i = 0; i < 8000000; ++i) {
            arr[i] = (int)(Math.random() * 8000000.0D);
        }

        System.out.println("排序前");
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是=" + date1Str);
        int[] temp = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序前的时间是=" + date2Str);
    }

    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 left   左边有序序列的初始索引
     * @param mid    中间索引
     * @param right   右边有序序列的初始索引
     * @param temp      做中转的数组
     */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left;
        int j = mid + 1;
        int t = 0;

        while(i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                ++t;
                ++i;
            } else {
                temp[t] = arr[j];
                ++t;
                ++j;
            }
        }
        //将剩余的拷贝进去
        while(i <= mid) {
            temp[t] = arr[i];
            ++t;
            ++i;
        }

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

        t = 0;

        for(int tempLeft = left; tempLeft <= right; ++tempLeft) {
            arr[tempLeft] = temp[t];
            ++t;
        }

    }
}

7、基数排序

7.1、实现思路

image-20210320114854473

image-20210320115419474

image-20210320115838543

image-20210320115943389

7.2、代码实现

public class Demo7 {
    public static void main(String[] args) {
        int[] arr = new int[]{53, 3, 542, 748, 14, 214};
        System.out.println("排序前");
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是=" + date1Str);
        radixSort(arr);
        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序前的时间是=" + date2Str);
        System.out.println("基数排序后 " + Arrays.toString(arr));
    }

    public static void radixSort(int[] arr) {
        int max = arr[0];

        int maxLength;
        for(maxLength = 1; maxLength < arr.length; ++maxLength) {
            if (arr[maxLength] > max) {
                max = arr[maxLength];
            }
        }

        maxLength = String.valueOf(max).length();
        int[][] bucket = new int[10][arr.length];
        int[] bucketElementCounts = new int[10];
        int i = 0;

        for(int n = 1; i < maxLength; n *= 10) {
            int index;
            int k;
            for(index = 0; index < arr.length; ++index) {
                k = arr[index] / n % 10;
                bucket[k][bucketElementCounts[k]] = arr[index];
                int var10002 = bucketElementCounts[k]++;
            }

            index = 0;

            for(k = 0; k < bucketElementCounts.length; ++k) {
                if (bucketElementCounts[k] != 0) {
                    for(int l = 0; l < bucketElementCounts[k]; ++l) {
                        arr[index++] = bucket[k][l];
                    }
                }

                bucketElementCounts[k] = 0;
            }

            ++i;
        }

    }
}

     index = 0;

        for(k = 0; k < bucketElementCounts.length; ++k) {
            if (bucketElementCounts[k] != 0) {
                for(int l = 0; l < bucketElementCounts[k]; ++l) {
                    arr[index++] = bucket[k][l];
                }
            }

            bucketElementCounts[k] = 0;
        }

        ++i;
    }

}

}
7种基本排序算法
06-18
本文将详细介绍七种基本排序算法，包括插入排序、快速排序、希尔排序、归并排序、选择排序、冒泡排序（以及双向冒泡排序）和堆排序，这些都是用C语言实现的。对于初学者来说，理解和掌握这些算法有助于提升编程技能...
Java 七种排序算法实现
05-10
本资源包含了七种经典的排序算法实现，它们分别是冒泡排序、插入排序、递归排序（这里可能是指归并排序）、基数排序、快速排序、选择排序和希尔排序。下面我们将详细探讨这些排序算法的工作原理和实现方式。 1. **...
基本的排序算法
liNewman的博客
04-01 111
基本的排序算法 基本的排序算法 算法的学习核心是：思路，知道思路，清楚思路，明白思路的思考过程，写代码就会很轻松 快速排序 （递归的方法） 快速排序就是大学学的折半查找算法，或者说是二分查找；时间复杂度：每次把搜索区减少一半，最坏的时间复杂度：O(n*n)，最优的时间复杂度：...
基本排序算法
chenxy132的博客
04-02 202
几种排序方法的总结 参考文章链接：https://blog.csdn.net/jackesy/article/details/80135033 一.选择排序 基本思路：首先知道数组中最小的那个元素，其次将它与数组中的第一个元素交换位置（如果第一个元素是最小元素那么久和它自己交换）。再次在剩下的元素中找到最小元素，将它与数组的第...
基于python的七种经典排序算法(1).pdf
最新发布
07-24
本文将详细介绍基于Python语言实现的七种经典排序算法。这七种算法分别为：冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序和希尔排序。每种算法都有其独特的特点和适用场景，下面将一一展开介绍。 冒泡...
基于python的七种经典排序算法（推荐）
12-23
排序算法，就是如何使得记录按照要求排列的方法。 排序的稳定性： 经过某种排序后，如果两个记录序号同等，且两者在原无序记录中的先后秩序依然保持不变，则称所使用的排序方法是稳定的，反之是不稳定的。 内排序和...
基于python的七种经典排序算法.docx
11-25
【排序算法概述】 排序是计算机科学中的一项基本操作，它涉及将一组数据按照特定规则（通常是升序或降序）重新排列。排序算法是数据结构和算法领域的...然而，了解这些基本排序算法有助于深入理解排序过程和算法设计。
经典排序算法总结与实现 ---python
weixin_34303897的博客
06-03 210
原文：http://wuchong.me/blog/2014/02/09/algorithm-sort-summary/ 经典排序算法在面试中占有很大的比重，也是基础，为了未雨绸缪，在寒假里整理并用Python实现了七大经典排序算法，包括冒泡排序，插入排序，选择排序，希尔排序，归并排序，快速排序，堆排序。希望能帮助到有需要的同学。之所以用Python实现，主要是因为它更接近伪代码，能用更少的代码...
基本排序算法总结
M_Stockholm的博客
09-01 324
1、选择排序       首先找到数组中最小的元素，然后将其与第一个元素交换，如果最小元素是自己，就和自己交换。然后继续找后面元素中最小，与第二个元素交换，如此往复，直到最后一个元素。 排序代码如下 public static void Sort(Comparable[] a) //选择排序 { int N = a.length; for (int i = 0; i < N;
各种基本排序算法
melouver的博客
03-23 228
插入排序 稳定void insertion_sort(vector&lt;int&gt; &amp;v) { for (int i = 1; i &lt; v.size(); i++) { int tmp = v[i]; int j = i-1; while (j &gt;= 0 &amp;&amp; v[j] &gt; tmp) { v[j+1] = v[...
JS中的算法与数据结构——排序（Sort）
weixin_34127717的博客
10-23 146
排序算法（Sort）引言我们平时对计算机中存储的数据执行的两种最常见的操作就是排序和查找，对于计算机的排序和查找的研究，自计算机诞生以来就没有停止过。如今又是大数据，云计算的时代，对数据的排序和查找的速度、效率要求更高，因此要对排序和查找的算法进行专门的数据结构设计，（例如我们上一篇聊到的二叉查找树就是其中一种），以便让我们对数据的操作更加简洁高效。这一篇我们将会介绍一些数据排序的基本算法和高级算...
最基本的八种排序算法
颖墨的博客
03-27 417
排序算法总共分成四大类
10种基本排序算法
Lenjor 的博客
02-28 3428
文章目录排序算法分类各排序算法复杂度分析（一）冒泡排序（Bubble Sort）算法描述（二）快速排序(Quick Sort)算法描述（三）、简单插入排序（Insertion Sort）算法描述（四）、希尔排序(Shell Sort)算法描述（五）、简单选择排序（Selection Sort）算法描述（六）、堆排序(Heap Sort)（七）、归并排序(Merge Sort)算法描述（八）、计数排序（Counting Sort）算法描述（九）、桶排序(Bucket sort)（十）、基数排序（Radix S
9种基础排序算法
Native Roma
03-18 1217
排序分类概览 时间空间复杂度概览 1.1.直接插入排序 算法思想 采用从小到大排序： 1.从位置1的数值n开始，将前面已经遍历过的数值集合看成数组m，则将n往m中插入 2.n插入到集合m中时从后往前比较，如果比n大则往后移一位，如果比较到比n小，则当前位置就是插入n的位置 3.通过1、2的操作则可以保证每次插入n后m的集合都是排好的序列 4.循环1、2、3操作将集合中所有数值均插入一遍即排序完成 代码实现 private int[] array = {23, 11, 7, 29, 33, 59, 8,
排序算法之基本几种排序方法
m0_57614828的博客
03-17 2034
排序算法 什么是排序算法 基本都排序算法有哪些 怎么衡量排序算法的优劣 冒泡排序的思想与c语言代码 插入排序的思想与c语言代码 1.什么是排序算法。 当你有一堆数据的时候，看着他们杂乱无章，无序的时候是不是看着特别不爽。是不是特想看着它们是从小到大，或者从大到小排列的，看着就舒服多了。还有哦，排序可不止是让你看着舒服，还有一部分是查找。在一堆数据中查找是否存在一个数据，如果是一堆杂乱无章的数据，我们就只能一个个比较，是否是你要的那个数据，...
C++实现五种基本排序算法效率对比
本文将详细介绍五种最基本的排序算法，包括插入排序、选择排序、希尔排序、快速排序和冒泡排序，以及如何用C++实现这些排序，并通过实验来统计比较次数和移动次数，从而比较各个算法的效率。 首先，我们来理解插入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值