排序算法汇总-代码

最新推荐文章于 2024-10-13 16:52:53 发布
最新推荐文章于 2024-10-13 16:52:53 发布
阅读量88 收藏
点赞数
文章标签： 算法 排序算法 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47029949/article/details/120272797
版权

1、冒泡排序

 //冒泡排序 O（n²）
    class BubbleSort
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;

            //外层循环控制冒泡次数
            for (int i = 0; i < n; i++)
            {
                //减去i 不需要对已经排好序的元素再次进行比较
                //内层循环在数组[0...n-1-i]范围内冒泡最大值
                //j取值范围[0...n-1-i)  j+1取值范围[1...n-1-i]
                for (int j = 0; j < n - 1 - i; j++)
                {
                    if (arr[j] > arr[j + 1])
                        Swap(arr, j, j + 1);
                }
            }
        }

        //交换数组中索引i和j对应元素的位置
        private static void Swap(int[] arr,int i,int j)
        {
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }

2、冒泡排序-泛型

class BubbleSortGeneric
    {
        public static void Sort<E>(E[] arr) where E:IComparable<E>
        {
            int n = arr.Length;

            //外层循环控制冒泡次数
            for (int i = 0; i < n; i++)
            {
                //减去i 不需要对已经排好序的元素再次进行比较
                for (int j = 0; j < n - 1 - i; j++)
                {
                    if (arr[j].CompareTo(arr[j + 1])>0)
                        Swap(arr, j, j + 1);
                }
            }
        }

        private static void Swap<E>(E[] arr, int i, int j)
        {
            E t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }

3、选择排序

 class SelectSort
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;

            //外层循环控制每一轮循环中要交换的位置i
            //第一轮循环 i=0 执行循环体内逻辑 找到最小值然后和arr[i]交换 将第一个元素排好序
            //第二轮循环 i=1 执行循环体内逻辑 找到最小值然后和arr[i]交换 将第二个元素排好序
            //....
            //第n轮循环 i=n-1 执行循环体内逻辑 找到最小值然后和arr[i]交换 将最后一个元素排好序
            //跳出外层循环 完成整个数组的选择排序
            for (int i = 0; i < n; i++)
            {
                //最小元素的索引min 从未排序的第一个位置i开始寻找
                int min = i; 

                //内层循环在[i+1...n)寻找最小值对应的索引min
                for (int j = i+1; j < n; j++)
                {
                    if (arr[j] < arr[min])
                        min = j;
                }

                //内层循环结束，找到最小值arr[min]，和未排序的边界元素arr[i]交换位置
                Swap(arr, i, min);
            }
        }

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

4、插入排序

 class InsertSort
    {
        public int [] InSort(int [] arr)
        {
            int n = arr.Length;
            for (int i = 1; i < n; i++)
            {
                int e = arr[i];
                int j;//位置
                for ( j = i; j >0; j--)
                {
                    if (e < arr[j - 1])
                    {
                        arr[j] = arr[j - 1];
                    }
                    else
                        break;
                }
                arr[j] = e;

            }
            return arr;
        }
         //对arr[l...r]的范围使用插入排序
        public static void Sort1(int[] arr,int l,int r)
        {
            for (int i = l+1; i <= r; i++)
            {
                int e = arr[i];
                int j;
                for (j = i; j > l; j--)
                {
                    if (e < arr[j - 1])
                        arr[j] = arr[j - 1];
                    else
                        break;
                }
                arr[j] = e;
            }
        }
    }

5、归并排序

