C#语言十大经典排序算法动画与解析！（动态演示+代码）(java改写成C# )

以下内容是根据 https://www.cnblogs.com/fivestudy/p/10212306.html 进行改写

排序算法是《数据结构与算法》中最基本的算法之一。

排序算法简介

排序算法可以分为内部排序和外部排序。

内部排序是数据记录在内存中进行排序。

而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

用一张图概括：

image

关于时间复杂度：

平方阶 (O(n2)) 排序各类简单排序：直接插入、直接选择和冒泡排序。
线性对数阶 (O(nlog2n)) 排序快速排序、堆排序和归并排序；
O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。希尔排序
线性阶 (O(n)) 排序基数排序，此外还有桶、箱排序。

关于稳定性：

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

1. 冒泡排序

1.1 算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

1.2 动画演示

image

1.3 参考代码

   /// <summary>
        /// 冒泡排序，从小到大
        /// </summary>
        /// <param name="a"></param>
        /// <param name="n"></param>
        static void BubbleSort(int[] arr,int n)
        {
            for (int i = 0; i < n-1; i++)
            {
                for (int j = 0; j < n-1-i; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        var temp = arr[j];//相邻的两个数，前面的值比后面的大，则两两交换值
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }

            {
                int[] arr = new int[] {5,4,2,3,8 };
                int n = arr.Length;
                ShowNum("排序前", arr);
                BubbleSort(arr, n);
                ShowNum("冒泡排序后", arr);
                Console.WriteLine("");
            }

        static void ShowNum(string des,int[] a)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < a.Length; i++)
            {
                sb.Append(a[i].ToString() + " ");
              
            }
            Console.WriteLine(des+"数据为："+sb.ToString());
        }

2. 选择排序

2.1 算法步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。

2.2 动画演示

image

