再撸排序算法

最新推荐文章于 2024-09-12 19:02:20 发布
最新推荐文章于 2024-09-12 19:02:20 发布
阅读量152 收藏
点赞数
分类专栏： 算法-排序 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pw8992134/article/details/119674075
版权

很久没有玩算法了，都快忘记了，手写复习下，同时发现了git上很多错误，进行了改进。

namespace Test
{
    /// <summary>
    /// 排序算法类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public static class SortedUtil<T> where T:IComparable<T>
    {
        /// <summary>
        /// 选择排序
        /// 思想是从索引为i=0开始，依次选择数组中([i~length-1])最小的元素与第i个元素交换位置
        /// </summary>
        /// <param name="origionArray"></param>
        /// <returns></returns>
        public static T[] SelectionSort(T[] origionArray)
        {
            for (int i = 0; i <= origionArray.Length-2; i++)
            {
                int swapIndex = i;
                int j=i+1;
                while (j <= origionArray.Length-1)
                {
                    if(origionArray[j].CompareTo(origionArray[swapIndex]) < 0)
                    {
                        swapIndex = j;
                    }

                    j++;
                }

                T data=origionArray[i];
                origionArray[i] = origionArray[swapIndex];
                origionArray[swapIndex] = data;
            }

            return origionArray;
        }

        /// <summary>
        /// 插入排序
        /// 思想是有两手牌，一手牌是排序好的（初始只有一张牌），一手是无序的，每次从无序的牌中抽出一张放入排序好的牌中，保证顺序。重复此步骤直到所有牌排序完成
        /// </summary>
        /// <param name="origionArray"></param>
        /// <returns></returns>
        public static T[] InsertionSort(T[] origionArray)
        {
            for (int i = 1; i < origionArray.Length; i++)
            {
                int j = i - 1;
                T data = origionArray[i];

                while (j >= 0 &&  origionArray[j].CompareTo(data) > 0)
                {
                    origionArray[j+1] =origionArray[j];
                    j--;
                }

                origionArray[j + 1] = data;
            }

            return origionArray;
        }

        /// <summary>
        /// 归并排序
        /// 思想是把排序看作一个递归的过程，把两个排序好的子序列合成一个排序好的子序列。
        /// </summary>
        /// <param name="origionArray"></param>
        /// <param name="p"></param>
        /// <param name="r"></param>
        public static void MergeSort(T[] origionArray,int p,int r)
        {
            if (p < r)
            {
                int q = (r + p) / 2;
                MergeSort(origionArray,p,q);
                MergeSort(origionArray,q+1,r);
                Merge(origionArray,p,q,r);
            }
        }

        /// <summary>
        /// 归并排序的归并过程（把两个排序好的子序列合成一个排序好的子序列。）
        /// </summary>
        /// <param name="origionArray"></param>
        /// <param name="p"></param>
        /// <param name="q"></param>
        /// <param name="r"></param>
        public static void Merge(T[] origionArray,int p,int q,int r)
        {
            T[] copyOne = new T[q - p + 1];
            T[] copyTwo=new T[r - q];

            for (int s = 0; s < q - p + 1; s++)
            {
                copyOne[s] = origionArray[p + s];
            }

            for (int s = 0; s < r-q; s++)
            {
                copyTwo[s] = origionArray[q + s + 1];
            }

            int a=0, b = 0;
            int i = p;
            for (; i <= r; i++)
            {
                if (a >= copyOne.Length || b >= copyTwo.Length)
                    break;

                if (copyOne[a].CompareTo(copyTwo[b]) < 0)
                {
                    origionArray[i] = copyOne[a++];
                }
                else
                {
                    origionArray[i] = copyTwo[b++];
                }
            }

            if (i <= r)
            {
                if (a >= copyOne.Length)
                {
                    for (; i <= r; i++)
                    {
                        origionArray[i] = copyTwo[b++];
                    }
                }
                else if (b >= copyTwo.Length)
                {
                    for (; i <= r; i++)
                    {
                        origionArray[i] = copyOne[a++];
                    }
                }
            }
        }

        /// <summary>
        /// 快速排序
        /// 思想是在数组中选取一个元素进行拆分，左边的元素都比这个元素小，右边的元素都比这个元素大。重复这个过程直到元素有序
        /// </summary>
        /// <param name="origionArray"></param>
        /// <param name="p"></param>
        /// <param name="r"></param>
        public static void QuickSort(T[] origionArray,int p,int r)
        {
            if (p < r)
            {
                int q = Partion(origionArray,p,r);
                QuickSort(origionArray,p,q-1);
                QuickSort(origionArray,q+1,r);
            }
        }

        /// <summary>
        /// 快排拆分过程
        /// </summary>
        /// <param name="origionArray"></param>
        /// <param name="p"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        public static int Partion(T[] origionArray,int p,int r)
        {
            var key = origionArray[r];

            int i = p - 1;

            for (int j = p; j < r; j++)
            {
                if(origionArray[j].CompareTo(key)<0)
                {
                    T data = origionArray[++i];
                    origionArray[i] = origionArray[j];
                    origionArray[j] = data;
                }
            }

            T current = origionArray[i + 1];
            origionArray[i + 1] = origionArray[r];
            origionArray[r] = current;
            return i + 1;
        }

        /// <summary>
        /// 冒泡排序
        /// 思想是每次都把最大的一块石头沉底（或者把最轻的浮起来）
        /// </summary>
        /// <param name="origionArray"></param>
        public static void BubbleSort(T[] origionArray)
        {
            for (int i = 0; i < origionArray.Length-1; i++)
            {
                for (int j = 1; j < origionArray.Length-i; j++)
                {
                    if (origionArray[j].CompareTo(origionArray[j - 1]) < 0)
                    {
                        T data = origionArray[j];
                        origionArray[j] = origionArray[j - 1];
                        origionArray[j - 1] = data;
                    }
                }
            }
        }

        /// <summary>
        /// 堆排序
        /// 利用最大堆或者最小堆的堆顶元素是最大或最小，依次取出堆顶元素，维护堆性质并且缩容，达到排序目的
        /// </summary>
        /// <param name="origionArray"></param>
        /// <returns></returns>
        public static T[] HeapSort(T[] origionArray)
        {
            return new Heap(origionArray).HeapSort();
        }

        /// <summary>
        /// 计数排序
        /// 思想是统计每个元素的个数逐次累加就可以得出这个元素在数组中的位置
        /// 这里为了支持泛型的元素，使用了底层是二叉搜索树的SortedDictionary结构，一般使用List数组即可
        /// </summary>
        /// <param name="origionArray"></param>
        /// <returns></returns>
        public static T[] CountingSort(T[] origionArray)
        {
            SortedDictionary<T,int> keyValuePairs= new SortedDictionary<T, int>();

            foreach (var item in origionArray)
            {
                if (keyValuePairs.ContainsKey(item))
                    keyValuePairs[item]++;
                else
                    keyValuePairs.Add(item,1);
            }

            for (int i = 0; i < keyValuePairs.Count-1; i++)
            {
                T key =keyValuePairs.Keys.ToList()[i];

                T keyNext = keyValuePairs.Keys.ToList()[i + 1];

                keyValuePairs[keyNext] += keyValuePairs[key];
            }

            T[] sortedArray = new T[origionArray.Length];

            foreach (var item in origionArray)
            {
                sortedArray[--keyValuePairs[item]] = item;
            }

            return sortedArray;
        }

        /// <summary>
        /// 基数排序
        /// 本质是一种桶排序，先分配，后收集。它的分桶是通过位来实现的。从低位到高位（从高到低也可，只是需要分子桶），每一位分配后收集，重复直到最高位，最后达到有序
        /// </summary>
        /// <param name="origionArray"></param>
        public static void RadixSort(int[] origionArray)
        {
            List<int>[] buket = new List<int>[10];
            for (int i = 0; i < 10; i++)
            {
                buket[i] = new List<int>();
            }

            int maxPosition = MaxPosition(origionArray);

            for (int i = 0; i < maxPosition; i++)
            {
                for (int j = 0; j < origionArray.Length; j++)
                {
                    int current = origionArray[j];

                    int currentPosition = current.ToString().Length < i + 1 ? 0 : int.Parse(current.ToString()[current.ToString().Length - i - 1].ToString());

                    buket[currentPosition].Add(current);
                }

                int index = 0;
                for (int k = 0; k < 10; k++)
                {
                    foreach (var item in buket[k])
                    {
                        origionArray[index++] = item;
                    }

                    buket[k]=new List<int>();
                }
            }
        }

        /// <summary>
        /// 桶排序（按照一定规则分桶，然后对每个桶进行插入排序，再收集就是排序好的序列）
        /// 其实分桶的大小无所谓，最好均匀分布，比如你可以把20-70的数分到一个桶子里
        /// </summary>
        /// <param name="origionArray"></param>
        public static void BuketSort(int[] origionArray)
        {
            int buketCount = SplitBuket(origionArray,10);

            List<int>[] buket = new List<int>[buketCount];

            for (int i = 0; i < buket.Length; i++)
            {
                buket[i] = new List<int>();
            }

            for (int i = 0; i < origionArray.Length; i++)
            {
                int current = origionArray[i];

                int buketIndex = (current - origionArray.Min()) / 10;

                buket[buketIndex].Add(current);
            }

            for (int i = 0; i < buket.Length; i++)
            {
                int[] currentBuket = buket[i].ToArray();

                buket[i]= SortedUtil<int>.InsertionSort(currentBuket).ToList();
            }

            int index = 0;
            for (int i = 0; i < buket.Length; i++)
            {
                for (int j = 0; j < buket[i].Count; j++)
                {
                    origionArray[index++] = buket[i][j];
                }
            }
        }

        /// <summary>
        /// 希尔排序（间隔插入排序，先使用较大的间隔插入排序使得元素基本有序，再逐渐缩小间隔，最后整体再进行一次插入排序，使得元素有序）
        /// </summary>
        /// <param name="origionArray"></param>
        public static void ShellSort(T[] origionArray)
        {
            int distance = 1,j;

            while (distance<origionArray.Length/3)
            {
                distance = distance * 3 + 1;
            }

            for (; distance >0; distance/=3)
            {
                for (int i = distance; i<origionArray.Length; i++)
                {
                    T temp = origionArray[i];
                    for (j =i- distance; j >=0 && origionArray[j].CompareTo(temp)>0; j-=distance)
                    {
                        origionArray[j + distance] = origionArray[j];
                    }

                    origionArray[j + distance] = temp;
                }
            }
        }

        #region Helpers

        public static string ToString(T[] array)
        {
            string s = string.Empty;

            for (int i = 0; i < array.Length; i++)
            {
                s += $"-> {array[i]}";
            }

            return s;
        }

        /// <summary>
        /// 分桶
        /// </summary>
        /// <param name="origionArray"></param>
        /// <param name="distance"></param>
        /// <returns></returns>
        public static int SplitBuket(int[] origionArray,int distance=10)
        {
            int min = origionArray.Min();
            int max = origionArray.Max();

            int buketCount = (max - min) / distance;

            if (buketCount * distance < max) buketCount += 1;

            return buketCount;
        }

        /// <summary>
        /// 最大位
        /// </summary>
        /// <param name="origionArray"></param>
        /// <returns></returns>
        public static int MaxPosition(int[] origionArray)
        {
            return origionArray.ToList().Max(t=>t.ToString().Length);
        }

        /// <summary>
        /// 最小堆
        /// </summary>
        public class Heap
        {
            private T[] _data;

            public int HeapSize { get; private set; }

            public Heap(T[] origionArray)
            {
                _data = origionArray;

                BuildHeap();
            }

            /// <summary>
            /// 堆排序
            /// </summary>
            /// <returns></returns>
            public T[] HeapSort()
            {
                int index = HeapSize - 1;
                for (int i = index; i > 0; i--)
                {
                    T data = _data[0];
                    _data[0] = _data[i];
                    _data[i] = data;
                    HeapSize--;

                    MaintainHeap(0);
                }

                return _data;
            }

            /// <summary>
            /// 建立堆
            /// </summary>
            private void BuildHeap()
            {
                HeapSize = _data.Length;

                int index = _data.Length / 2;

                for (int i = index - 1; i >= 0; i--)
                {
                    MaintainHeap(i);
                }
            }

            /// <summary>
            /// 维护堆的性质
            /// </summary>
            /// <param name="index"></param>
            private void MaintainHeap(int index)
            {
                int maxIndex = index;
                if (Left(index) < HeapSize && _data[maxIndex].CompareTo(_data[Left(index)]) < 0)
                {
                    maxIndex = Left(index);
                }

                if (Right(index) < HeapSize && _data[maxIndex].CompareTo(_data[Right(index)]) < 0)
                {
                    maxIndex = Right(index);
                }

                if (index != maxIndex)
                {
                    T data = _data[index];
                    _data[index] = _data[maxIndex];
                    _data[maxIndex] = data;
                    MaintainHeap(maxIndex);
                }
            }

            private int Left(int index)
            {
                return index * 2 + 1;
            }

            private int Right(int index)
            {
                return index * 2 + 2;
            }
        }

        #endregion
    }
}