//时间复杂度O(nlogn)
    //空间复杂度O（n）需要借助一个同样长度的辅助数组进行排序
    class MergeSort1
    {
        //用户调用的排序方法传进数组即可排序
        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            int[] temp = new int[n];
            Sort(arr, temp, 0, n - 1);
        }

        //递归使用归并排序，对arr[l...r]的范围进行排序
        private static void Sort(int[] arr,int[] temp,int l,int r)
        {
            
            if (l >= r) return;//可以在这里进行优化，看下面的Sort2

            //int mid = (r + l) / 2;
            int mid = l + (r - l) / 2;
            //Console.WriteLine("mid = {0}", mid);

            Sort(arr, temp, l, mid);        //将左半边排序
            Sort(arr, temp, mid + 1, r);    //将右半边排序
            Merge(arr, temp, l, mid, r);    //归并结果
        }

        // 将arr[l...mid]和arr[mid+1...r]两部分有序排列进行归并
        private static void Merge(int[] arr,int[] temp,int l,int mid ,int r)
        {
            //Console.WriteLine("Merge（{0},{1},{2}）", l, mid, r);

            int i = l;
            int j = mid + 1;
            int k = l;

            //左右半边都有元素(将小的放到temp数组中)
            while(i<=mid && j <= r)
            {
                if(arr[i] < arr[j])
                    temp[k++] = arr[i++];
                else //arr[i] >= arr[j]
                    temp[k++] = arr[j++];
            }

            //左半边还有元素，右半边用尽（取左半边的元素）
            while (i <= mid)
                temp[k++] = arr[i++];

            //右半边还有元素，左半边用尽（取右半边的元素）
            while (j <= r)
                temp[k++] = arr[j++];

            //将temp数组拷贝回给arr数组，完成arr排序
            for (int z = l; z <= r; z++)
                arr[z] = temp[z];
        }
    }

6、归并排序（优化），在递归终止条件处处理，数组长度小时使用插入排序即可

//时间复杂度O(nlogn)
    //空间复杂度O（n）需要借助一个同样长度的辅助数组进行排序
    class MergeSort2
    {
        //用户调用的排序方法传进数组即可排序
        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            int[] temp = new int[n];
            Sort(arr, temp, 0, n - 1);
        }

        //递归使用归并排序，对arr[l...r]的范围进行排序
        private static void Sort(int[] arr, int[] temp, int l, int r)
        {

            if (r - l + 1 <= 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            int mid = l + (r - l) / 2;
            Sort(arr, temp, l, mid);        //将左半边排序
            Sort(arr, temp, mid + 1, r);    //将右半边排序

            if (arr[mid] > arr[mid + 1])
                Merge(arr, temp, l, mid, r);    //归并结果
        }

        // 将arr[l...mid]和arr[mid+1...r]两部分有序排列进行归并
        private static void Merge(int[] arr, int[] temp, int l, int mid, int r)
        {
            int i = l;
            int j = mid + 1;
            int k = l;

            //左右半边都有元素(将小的放到temp数组中)
            while (i <= mid && j <= r)
            {
                if (arr[i] < arr[j])
                    temp[k++] = arr[i++];
                else //arr[i] >= arr[j]
                    temp[k++] = arr[j++];
            }

            //左半边还有元素，右半边用尽（取左半边的元素）
            while (i <= mid)
                temp[k++] = arr[i++];

            //右半边还有元素，左半边用尽（取右半边的元素）
            while (j <= r)
                temp[k++] = arr[j++];

            //将temp数组拷贝回给arr数组，完成arr排序
            for (int z = l; z <= r; z++)
                arr[z] = temp[z];
        }
    }

