快速排序（拔萝卜法，实质就是一直否定寻找数当前的位置，一个萝卜，一个坑）...

最新推荐文章于 2021-11-12 18:00:14 发布

转载最新推荐文章于 2021-11-12 18:00:14 发布 · 344 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/kexb/p/5042975.html

本文介绍了一个使用C#实现的快速排序算法。通过递归方式，选取基准元素并对数组进行分区，确保基准元素左边的元素都小于它，右边的元素都大于它。此过程重复应用于左右两个子数组，直至整个数组有序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace QuickSort
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>() { 1, 1, 28, 14, 10, 67, 22, 90, 55, 100, 120, 140, 1, 12 };
            int low = 0;
            int high = list.Count - 1;
            int mid = (low + high) / 2;
            QuickSortArr(list, low, high);
            list.ForEach(a => { Console.WriteLine(a.ToString()); });
            Console.ReadKey();
        }
        public static void QuickSortArr(List<int> list, int low, int high)
        {
            //用来结束递归调用
            if (low >= high)
            {
                return;

            }
            int start = low;
            int end = high;

int mid = (low + high) / 2;

            int findNum = list[mid];
            //tag=0是初始化 tag用来标示要定位的数字的可能的位置
            int tag = 0;
            tag = mid;
            while (low<high)
            {

                while (findNum <= list[high] && tag < high)
                {
                    high--;

}

                //寻找的数字的可能的位置每次都在变化，不管是后面找小的还是前面找大的tag=high（定位可能的位置，tag=high是在更新可能的位置）
                if (findNum > list[high])
                {
                    list[tag] = list[high];
                    tag = high;
                }
                while (findNum >= list[low] && tag > low)
                {

                    low++;

                }
                //寻找的数字的可能的位置每次都在变化，不管是后面找小的还是前面找大的tag=low（定位可能的位置，tag=low是在更新可能的位置）
                if (findNum < list[low])
                {
                    list[tag] = list[low];
                    tag = low;
                }

            }
            //low==high的时候说明前面都是比被寻找数小的，后面都是比被寻找数大的，说以low==high的下标就是最终数的下标


            list[low] = findNum;

QuickSortArr(list, start, low - 1);
QuickSortArr(list, low + 1, end);

}
}
}

转载于:https://www.cnblogs.com/kexb/p/5042975.html