【数据结构】几种排序的代码以及时间复杂度分析和优化

最新推荐文章于 2024-03-12 17:47:05 发布
最新推荐文章于 2024-03-12 17:47:05 发布
阅读量326 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41306220/article/details/105677115
版权

1、直接插入排序

//时间复杂度是O(n^2)
public class InsertDirectly {
    public static void main(String[] args) {
        int[] arrays=new int[]{49,38,65,97,76,13,27,49};
        int i,j,temp;
        for(i=1;i<arrays.length;i++){
            temp=arrays[i];
            j=i-1;
            while (j>=0 && temp<arrays[j]){
                arrays[j+1]=arrays[j];
                --j;
            }
            arrays[j+1]=temp;
        }
        for (int a=0;a<arrays.length;a++){
            System.out.println(arrays[a]);
        }

    }
}

考虑最坏情况，数组是逆序的，最内层循环执行次数是n,n-1,n-2…加起来以后是n(n-1)/2，所以时间复杂度是O(n^2)

2、折半插入

//时间复杂度最坏是O(n^2)，最好是O(nlog2^n)，平均是O(n^2)
public class HalfInsert {
    public static void main(String[] args) {
        int[] arrays=new int[]{13,38,49,65,76,97,27};
        for(int i=0;i<arrays.length;i++){
            int low=0;
            int high=i-1;
            int temp=arrays[i];
            while(low<=high){
                int middle=(high+low)/2;
                if(arrays[middle]>temp){
                    high=middle-1;
                }else{
                    low=middle+1;
                }
            }
            for(int j=i-1;j>high;j--){
                arrays[j+1]=arrays[j];
            }
            arrays[high+1]=temp;
        }

        for(int a=0;a<arrays.length;a++){
            System.out.println(arrays[a]);
        }
    }
}

3、希尔排序

//最佳情况：T(n) = O(nlogn)。最坏情况：T(n) = O(n)。平均情况：T(n) = O(nlogn)
public class ShellSort {
    public static void main(String[] args) {
        int[] array=new int[]{49,38,65,97,76,13,27,49,55,4};
        int gap=array.length/2;

        int i,j,temp;
        while(gap>=1){
            for(i=gap;i<array.length;i++){
                temp=array[i];
                j=i-gap;
                while(j>=0 && array[j]>temp){
                   array[j+gap]=array[j];
                   j=j-gap;
                }
                array[j+gap]=temp;
            }
            gap=gap/2;
        }
        for(int index=0;index<array.length;index++){
            System.out.println(array[index]);
        }
    }
}

4、冒泡排序