测试：

int[] array = new int[] { 1, 15, 24, 65, 98, 63, 45, 5, 3 };
            //var sortedArray = SortedUtil<int>.SelectionSort(array);

            var sortedArray = SortedUtil<int>.InsertionSort(array);
            Console.WriteLine(SortedUtil<int>.ToString(sortedArray));

            int[] mergeArray = new int[] { 2, 4, 6, 1, 3, 5 };

            SortedUtil<int>.MergeSort(mergeArray, 0, 5);
            Console.WriteLine(SortedUtil<int>.ToString(mergeArray));

            int[] quickArray = new int[] { 15, 65, 48, 54, 33, 2, 9, 22, 13 };
            SortedUtil<int>.QuickSort(quickArray, 0, 8);
            Console.WriteLine(SortedUtil<int>.ToString(quickArray));

            int[] bubbleSortArr = new int[] { 15, 65, 48, 54, 33, 2, 9, 22, 13 };
            SortedUtil<int>.BubbleSort(bubbleSortArr);
            Console.WriteLine(SortedUtil<int>.ToString(bubbleSortArr));

            int[] heapSortArr = new int[] { 15, 65, 48, 54, 33, 2, 9, 22, 13 };

            Console.WriteLine(SortedUtil<int>.ToString(SortedUtil<int>.HeapSort(heapSortArr)));

            int[] countingSortArr = new int[] { 15, 65, 48, 54, 33, 2, 9, 22, 13 };
            Console.WriteLine(SortedUtil<int>.ToString(SortedUtil<int>.CountingSort(countingSortArr)));

            int[] radixSortArr = new int[] { 156, 6548, 48, 546, 33, 2, 9, 22, 13 };
            SortedUtil<int>.RadixSort(radixSortArr);
            Console.WriteLine(SortedUtil<int>.ToString(radixSortArr));

            int[] buketSortArr = new int[] { 15, 65, 48, 54, 33, 2, 9, 22, 13 };
            SortedUtil<int>.BuketSort(buketSortArr);
            Console.WriteLine(SortedUtil<int>.ToString(buketSortArr));

            int[] shellSortArr = new int[] { 15, 65, 48, 54, 33, 2, 9, 22, 13 };
            SortedUtil<int>.ShellSort(shellSortArr);
            Console.WriteLine(SortedUtil<int>.ToString(shellSortArr));

