C#实现快速排序（两种方法）

最新推荐文章于 2024-03-08 11:50:53 发布
booksky508
最新推荐文章于 2024-03-08 11:50:53 发布
阅读量883
点赞数 1
分类专栏： C# / ASP.NET 文章标签： c# numbers pivot string 算法
本文链接：https://blog.csdn.net/booksky508/article/details/3168828
版权
C# / ASP.NET 专栏收录该内容
4 篇文章 0 订阅
订阅专栏
 
 //题目：快速排序 
//题目要求：实现快速排序算法，要求可以对目标数组的某一指定范围进行快速排序，轴（也称：基准）的位置允许选择。 
//现给出接口，如下： 
// 
numbers: 目标数组 
left:范围的左边界（当对全数组排序时，为0） 
right:范围的右边界（当对全数组排序时，为数组长度-1） 
pivot:轴（也称：基准）所在位置 
// 
//private void Sort(int[] numbers,  int left,  int right，int pivot) 
//{ 
Finish this function, please 
// 
//} 
using System;
namespace quickSort
{
    /// <summary> 
    /// Summary description for Class1. 
    /// </summary> 
    class MyQuickSort
    {
        /// <summary> 
        /// The main entry point for the application. 
        /// </summary> 
        
        //调试用 
        static int n = 0;
        static int n1 = 0;
        [STAThread] 
        #region //入口函数 
        static void Main(string[] args)
        {
            int[] numbers = {1, 6, 2, 8, 3, 4, 5, 9, 10, 100, 50, 8, 9, 4, 4, 4, 4, 5, 1000, 600, 0, -2, -9};
            int[] numbers1 = {1, 6, 2, 8, 3, 4, 5, 9, 10, 100, 50, 8, 9, 4, 4, 4, 4, 5, 1000, 600, 0, -2, -9};
            int left = 0;
            int right = numbers.Length - 1;
            int pivot = 0;
            //使用第一种方法对numbers中的指定元素段进行快速排序 
            //输出排序前的数组元素 
            Console.WriteLine("排序前：");
            for (int i = 0; i < numbers.Length; ++i)
            {
                Console.Write(numbers[i].ToString() + " ");
            }
            //此方法仅支持pivot为最左边元素 
            Sort(numbers, left, right, pivot);
            //输出排序后的数组元素 
            Console.WriteLine("/n排序后：");
            for (int i = 0; i < numbers.Length; ++i)
            {
                Console.Write(numbers[i].ToString() + " ");
            }
            Console.WriteLine();
            //使用第二种方法对numbers中的指定元素段进行快速排序 
            //输出排序前的数组元素 
            Console.WriteLine("排序前：");
            for (int i = 0; i < numbers1.Length; ++i)
            {
                Console.Write(numbers1[i].ToString() + " ");
            }
            //此方法pivot可为任意值 
            Sort1(numbers1, left, right, pivot);
            //输出排序后的数组元素 
            Console.WriteLine("/n排序后：");
            for (int i = 0; i < numbers1.Length; ++i)
            {
                Console.Write(numbers1[i].ToString() + " ");
            }
            Console.WriteLine();
        } 
        #endregion 
        #region //实现快速排序--方法一 
        //注意：将前++改为后++后各个数值以及判断条件的不同，这里不再列举 
        //此方法仅支持pivot为最左边元素 
        //numbers: 目标数组 
        //left:范围的左边界（当对全数组排序时，为0） 
        //right:范围的右边界（当对全数组排序时，为数组长度-1） 
        //pivot:轴（也称：基准）所在位置 
        private static void Sort(int[] numbers, int left, int right, int pivot)
        {
            if (left < 0 || left > numbers.Length - 1 || right < 0 || right > numbers.Length - 1)
            {
                Console.WriteLine("/n左右边界越界！");
                return;
            }
            if (pivot > right || pivot < left)
            {
                Console.WriteLine("/n基准点越界！");
                return;
            }
            int l = left;
            int r = right + 1;
            int temp = numbers[pivot];
            while (true)
            {
                //自左至右找到第一个大于基准的点 
                while (l <= right - 1 && numbers[++l] < temp);
                //自右至左找到第一个小于基准的点 
                while (r >= left + 1 && numbers[--r] > temp);
                if (l >= r)
                {
                    break;
                }
                //交换左边找到的点和右边找到的点 
                int t = numbers[l];
                numbers[l] = numbers[r];
                numbers[r] = t;
                //调试信息 
                n++;
                Console.WriteLine("/n第" + n.ToString() + "次交换后！");
                for (int i = left; i < right + 1; ++i)
                {
                    Console.Write(numbers[i].ToString() + " ");
                }
            }
            //交换基准与r 
            numbers[pivot] = numbers[r];
            numbers[r] = temp;
            //调试信息 
            n++;
            Console.WriteLine("/n第" + n.ToString() + "次交换后！");
            for (int i = left; i < right + 1; ++i)
            {
                Console.Write(numbers[i].ToString() + " ");
            }
            if (left < r - 1)
            {
                Sort(numbers, left, r - 1, left);
            }
            if (r + 1 < right)
            {
                Sort(numbers, r + 1, right, r + 1);
            }           
        } 
        #endregion 
        #region //实现快速排序--方法二 
        //此方法pivot可为任意值 
        //numbers: 目标数组 
        //left:范围的左边界（当对全数组排序时，为0） 
        //right:范围的右边界（当对全数组排序时，为数组长度-1） 
        //pivot:轴（也称：基准）所在位置 
        private static void Sort1(int[] numbers, int left, int right, int pivot)
        {
            if (left < 0 || left > numbers.Length - 1 || right < 0 || right > numbers.Length - 1)
            {
                Console.WriteLine("/n左右边界越界！");
                return;
            }
            if (pivot > right || pivot < left)
            {
                Console.WriteLine("/n基准点越界！");
                return;
            }
            int l = left;
            int r = right;
            int temp = numbers[pivot];   //基准的值 
            int low = pivot;  //基准的位置 
            while (l < r)
            {
                //自右至左找到第一个小于基准的点 
                while (numbers[r] >= temp && l < r && r >= low)
                {
                    --r;
                }
                //如果右边第一个小于基准的点在基准点左边，则不交换 
                if (r < low)
                {
                    r = low;
                }
        
                if (l < r && r != low)
                {
                    //将 找到的值 移到基准所在的位置 
                    numbers[low] = numbers[r];
                    //将基准的位置移到 找到的值 的位置 
                    low = r;
                    //调试信息 
                    ++n1;
                    Console.WriteLine("/n第" + n1.ToString() + "次交换后！");
                    for (int i = left; i < right + 1; ++i)
                    {
                        Console.Write(numbers[i].ToString() + " ");
                    }
                    Console.Write("low= " + low.ToString());
                }
                //自左至右找到第一个大于基准的点 
                while (numbers[l] <= temp && l < r && l <= low)
                {
                    ++l;
                }
                //如果左边第一个大于基准的点在基准点右边，则不交换 
                if (l > low)
                {
                    l = low;
                }
                if (l < r && l != low)
                {
                    //将 找到的值 移到基准所在的位置 
                    numbers[low] = numbers[l];
                    //将基准的位置移到 找到的值 的位置 
                    low = l;
                    //调试信息 
                    ++n1;
                    Console.WriteLine("/n第" + n1.ToString() + "次交换后！");
                    for (int i = left; i < right + 1; ++i)
                    {
                        Console.Write(numbers[i].ToString() + " ");
                    }
                    Console.Write("low= " + low.ToString());
                }
            }
            //将基准值移到基准位置 
            numbers[low] = temp;
            if (left < l - 1)
            {
                Sort1(numbers, left, low - 1, left);
            }
            if (l + 1 < right)
            {
                Sort1(numbers, low + 1, right, l + 1);
            }           
        } 
        #endregion 
    }
}
 
booksky508
关注
1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
C#实现快速排序（两种方法）

//题目：快速排序 //题目要求：实现快速排序算法，要求可以对目标数组的某一指定范围进行快速排序，轴（也称：基准）的位置允许选择。 //现给出接口，如下： // ////numbers: 目标数组 ////left:范围的左边界（当对全数组排序时，为0） ////right:范围的右边界（当对全数组排序时，为数组长度-1） ////pivot:轴（也称：基准）所
复制链接

扫一扫