7、快速排序

 //快速排序 O（nlogn）
    class QuickSort1
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            Sort(arr, 0, n - 1);
        }

        private static void Sort(int[] arr,int l,int r)
        {
            if (r - l + 1 <= 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            int v = arr[l];

            int j = l; // arr[l+1...j] < v  arr[j+1...i-1] > v

            for (int i = l+1; i <= r; i++)
            {
                if(arr[i] < v)
                {
                    j++;
                    Swap(arr, i, j);
                }
            }

            Swap(arr, l, j);
            Sort(arr, l, j - 1);
            Sort(arr, j + 1, r);
        }

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

8、快速排序（优化），在递归终止条件处处理，数组长度小时使用插入排序即可

 class QuickSort2
    {
        private static Random rd = new Random();

        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            Sort(arr, 0, n - 1);
        }

        private static void Sort(int[] arr, int l, int r)
        {
            if (r - l + 1 <= 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            int p =l + rd.Next(r - l + 1);

            Swap(arr, l, p);

            int v = arr[l];

            int j = l; // arr[l+1...j] < v  arr[j+1...i-1] > v

            for (int i = l + 1; i <= r; i++)
            {
                if (arr[i] < v)
                {
                    j++;
                    Swap(arr, i, j);
                }
            }

            Swap(arr, l, j);
            Sort(arr, l, j - 1);
            Sort(arr, j + 1, r);
        }

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

9、快速排序（优化）， 对标定元素随机化处理，对排序有序性很强的数组会得到很大的优化

class QuickSort3
    {
        private static Random rd = new Random();

        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            Sort(arr, 0, n - 1);
        }

        private static void Sort(int[] arr,int l ,int r)
        {
            //对小规模的数组使用插入排序，避免频繁的递归调用
            if (r - l + 1 <= 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            //随机化处理，对排序有序性很强的数组会得到很大的优化
            int p = l + rd.Next(r - l + 1);

            Swap(arr, l, p);

            int v = arr[l];    //标定元素v

            int lt = l;        // arr[l+1...lt] < v
            int gt = r + 1;    // arr[gt...r] > v
            int i = l + 1;     // arr[lt+1...i-1] == v

            //往三个区间填充元素
            while(i < gt)
            {
                if(arr[i] < v)
                {
                    lt++;
                    Swap(arr, i, lt);
                    i++;
                }
                else if(arr[i] > v)
                {
                    gt--;
                    Swap(arr, i, gt);
                }
                else //arr[i]==v
                {
                    i++;
                }
            }

            //跳出while循环填充完毕后，把标定元素放到合适位置
            Swap(arr, l, lt);

            Sort(arr, l, lt - 1);  //将左半部分arr[l...lt-1]排序
            Sort(arr, gt, r);      //将右半部分arr[gt...r]排序

        }

        private static void Swap(int[] arr,int i,int j)
        {
            int e = arr[i];
            arr[i] = arr[j];
            arr[j] = e;
        }
    }
xyz_sky
关注
排序算法汇总---Java实现各个排序
、思考致富的博客
03-01 853
排序算法汇总 下图来自菜鸟教程： 下面所有方法都有static关键字，因为测试的时候需要被main函数调用，故添加static。 若需要c++版本的算法实现，可参考下面博文连接 排序算法汇总—C++实现各个排序 1、冒泡排序 // 冒泡排序 static void bubble_sort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { // n-1趟 for (int j = 0
插入排序算法汇总---附JAVA语言实现
m0_46672151的博客
07-09 103
插入排序算法汇总一、直接插入排序二、折半插入排序三、希尔排序 在介绍算法之前，我先给大家介绍一个很好用的网站，里面的可视化过程可以帮助你更好的理解数据结构和算法 VISUALGO.NET: https://visualgo.net/zh. 可视化过程： 以下内容以算法的思想、特征、实现三方面进行讲解 一、直接插入排序 基本思想：每次将一个待排序的记录按其关键字大小插入到前面已排好的子序列。类似于打牌的时候，手中扑克牌的排序。 特征： 适用于顺序存储表和链式存储表； 应用于基本有序和数据量小的排序表；
数据结构-排序算法汇总 -C语言
weixin_53284122的博客
03-08 431
排序算法的原理在此就不再叙述，后面代码里面注释也有原理的体现1.插入排序。
C语言常见的四大排序算法--插入排序、选择排序、交换排序、归并排序的实现讲解与性能对比
m0_74949249的博客
05-03 993
本文详细介绍了四大排序算法（插入排序，选择排序，交换排序，归并排序）以及它们的优化算法（希尔排序，堆排序，快速排序），并进行了它们之间的性能比较。如有错误，请批评指正，希望大家多多支持。
【排序算法】 - 常见排序算法及稳定性
行仔ovo的博客
12-20 221
文章目录1. 代码2. 稳定性 1. 代码 /* * @Brief: 常见排序算法汇总 * @Author: * @Date: 2021-07-01 */ #include <iostream> #include <algorithm> #include <vector> #include <queue> using namespace std; void printArray(int *a, int len){ for(int i =
十大排序算法
热门推荐
个人站点：javatv.net
08-20 2万+
冒泡排序 从数组头开始，比较相邻的元素。如果第一个比第二个大(小)，就交换它们两个 对每一对相邻元素作同样的工作，从开始第一对到尾部的最后一对，这样在最后的元素应该会是最大(小)的数 重复步骤1~2，重复次数等于数组的长度，直到排序完成 代码实现 对下面数组实现排序：{24, 7, 43, 78, 62, 98, 82, 18, 54, 37, 73, 9} 代码实现 public class BubbleSort { public static final int[] ARRAY = {2
常见的排序算法汇总（详解篇）
m0_73634434的博客
08-19 1866
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。稳定性 ：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中， r[i]=r[j] ，且 r[i] 在 r[j] 之前，而在排序后的序列中， r[i] 仍在 r[j] 之前，则称这种排序算法是稳定的；否则称为不稳定的。数据元素全部放在内存中的排序。数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
【最全】经典排序算法--C语言
qing_tong_tong的博客
01-23 1049
在冒泡排序的每趟扫描中，记住最后一次交换发生的位置lastexchange也能有所帮助。因为该位置之前的相邻记录已经有序，故下一趟排序开始的时候，0到lastexchange已经是有序的了，lastexchange到n-1是无序区。所以一趟排序可能使当前有序区扩充多个记录.即较大缩小无序区范围，而非递减1，以此减少排序趟数。// 改进二，记录最后一次交换的位置int j;int tmp;int pos;pos = 0;// 不要漏了该条赋值语句。否则会陷入无限循环。for(j=0;
常见排序算法汇总
夜槿笙歌的博客
04-17 8503
整理一下之前学习的各种排序算法
C/C++最全排序算法汇总，原理+代码
m0_68557563的博客
09-17 1054
排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序。若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程叫做排序。假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
基于Qt5-实现九大排序算法的代码汇总
02-16
在本文中，我们将深入探讨如何使用Qt5框架和C++编程语言实现九大经典的排序算法。Qt5是一个跨平台的应用程序开发框架，它提供了丰富的库和工具，使得开发人员能够便捷地构建用户界面和应用程序逻辑。C++则是一种强大...
基于C++实现的各种内部排序算法汇总
12-31
提起排序算法相信大家都不陌生，或许很多人已经把它们记得滚瓜烂熟，甚至随时可以写出来。是的，这些都是最基本的算法。这里就把各种内部排序算法总结归纳了一下，包括插入排序（直接插入排序，折半插入排序，希尔...
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 997
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
在顺序结构和链式结构的线性表上实现顺序检索算法
最新发布
m0_56332819的博客
10-13 100
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1345
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
力扣10.13
qq_40052678的博客
10-13 306
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
生成哈夫曼树
TTz012的博客
10-08 304
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
ICPC-day2(圆方树)
m0_74315028的博客
10-08 332
每次询问两点x, y，求是否存在一个n的排列，使得第一个元素为x，最后一个元素为y，且排列的任意一个前缀、任意一个后缀都连通。可以用圆方树缩点将其变成一颗树，再判断这颗树是否是一条链，x,y是否在这条链的两侧。其实就是求这两个点是否存在两个不相同的路径，同时两者路径的交集是n。
Java排序算法详解与实现
【资源摘要信息】: "Java排序算法汇总，包括插入排序、交换排序、选择排序、归并排序和基数排序。适用于不同规模和顺序的数组，选择合适的排序算法能提高效率。" 在计算机科学中，排序算法是用于对一组数据进行排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xyz_sky

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

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

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

打赏作者

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

抵扣说明：

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

余额充值