2.3 参考代码

        /// <summary>
        /// 选择排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="n"></param>
        static void SelectSort(int[] arr,int n)
        {
           
            for (int i = 0; i < n-1; i++)
            {
                var minIndex = i;
                for (int j = i+1; j < n; j++)
                {
                    if (arr[j] < arr[minIndex])//在未排序区寻找最小的数
                    {
                        minIndex = j;//将最小的数索引保存
                    }
                }
                var temp = arr[i];//要选择的排序位置的值，与未排序区索引的值，两两交换
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }

            {
                int[] arr = new int[] { 2,4,3,6,5 };
                int n = arr.Length;
                ShowNum("排序前", arr);
                SelectSort(arr, n);
                ShowNum("选择排序后", arr);
                Console.WriteLine("");
            }

3. 插入排序

3.1 算法步骤

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

3.2 动画演示

image

3.3 参考代码

        /// <summary>
        /// 插入排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="n"></param>
        static void InsertSort(int[] arr,int n)
        {
            if (n <= 1)
            {
                return;
            }

            for (int i = 1; i < n; i++)
            {
                if (arr[i-1] > arr[i])
                {
                    var j = i - 1;
                    var temp = arr[i];//记录要插入的数据
                    arr[i] = arr[i - 1];//先后移一个元素

                    for (; j >= 0; --j)
                    {
                        if (arr[j] > temp)
                        {
                            arr[j + 1] = arr[j];
                        }
                        else
                        {
                            break;
                        }
                    }

                    arr[j + 1] = temp;//插入到正确位置

;                }
            }
        }
        /// <summary>
        /// 插入排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="n"></param>

        static void InsertSort1(int[] arr, int n)
        {
            for (int i = 1; i < n; i++)
            {
                var temp = arr[i];//记录要插入的数据
                // 从已经排序的序列最右边的开始比较，找到比其小的数
                int j = i;
                while (j>0 && arr[j-1]>temp)
                {
                    arr[j] = arr[j - 1];
                    j--;
                }
                //存在比其小的数，插入
                if (j != i)
                {
                    arr[j] = temp;
                }
            }
        }

            {
                int[] arr = new int[] { 5,3,4,7,2};
                int n = arr.Length;
                ShowNum("排序前", arr);
                InsertSort1(arr, n);
                ShowNum("插入排序后", arr);
                Console.WriteLine("");
            }

4. 希尔排序

4.1 算法步骤

选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
按增量序列个数 k，对序列进行 k 趟排序；
每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.2 动画演示

image

4.3 参考代码

        /// <summary>
        /// 希尔排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="n"></param>
        static  void     SellSort(int[]arr,int n)
        {
            int gap = 10;
            while (gap < n)
            {
                gap = gap * 2 + 1;
            }
            while (gap > 0)
            {
                for (int i = gap; i < n; i++)
                {
                    var temp = arr[i];
                    int j = i - gap;
                    while(j>=0&& arr[j] > temp)
                    {
                        arr[j + gap] = arr[j];
                        j -= gap;
                    }
                    arr[j + gap] = temp;
                }
                gap = (int)Math.Floor(gap / 2.00);
            }
           
        }

            {
                int[] arr = new int[] { 8,9,1,7,2,3,5,4,6,0 };
                int n = arr.Length;
                ShowNum("排序前", arr);
                SellSort(arr,n);
                ShowNum("希尔排序后", arr);
                Console.WriteLine("");
            }

5. 归并排序

5.1 算法步骤

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
设定两个指针，最初位置分别为两个已经排序序列的起始位置；
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
重复步骤 3 直到某一指针达到序列尾；
将另一序列剩下的所有元素直接复制到合并序列尾。

5.2 动画演示

image

5.3 参考代码

写法一:

      /// <summary>
        /// 归并排序，从小到大
        /// </summary>
        /// <param name="arr">原arr</param>
        /// <param name="newArr">排序后的newArr</param>
        /// <param name="fristIndex">首位Index</param>
        /// <param name="lastIndex">末位Index</param>
        /// <returns></returns>
        static int[] MergeSort(int[] arr, int[] newArr, int fristIndex, int lastIndex)
        {
            if (fristIndex == lastIndex)
            {
                newArr[fristIndex] = arr[fristIndex];
            }
            else
            {
                int midIndex = (fristIndex + lastIndex) / 2;//将SR[s...t]评分为SR[s...m]和SR[m+1...t]
                int[] newArr2 = new int[arr.Length];
                MergeSort(arr, newArr2, fristIndex, midIndex);//递归地将SR[s...m]归并为有序的TR2[s...m]
                                         //ShowSortArray(test, s, m);
                MergeSort(arr, newArr2, midIndex + 1, lastIndex);//递归地将SR[m+1...t]归并为有序的TR2[m+1...t]
                Merge(newArr2, newArr, fristIndex, midIndex, lastIndex);
            }
            return newArr;
        }
        /// <summary>
        /// 将arr中记录由小到大地并入newArr
        /// </summary>
        /// <param name="arr">原arr</param>
        /// <param name="newArr">要并入目标的newArr</param>
        /// <param name="fristIndex">首位Index</param>
        /// <param name="midIndex">分割Index</param>
        /// <param name="lastIndex">末位Index</param>
        private static void Merge(int[] arr, int[] newArr, int fristIndex, int midIndex, int lastIndex)
        {
            int j = 0, k = 0;
            for (k = fristIndex, j = midIndex + 1; fristIndex <= midIndex && j <= lastIndex; k++)
            {
                //将arr中首位值、分割位值的最小的那个依次并入newArr
                if (arr[fristIndex] <= arr[j])
                {
                    newArr[k] = arr[fristIndex];
                    fristIndex++;//首位Index 后移
                }
                else
                {
                    newArr[k] = arr[j];
                    j++; //分割Index 后移
                }
            }
            //将剩下的尚未并入的arr[fristIndex]的值依次并入到newArr
            if (fristIndex <= midIndex)
            {
                while (k <= lastIndex && fristIndex <= midIndex)
                {
                    newArr[k] = arr[fristIndex];
                    k++;
                    fristIndex++;
                }
            }
            //将剩下的尚未并入的arr[midIndex]的值依次并入到newArr
            if (j <= lastIndex)
            {
                while (k <= lastIndex && j <= lastIndex)
                {
                    newArr[k] = arr[j];
                    k++;
                    j++;
                }
            }

        }

写法二：

        /// <summary>
        /// 归并排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        static int[] MergeSort1(int[] arr)
        {
            var result = new int[arr.Length];
            if (arr.Length == 1)
            {
                return arr;
            }
          
            int middle = arr.Length / 2;

            int[] left = arr.ToList().Take(middle).ToArray();

            int[] right = arr.ToList().Skip(middle).ToArray();

            var newLeft = MergeSort1(left);
            var newRight = MergeSort1(right);
            
            return Merge1(newLeft,newRight);
        }
        private static int[] Merge1(int[] left, int[] right)
        {
            int[] result = new int[left.Length + right.Length];
            int i = 0;
            while (left.Length > 0 && right.Length > 0)
            {
                if (left[0] <= right[0])
                {
                    result[i++] = left[0];
                    left = left.ToList().Skip(1).ToArray();

                }
                else
                {
                    result[i++] = right[0];
                    right = right.ToList().Skip(1).ToArray();
                }
               
            }
            while (left.Length > 0)
            {
                result[i] = left[0];
                left = left.ToList().Skip(1).ToArray();
                i++;
            }
            while (right.Length > 0)
            {
                result[i] = right[0];
                right = right.ToList().Skip(1).ToArray();
                i++; ;
            }
            return result;
        }

            {
                int[] arr = new int[] { 6,4,3,7,5,1,2 };
                int n = arr.Length;
                ShowNum("排序前", arr);
                int[] newArr = new int[arr.Length];
                newArr =  MergeSort( arr,newArr,0,arr.Length-1);
                ShowNum("归并排序后", newArr);
                newArr = MergeSort1(arr);
                ShowNum("归并2排序后", newArr);
                Console.WriteLine("");
            }

6. 快速排序

6.1 算法步骤

从数列中挑出一个元素，称为 “基准”（pivot）;
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

6.2 动画演示

image

6.3 参考代码

        /// <summary>
        /// 快速排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        static void QuickSort(int[] arr,int left,int right)
        {
            if (left < right)
            {
                var L_R = arr[left];//基准数，把比他小或者等于它的 放在它的左边，然后把比它大的 放在它的右边
                var i = left;
                var j = right;
                while (i < j)
                {
                    //从后往前比较
                    while (i < j)
                    {
                        if (arr[j] <= L_R)//找到一个比基准数小于或者等于的值，应该把他放在L_R的左边
                        {
                            arr[i] = arr[j];
                            break;
                        }
                        else
                        {
                            j--;//向左移动 到下一个数字，然后做比较
                        }
                    }

                    //从前往后
                    while (i < j)
                    {
                        if (arr[i] > L_R)//找到一个比基准数大于或者等于的值，应该把他放在L_R的右边
                        {
                            arr[j] = arr[i];
                            break;
                        }
                        else
                        {
                            i++;
                        }
                    }
                }
                //跳出循环，现在i==j  i是中间位置
                arr[i] = L_R;
                QuickSort(arr, left, i - 1);
                QuickSort(arr, i + 1, right);
            }

        }

            {
                int[] arr = new int[] {3,5,8,1,2,9,4,7,6 };
                int n = arr.Length;
                ShowNum("排序前", arr);
                QuickSort(arr, 0,n-1);
                ShowNum("快速排序后", arr);
                Console.WriteLine("");
            }

7. 堆排序

7.1 算法步骤

创建一个堆 H[0……n-1]；
把堆首（最大值）和堆尾互换；
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
重复步骤 2，直到堆的尺寸为 1。

7.2 动画演示

image

7.3 参考代码

       /// <summary>
        /// 堆排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="n"></param>
        static void HeapSort(int[]arr)
        {
            BuildMaxHeap(arr); //创建大顶推（初始状态看做：整体无序）
            for (int i = arr.Length-1; i > 0; i--)
            {
                Swap(ref arr[0], ref arr[i]);//将堆顶元素依次与无序区的最后一位交换（使堆顶元素进入有序区）
                MaxHeapify(arr, 0, i);//重新将无序区调整为大顶堆
            }
        }
        /// <summary>
        /// 创建大顶推（根节点大于左右子节点）
        /// </summary>
        /// <param name="arr">待排数组</param>
        private static void BuildMaxHeap(int[] arr)
        {
           
            for (int i = arr.Length/2-1; i >=0; i--)//从最底层的最后一个根节点开始进行大顶推的调整
            {
                MaxHeapify(arr, i, arr.Length); //调整大顶堆

            }
        }
        /// <summary>
        /// 大顶推的调整过程
        /// </summary>
        /// <param name="arr">待调整的数组</param>
        /// <param name="currentIndex">待调整元素在数组中的位置</param>
        /// <param name="heapSize">堆中所有元素的个数</param>
        private static void MaxHeapify(int[]arr,int currentIndex,int heapSize)
        {
            int left = 2 * currentIndex + 1; //左子节点在数组中的位置
            int right = 2 * currentIndex + 2; //右子节点在数组中的位置
            int large = currentIndex; //记录此根节点、左子节点、右子节点 三者中最大值的位置
            if (left<heapSize && arr[left] > arr[large])//与左子节点进行比较
            {
                large = left;
            }
            if(right<heapSize&& arr[right] > arr[large]) //与右子节点进行比较
            {
                large = right;
            }
            if (currentIndex!=large)//如果 currentIndex != large 则表明 large 发生变化（即：左右子节点中有大于根节点的情况）
            {
                Swap(ref arr[currentIndex], ref arr[large]);  //将左右节点中的大者与根节点进行交换（即：实现局部大顶堆）
                MaxHeapify(arr, large, heapSize);//以上次调整动作的large位置（为此次调整的根节点位置），进行递归调整
            }
        }
        /// <summary>
        /// 交换函数
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        private static void Swap(ref int a,ref int b)
        {

            int temp = 0;
            temp = a;
            a = b;
            b = temp;
        }

            {
                int[] arr = new int[] { 5,2,7,3,6,1,4 };
                int n = arr.Length;
                ShowNum("排序前", arr);
                HeapSort(arr);
                ShowNum("堆排序后", arr);
                Console.WriteLine("");
            }

8. 计数排序

8.1 算法步骤

花O(n)的时间扫描一下整个序列 A，获取最小值 min 和最大值 max
开辟一块新的空间创建新的数组 B，长度为 ( max - min + 1)
数组 B 中 index 的元素记录的值是 A 中某元素出现的次数
最后输出目标整数序列，具体的逻辑是遍历数组 B，输出相应元素以及对应的个数

8.2 动画演示

image

8.3 参考代码

        /// <summary>
        /// 计数排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="n"></param>
        static void CountingSort(int[]arr, int n)
        {
            int min = arr[0];
            int max = min;
            foreach (int number in arr)
            {
                if (number > max) { max = number; }
                else if (number < min) { min = number; }
            }
            int[] counting = new int[max - min + 1];
            for (int i = 0; i < n; i++)
            {
                counting[arr[i] - min] += 1;
            }
            int index = -1;
            for (int i = 0; i < counting.Length; i++)
            {
                for (int j = 0; j < counting[i]; j++)
                {
                    index++;
                    arr[index] = i + min;
                }
            }
        }

            {
                int[] arr = new int[] { 5,3,4,7,2,4,3,4,7 };
                int n = arr.Length;
                ShowNum("排序前", arr);
                CountingSort(arr, n);
                ShowNum("计数排序后", arr);
                Console.WriteLine("");
            }

9. 桶排序

9.1 算法步骤

设置固定数量的空桶。
把数据放到对应的桶中。
对每个不为空的桶中数据进行排序。
拼接不为空的桶中数据，得到结果

9.2 动画演示

9.3 参考代码

        /// <summary>
        /// 桶排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="bucketCount">桶数</param>
        /// <returns></returns>
         static void BucketSort(int[] arr,int bucketCount)
        {
            int bucketSize = (arr.Max() - arr.Min()) / bucketCount + 1;
           
            // 桶
            LinkedList<int>[] bucket = new LinkedList<int>[bucketCount];
            // 初始化桶
            for (int i = 0; i < bucketCount; i++)
            {
                bucket[i] = new LinkedList<int>();
            }

            // 元素分装到各桶
            for (int i = 0; i < arr.Length; i++)
            {
              
                int bucketIndex = (arr[i]-arr.Min())/ bucketSize;//arr[i] 的值放入第Index的桶中（Index值 从0 到 buckectCount-1）

                // 添加并进行插入排序
                InsertToLinkList(bucket[bucketIndex], arr[i]);
            }

            // 各桶排序
            int index = 0;
            for (int i = 0; i < bucketCount; i++)
            {
                foreach (var item in bucket[i])
                {
                    arr[index++] = item;
                }
            }

         
        }

        /// <summary>
        ///  按升序插入
        /// </summary>
        /// <param name="linkedList">要排序的链表</param>
        /// <param name="num">要插入排序的数字</param>
        private static void InsertToLinkList(LinkedList<int> linkedList, int num)
        {
            if (linkedList.Count == 0)
            {
                linkedList.AddFirst(num);
                return;
            }

            var minValue = linkedList.Min(); var minNode = linkedList.Find(minValue);
            var maxValue = linkedList.Max(); var maxNode = linkedList.Find(maxValue);
            if (num < minValue)
            {
                linkedList.AddBefore(minNode, num);
                return;
            }
            if (num >maxValue)
            {
                linkedList.AddAfter(maxNode, num);
                return;
            }
            else
            {
                for (int i = 0; i < linkedList.Count-1; i++)
                {
                    if (linkedList.ElementAt(i) <= num && linkedList.ElementAt(i+1)>=num)
                    {
                        LinkedListNode<int> node = linkedList.FindLast(linkedList.ElementAt(i));
                        linkedList.AddAfter(node, num);
                        return;
                    }
                }
            }

        }

            {
                int[] arr = new int[] {7,12,56,23,19,33,35,42,42,2,8,22,39,26,17 };
                int n = arr.Length;
                ShowNum("排序前", arr);
                BucketSort(arr, 5);
                ShowNum("桶排序后", arr);
                Console.WriteLine("");
            }

10. 基数排序

10.1 算法步骤

将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零
从最低位开始，依次进行一次排序
从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列

10.2 动画演示

image

10.3 参考代码

        /// <summary>
        /// 基数排序，从小到大
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="bucketNum">桶数</param>
        static void RadixSort(int[]arr,int bucketNum)
        {
            int maxLength = MaxLength(arr);
            //创建bucket时，在二维中增加一组标识位，其中bucket[x, 0]表示这一维所包含的数字的个数
            //通过这样的技巧可以少写很多代码

            int[,] bucket = new int[bucketNum, arr.Length + 1];
            for (int i = 0; i < maxLength; i++)
            {
                foreach (var item in arr)
                {
                    int bit = (int)(item / Math.Pow(10, i) % 10);
                    bucket[bit, ++bucket[bit, 0]] = item;
                }
                for (int count = 0,j=0; j < bucketNum; j++)
                {
                    for (int k = 1; k <= bucket[j,0]; k++)
                    {
                        arr[count++] = bucket[j, k];
                    }
                }
                //  //最后要重置这个标识
                for (int j = 0; j < bucketNum; j++)
                {
                    bucket[j, 0] = 0;
                }
            }
        }
        
        private static int MaxLength(int[] arr)
        {
            if (arr.Length == 0) return 0;
            int max = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                if (arr[i] > max) max = arr[i];
            }
            int count = 0;
            while (max != 0)
            {
                max /= 10;
                count++;
            }
            return count;
           // return (int)Math.Log10(max)+1;
        }

            {
                int[] arr = new int[] { 1, 10, 321, 127, 743, 60, 577 };        
                int n = arr.Length;
                ShowNum("排序前", arr);
                RadixSort(arr, 10);
                ShowNum("基数排序后", arr);
                Console.WriteLine("");
            }


GitHub Repo：Sort Article 
Follow: MisterBooo · GitHub


内容改写自： https://www.cnblogs.com/fivestudy/p/10212306.html

posted @ 2020-05-27 18:42 明志德道阅读(781) 评论(0) 编辑收藏举报

刷新页面返回顶部

择其通者而纳之

世间知无限，唯识异同

C#语言十大经典排序算法动画与解析！（动态演示+代码）(java改写成C# )

排序算法简介

1. 冒泡排序

2. 选择排序

3. 插入排序

4. 希尔排序

5. 归并排序

6. 快速排序

7. 堆排序

8. 计数排序

9. 桶排序

10. 基数排序

公告

择其通者而纳之

世间知无限，唯识异同

C#语言 十大经典排序算法动画与解析！（动态演示+代码）(java改写成C# )

排序算法简介

1. 冒泡排序

2. 选择排序

3. 插入排序

4. 希尔排序

5. 归并排序

6. 快速排序

7. 堆排序

8. 计数排序

9. 桶排序

10. 基数排序

公告

C#语言十大经典排序算法动画与解析！（动态演示+代码）(java改写成C# )