zoukankan html css js c++ java

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

以下内容是根据 https://www.cnblogs.com/fivestudy/p/10212306.html 原文是用java语言写得，我用C#语言改写

GitHub Repo：Sort Article Follow: MisterBooo · GitHub

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

排序算法简介

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

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

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

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

用一张图概括：

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

查看全文

相关阅读:
MySQL "show users"
MySQL
A MySQL 'create table' syntax example
MySQL backup
MySQL show status
Tomcat, pathinfo, and servlets
Servlet forward example
Servlet redirect example
Java servlet example
How to forward from one JSP to another JSP

原文地址：https://www.cnblogs.com/for-easy-fast/p/12970091.html

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

排序算法简介

1. 冒泡排序

2. 选择排序

3. 插入排序

4. 希尔排序

5. 归并排序

6. 快速排序

7. 堆排序

8. 计数排序

9. 桶排序

10. 基数排序

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