//平均时间复杂度是O(n^2)
public class BubbleSort {
    public static void main(String[] args) {
        int[] array=new int[]{49,38,65,97,76,13,27,49,55,4};
        int i,j,temp;
        for (i=0;i<array.length-1;i++){
            for(j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        for (int a:array) {
            System.out.println(a);
        }

    }
}

5、快速排序(优化了一部分的)

package sort;
//快速排序的缺点及其优化

/**
 * 三种选择基准的方法：
 *
 * 1、取序列的第一个或者最后一个元素作为基准
 *
 * 缺点：若数组有序，此时的分割效果非常差，每次划分只能使待排序序列减一，快速排序沦为冒泡排序，时间复杂度O（N2）数据量特别大时，会出现栈溢出的情况
 *
 * 2、随机选取基准：取待排序列中任意一个元素作为基准，将选择好的基准元素与low位置元素互换位置，此时就可以和普通的快排一样调用划分函数。
 *
 * 缺点：数字全相等的情况下，时间复杂度依然是O（n2）。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n）。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn）的期望时间复杂度。
 *
 * 3、三数取中
 *
 * 一般是取low、middle、high三个位置上元素的中值作为基准
 *
 * 缺点：同样处理不了重复数组
 * 4.当待排序序列长度分割到一定大小后，使用插入排序。
 * 原因：对于很小和部分有序的数组，快排不如插排好。当待排序序列的长度分割到一定大小后，继续分割的效率比插入排序要差，此时可以使用插排而不是快排
 *
 * 5.在一次分割结束后，可以把与Key相等的元素聚在一起，继续下次分割时，不用再对与key相等元素分割(还未优化)（处理重复效率极高）
 */
public class FastSortUp {
    //三数取中优化
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    private  static void printArr(int[] arr) {
        for (int anArr : arr) {
            System.out.print(anArr + " ");
        }
    }

    private static int partition(int[] arr, int left, int right) {
        // 采用三数中值分割法,找出一次排序后mid的值作为分割点。
        int mid = left + (right - left) / 2;
        // 保证左端较小
        if (arr[left] > arr[right])
            swap(arr, left, right);
        // 保证中间较小
        if (arr[mid] > arr[right])
            swap(arr, mid, right);
        // 保证中间最小，左右最大
        if (arr[mid] > arr[left])
            swap(arr, left, mid);
        int pivot = arr[left];
        while (right > left) {
            // 先判断基准数和后面的数依次比较
            while (pivot <= arr[right] && left < right) {
                --right;
            }
            // 当基准数大于了 arr[right]，则填坑
            if (left < right) {
                arr[left] = arr[right];
                ++left;
            }
            // 现在是 arr[right] 需要填坑了
            while (pivot >= arr[left] && left < right) {
                ++left;
            }
            if (left < right) {
                arr[right] = arr[left];
                --right;
            }
        }
        arr[left] = pivot;


        return left;
    }

    private static void quickSort(int[] arr, int left, int right) {
        if (arr == null || left >= right || arr.length <= 1)
            return;
        if(right-left+1<10){
            insertSort(arr,left,right);
        }
        int mid = partition(arr, left, right);
        quickSort(arr, left, mid);
        quickSort(arr, mid + 1, right);
    }

    public static void insertSort(int[] arr,int low,int height)
    {
        for(int i=low+1;i<=height;i++)
        {
            int tmp=arr[i];
            int j;
            for(j=i;j>low&&arr[j-1]>tmp;j--)
            {
                arr[j]=arr[j-1];
            }
            arr[j]=tmp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {1,5,4,8,3,6,7,2,12,9,34,27,54,43,18,20,-1,-5,13,17,-22,7,2,11,66,78,103};
        quickSort(arr, 0, arr.length - 1);
        printArr(arr);
    }

}

6、简单选择排序

public class SimpleChooseSort {
    public static void main(String[] args) {
        int[] array=new int[]{49,68,65,97,76,13,27,49};
        int i=0,j=0,index=0,temp;
        while(i<array.length){
            index=i;
            for(j=i+1;j<array.length;j++){
                if(array[index]>array[j]){
                    index=j;
                }
            }
            temp=array[i];
            array[i]=array[index];
            array[index]=temp;
            i++;
        }
        for(int a=0;a<array.length;a++){
            System.out.println(array[a]);
        }
    }

}

7、堆排序

package sort;
//时间复杂度为O(nlogn)
public class HeapSort {
    public static void main(String[] args) {
        int[] arr = {16, 7, 3, 20, 17, 8};
        heapSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

        /**
         * 创建堆，
         * @param arr 待排序列
         */
        private static void heapSort(int[] arr) {
            //创建堆
            for (int i = (arr.length - 1) / 2; i >= 0; i--) {
                //从第一个非叶子结点从下至上，从右至左调整结构
                adjustHeap(arr, i, arr.length);
            }

            //调整堆结构+交换堆顶元素与末尾元素
            for (int i = arr.length - 1; i > 0; i--) {
                //将堆顶元素与末尾元素进行交换
                int temp = arr[i];
                arr[i] = arr[0];
                arr[0] = temp;

                //重新对堆进行调整
                adjustHeap(arr, 0, i);
            }
        }

        /**
         * 调整堆
         * @param arr 待排序列
         * @param parent 父节点
         * @param length 待排序列尾元素索引
         */
        private static void adjustHeap(int[] arr, int parent, int length) {
            //将temp作为父节点
            int temp = arr[parent];
            //左孩子
            int lChild = 2 * parent + 1;

            while (lChild < length) {
                //右孩子
                int rChild = lChild + 1;
                // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
                if (rChild < length && arr[lChild] < arr[rChild]) {
                    lChild++;
                }

                // 如果父结点的值已经大于孩子结点的值，则直接结束
                if (temp >= arr[lChild]) {
                    break;
                }

                // 把孩子结点的值赋给父结点
                arr[parent] = arr[lChild];

                //选取孩子结点的左孩子结点,继续向下筛选
                parent = lChild;
                lChild = 2 * lChild + 1;
            }
            arr[parent] = temp;
        }

}

8、二路归并排序

package sort;

public class TogetherSort {

    /**
     * 归并排序
     * @param arr
     * @param left
     * @param right
     */
    public static void mergeSort(int[] arr, int left, int right) {
        if(null == arr) {
            return;
        }
        if(left < right) {
            //找中间位置进行划分
            int mid = (left+right)/2;
            //对左子序列进行递归归并排序
            mergeSort(arr, left, mid);
            //对右子序列进行递归归并排序
            mergeSort(arr, mid+1, right);
            //“合”。 进行归并
            merge(arr, left, mid, right);
        }
    }

    /**
     * 进行归并
     * @param arr
     * @param left
     * @param mid
     * @param right
     */
    private static void merge(int[] arr, int left, int mid, int right) {
        int[] tempArr = new int[arr.length];
        int leftStart = left;
        int rightStart = mid+1;
        int tempIndex = left;

        while(leftStart <= mid && rightStart <= right) {
            if(arr[leftStart] < arr[rightStart]) {
                tempArr[tempIndex++] = arr[leftStart++];
            } else {
                tempArr[tempIndex++] = arr[rightStart++];
            }
        }

        while(leftStart <= mid) {
            tempArr[tempIndex++] = arr[leftStart++];
        }

        while(rightStart <= right) {
            tempArr[tempIndex++] = arr[rightStart++];
        }

        while(left <= right) {
            arr[left] = tempArr[left++];
        }
    }

    private static void showArr(int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void main(String[] args) {
        int[] arr = {4, 2, 6, 1, 3, 8, 5, 9};
        /*
         * 归并排序
         * 对上下限值分别为0和arr.length-1的记录序列arr进行归并排序
         */
        mergeSort(arr, 0, arr.length-1);
        showArr(arr);
    }


}
H. Private
关注
数据结构和算法(十三)排序算法
yuan_xw的专栏
08-27 806
1. 数据结构和算法(十三)冒泡排序算法 1.1 什么是冒泡排序 冒泡排序是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。 1.2 算法基本思想   比较相邻的两个数，如果第一个数比第二个数大，则两数交换。对之后的相邻元素进行同样的工作，从开始到最后一对，这样进行一次排序后，数据的最后一位会是最大值 ，第一次循环进行的次数为 array.length-1。之后对所有的元素重复以上的步骤，且以后每次循环的次数为array.length-1-i （i为循环
排序算法——希尔排序的图解、代码实现以及时间复杂度分析
zhoucheng05_13的博客
01-22 9126
希尔排序(Shellsort) 希尔排序是冲破二次时间屏障的第一批算法之一。 希尔排序通过比较相距一定间隔的元素来工作；各躺比较所用的距离随着算法的进行而减小，直到只比较相邻元素的最后一趟排序为止。由于这个原因，希尔排序有时也叫做缩减增量排序。 希尔排序使用一个序列h1,h2,…,hi,这个序列叫做增量序列(increment sequence)。增量序列只要求h1=1，以及hi>hi-1。
【数据结构】排序算法-时间复杂度
weixin_37838913的博客
03-29 1165
【数据结构】排序算法算法的时间复杂度T(n)T(n)怎么计算忽略常数项忽略低次项n^2^可以忽略系数O(n):渐进时间复杂度常见的时间复杂度常数阶O(1)对数阶O(log⁡2n\log_2 nlog2​n) 算法的时间复杂度T(n) T(n)怎么计算 比如：计算1-100的所有数字之和，我们设计了两种算法： 1.使用for循环计算 int total=0; int end=100; //使用for...
几种常见排序的代码和时间比较
weixin_33774615的博客
04-02 117
void my_sort(int n) //冒泡 耗时15499ms { for(int i = 0;i < n;i ++) for(int j = 0;j < n - i - 1;j ++) if(s[j] > s[j + 1]) swap(s[j],s[j + 1]); }...
【数据结构与算法】排序算法的介绍、各排序算法的时间复杂度
Bulut0907
09-26 327
定义：排序是将一组数据，依指定的顺序进行排列的过程内部排序：将需要处理的所有数据都加载到内部存储器中进行排序插入排序(直接插入排序、希尔排序)选择排序(简单选择排序、堆排序)交换排序(冒泡排序、快速排序)归并排序基数排序外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
数据结构课程设计多种排序算法时间比较.c
12-11
快速排序，基数排序，插入排序，希尔排序，堆排序，归并排序等算法对数排序的时间进行比较。可以对5000000以内（超大数据量）的随机数（可能存在超大数值）进行排序！！！
算法设计与优化中的时间复杂度分析
最新发布
10-20
首先解释了什么是时间复杂度以及其常用的表示方法——大 O 符号，并列举了几种常见的时间复杂度，如 O(1)、O(log n)、O(n)、O(n log n) 和 O(n^2) 等。接着，文章提供了排序算法、搜索算法、图算法和字符串算法等...
七种内部排序 实现及时间复杂度分析
qq_44759710的博客
02-18 2138
排序分类 排序分为内部排序和外部排序两种 内部排序 内部排序通常为常见的七种算法，本实验要求掌握选择排序、冒泡排序、合并排序、快速排序、插入排序、堆排序、希尔排序 算法一：插入排序 插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入 算法步骤： 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当...
【数据结构入门】算法的时间复杂度和空间复杂度详解
codewinter的博客
07-27 3929
【数据结构学习之路】算法的时间复杂度和空间复杂度 文章目录【数据结构学习之路】算法的时间复杂度和空间复杂度（1）算法效率（2）时间复杂度的计算1）什么是时间复杂度2）大O渐进表示法（估算）3）时间复杂度计算实例4）总结5）一些思考（3）空间复杂度的计算（4）常见复杂度对比 本篇前言 在C语言阶段，我们学过了一些排序和查找算法，冒泡排序，快速排序，二分查找等等，哪种算法更好呢，我们如何衡量一个算法的好坏呢？本篇来学习算法的时间复杂度和空间复杂度，相信学完后你就会明白了。 （1）算法效率 算法在编写成可执行
几种内排序的方法 数据结构报告c++代码
06-17
在这个数据结构报告中，我们将深入探讨七种不同的内排序算法：简单选择排序、冒泡排序、插入排序、快速排序、两路合并排序以及堆排序。这些排序算法在C++语言环境下进行了实现，并且包含了详细的源代码和实验报告，...
数据结构各种排序算法
11-08
编写程序，实现所有内部排序算法，并比较这些算法在不同数据量下的运行时间。 （1）排序算法包括：插入排序、希尔排序、堆排序、归并排序、快速排序、基数排序。 （2）对整数进行排序。 （3）程序功能：可从键盘输入初始数据个数（数据自动生成）、初始数据类别（随机、正序、逆序），并得出排序所用时间（精确到毫秒） 注1：若某算法排序时间超过300秒，可显示为N/A，且不用记录在Excel表中 注2：rand()函数生成的随机数范围在0~32767之间，为扩大该范围，可使用下面代码： randnum = (rand() << 16) + rand(); // 随机数范围扩大至0~231之间 （4）生成图表：对1000、8000、30000、80000、150000、300000、500000、1000000、2000000、5000000个数据排序后得出排序时间，并制作类似的折线图如下。
常见的排序算法的时间复杂度
热门推荐
码字不易，大家的支持就是我坚持下去的动力
03-12 1万+
接着，对每个桶中的元素进行排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序），最后依次将各个桶中的元素取出，得到的就是有序序列。计数排序不是基于比较的排序算法，其优势在于在对一定范围内的整数排序时，复杂度为O(n+k)，其中n为输入元素个数，k为待排序列中最大的数。例如，如果数据的范围非常大，或者数据的分布极不均匀，那么可能需要大量的桶，这可能导致空间复杂度的增加。基数排序的时间复杂度是线性的，为O(dn)，其中d为数字的位数，n为待排序序列的长度。因此，时间复杂度为O(n^2)。
数据结构和常用排序算法复杂度
拉依达不拉跨的博客
11-24 8947
数据结构和常用排序算法复杂度
数据结构之时间复杂度
qq_40334837的博客
07-15 642
前言：为什么会出现时间复杂度这个概？ 我们在编写代码的时候为了完成一个函数功能，可能用到不同的处理方式：顺序多次执行、使用for循环执行、使用递归调用等等。当循环次数取值范围不同时，各种算法处理所耗费的时间也不一样，不同的算法所执行的次数通过分析可以用数学函数表达。 时间复杂度概念：我们把 算法需要执行的运算次数 用 输入大小n 的函数 表示，即 T(n) 。此...
【数据结构】算法的时间复杂度和空间复杂度（含代码分析）
kevin_cai的博客
04-26 1627
学习了数据结构以后，遇到问题的时候，我们不应该直接暴力求解，而是通过思考不同的解决方案，估算其时间复杂度和空间复杂度，选择最优解以提升算法效率。先思考，再求解。小伙伴们都学废了吗？
八大排序时间复杂度与稳定性
m0_75062065的博客
10-06 8984
因为每一趟排好一个数据后，会把这个数组一分为二，而被分成的这两个数组总元素少1（可忽略，因为到最后这个总元素不会相差原始元素个数太多，若差10则说明有1024个数据）。用二分法，类比二叉树。n个数据，总共分成了 log n 层，每次都要对上一层的数据全部处理完，才能形成了新的下一层的新数据，再来进行下次的处理。每一趟的这一个待插入数据，都要向前挨个找，找到满足的为止，最多走 n-i-1 次，最少直接插入。每一趟能排好一个数据，一共n个数据，如果前n-1个都排好了，那么最后一个就不用排了。
算法与数据结构 | 时间复杂度分析 / 更准确的描述代码的时间复杂度
Wion Wan
01-16 386
文章目录数据结构与算法概述复杂度分析大O复杂度表示法时间复杂度分析几种常见时间复杂度实例分析空间复杂度分析复杂度坐标图复杂度分析的四个知识点 数据结构与算法概述 什么是数据结构？什么是算法？ 从广义上讲，数据结构就是指一组数据的存储结构。算法就是操作数据的一组方法。 从狭义上讲，是指某些著名的数据结构和算法，比如队列、栈、堆、二分查找、动态规划等。 算法和数据结构直接的关系 数据结构是为...
数据结构与算法之简单选择排序及改进(可视化)
梦的灰色边沿...
03-27 510
简单选择排序简单选择排序描述​ 从序列L[i + 1]…L[n]之间找到其中最小值，然后交换L[i]和L[min]的数据，直到遍历整个序列结束为止。示意图/** * 简单选择排序算法（L为线性表） */typedef int type; void print_array(type *L, int len, char *msg); /** * 用于交换元素 */ void swap(t
数据结构代码03-选择排序（简单选择排序、堆排序）
weixin_43481880的博客
09-01 220
一.简单选择排序 简单选择排序不稳定。 时间复杂度始终为O(n*n)，空间复杂度为O(1)。 每次找一个最大或最小元素，所以每轮下来能找到一个元素的确定位置。 #include<stdio.h> //简单选择排序 void SelectSort(int arry[],int lenght){ int min;//记录更换的最小索引的值 for(int index=0;index<lenght-1;index++){//从0到i-1索引 min=index; for(int
数据结构习题解析：排序与算法时间复杂度分析
"数据结构习题讲解，包含排序算法、素数判断、求和算法以及矩阵乘法的时间复杂度分析" 在数据结构的学习中，掌握各种算法的时间复杂度至关重要，因为它直接影响程序的效率。以下是对题目中涉及的几个知识点的详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值