结果如下
在这里插入图片描述
github：https://github.com/pw8992134/Algorithm/blob/master/Algorithm/Sort/SortUtil.cs

pw8992134
关注
专栏目录
手撸冒泡排序代码：数据结构与算法小结1
StefanSSSS的博客
10-23 154
首先，正在看文章的靓仔，现在有个需求给你： 将已知的数组里面的值重新排序，按照从小到大的顺序打印输出； 你会怎么思考呢？ 这个需求需要用到排序的算法，排序有很多种方式，比如 1.冒泡排序：（今天以这个为例） 2.选择排序： 3.插入排序 一 .为啥叫冒泡排序呢？ 一开始我也挺有疑问的，直到我将排序过程竖着看的时候，就豁然开朗了； 举个例子，一个数组长这样： Integer[] arr = {85, 7, 9, 56, 47, 1, 2, 8, 5}; 假如竖着看，...
排序基础之选择排序法
乔布奇的博客
02-25 1115
如何实现一个选择排序呢？
撸代码之排序算法
05-28 102
排序算法分类： （图片来至于网络） 排序算法离不开数据的交换，简单数据交换方法： public static void swap(int[] num, int i, int j) { if (i == j) { return; ...
手写排序算法（一）
lizefeng1998的博客
03-30 486
手写排序算法（一） 算法分析 1、冒泡排序 vector<int> bubble(vector<int> nums)//冒泡排序 { for (int i = nums.size() - 1; i > 0; i--) { bool judge = false; for (int j = 0; j < i; j++) { if (nums[j] > nums[j + 1]) { int t = nums[j]; nums[
Java实现桶排序算法
Fury的博客
09-16 1299
桶排序 上学第一次听到桶排序时候一脸蒙蔽，心想数据结构也学习了，有堆、栈、队列等，没听说还有个桶的数据结构。看完代码才算明白原来桶只是打个比方的意思。其实网上关于排序算法的博客一大把，写这篇的目的主要是记录一下，因为今天突然兴起撸一遍桶排序时候竟然想不起来怎么写的了，好气所以干脆记录起来，好记性不如烂笔头。算法这东西不经常用的话忘得是真快。 桶排序 (Bucket sort)或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递归方式继续
面试必备题：用 Python 实现十大经典排序算法
m0_59596937的博客
01-27 488
排序算法是《数据结构与算法》中最基本的算法之一，也是面试必背题，为方便技术交流，文末创建技术交流群。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 关于时间复杂度 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。 线性对数阶 (O(nlog2n))
撸完十大经典排序算法也枉然，一行代码搞定面试
外星喵的博客
05-09 822
目录 选择排序 插入排序 冒泡排序 非优化版本 优化版本 希尔排序 归并排序 递归式归并排序 非递归式归并排序 快速排序 堆排序 基数排序 非优化版本 优化版本 桶排序 基数排序 选择排序 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据
手撸冒泡排序
吃瓜叶少的博客
06-24 472
title: 手撸冒泡排序 date: 2019-04-20 23:37:50 tags: 冒泡排序 categories: 算法 手撸冒泡排序 下面是自己对冒泡的理解，以便日后回顾： 例如一个从小到大的排序，一个元素与后面的元素对比，如果大于后面的元素，则交换位置，交换位置后，接着与其后元素对比。如果该元素比其后元素小，则不交换位置，其后元素接着与后面元素比较。 public stati...
河北专接本微机原理汇编，手撸一个算法-冒泡排序
苏落is菜鸡的博客
04-27 339
河北专接本微机原理汇编 手撸一个冒泡排序
Python-Leetcode题解跟随思路一步一步撸出代码及经典算法实现
08-10
1. **排序算法**：Python 内置的 `sorted()` 函数和 `list.sort()` 方法可以快速完成排序任务，但更为底层的排序算法如冒泡排序、插入排序、选择排序、快速排序、归并排序等，也是算法学习中的基础内容。理解这些...
c语言十大经典算法排序,十大经典排序算法，作为程序员一定要知道！（详细解析）...
weixin_39699070的博客
05-24 1108
十大排序算法可以说是每个程序员都必须得掌握的了，花了一天的时间把代码实现且整理了一下，为了方便大家学习，我把它整理成一篇文章，每种算法会有简单的算法思想描述，为了方便大家理解，我还找来了动图演示；这还不够，我还附上了对应的优质文章，看完不懂你来砍我，如果不想砍我就给我来个好看。术语铺垫有些人可能不知道什么是稳定排序、原地排序、时间复杂度、空间复杂度，我这里先简单解释一下：1、稳定排序：如果 a 原...
Swift实现排序算法
03-20 3095
快速排序 时间复杂度O( Nlog2N)） 1、选择基准点P，大的放在右边，小的放在左边。 2、递归调用左边，右边 func quickSorted (_ nums: inout [Int], _ left: Int, _ right: Int) { if left >= right { return ; } var l = left var r = right let pivot = nums[l] while l <
一、排序算法
初入博客
08-18 391
数据结构与算法-排序算法排序算法概述常用的排序算法冒泡排序快速排序选择排序插入排序归并排序堆排序桶排序基数排序计数排序希尔排序 排序算法概述 排序算法的用途是对数据集合按照一定规则进行排序，排序算法可以分为两类： 比较类排序：通过比较元素之间的大小，决定相对次序，时间复杂度与数据规模强相关。 非比较类排序：不通过比较元素大小决定次序，时间复杂度和数据规模不强相关，算法复杂度与数据特征有关系。 常用的排序算法如下： 算法 时间复杂度 最好时间复杂度 最差时间复杂度 空间复杂度 稳定性 冒泡排序
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 497
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 293
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1181
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 320
试除法求约数、约数个数、约数之和、最大公约数
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 476
64. 最小路径和。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值