算法_快速排序_笔记（二）

快速排序

 1、算法介绍：(Quick Sort，对冒泡算法的一种改进)
    由C. A. R. Hoare在1962年提出。 -- 分割 +　递归
    它的基本思想是：
            通过一趟排序将要排序的数据分割成独立的两部分，
    其中一部分的所有数据都比另外一部分的所有数据都要小，
    然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，
       以此达到整个数据变成有序序列。
   
 2、算法分析：
  稳定性：不稳定 
  时间复杂度：O(nlog2n)
  空间复杂度：O(nlog2n)
 
 3、算法特点
    快速排序是冒泡排序的改进版，是目前已知的最快排序方法之一。 //比堆排序
    优点：极快，数据移动少； 
       缺点：不稳定。 （有改进的快排)
   
 4、算法实现描述
    快速排序算法的基本思路：
  1)、设置两个变量lowNum、highNum，排序开始的时候：lowNum = 0，highNum=N-1；
       
        2)、left = lowNum， right = highNum；
       
  3)、以Array[left]作为关键数据，赋值给key，即 key = Array[left]；
      
  4)、从 right 开始向前搜索，right--，找到第一个小于key值的 A[right]，
      将 A[right] 和 A[left] 互换；
           
  5)、从 left 开始向后搜索，left++ ，找到第一个大于key值的 A[Left]，
      将 A[left] 和A[right] 互换；
           
  6)、重复第4、5步，直到 left == right。
  
  7)、 分裂为2组：  left = lowNum     和  right = right - 1 ，重复3～7，直到初始情况时， left == right
                          left = right + 1  和  right = highNum   ，重复3～7，直到初始情况时， left == right

5、代码实现

   

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

namespace SortProject_2020._06._04
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] ay = new int[]{ 2, 1, 3, 6, 4, 7, 8, 5, 10, 9};

            //排序
            QuickSort(ay,0,ay.Length-1);  //这里需要注意得是 C# 里面得length属性 是从下标1开始的 如果从0下标开始计算时就下标出界了

            for (int i = 0; i < ay.Length; ++i)
            {
                Console.Write(ay[i] + "  ");
            }


            Console.ReadKey();

        }

        //快速排序
        public static void  QuickSort(int[] _ay,int lowNum,int highNum)
        {
            //如果开始排序时，上下界限相等时，则返回
            if(lowNum >= highNum)
            {
                return;
            }

            //新建左右下标，初值为上下限。
            int left = lowNum;
            int right = highNum;

            //用left下标，对应得数组值作为关键值。
            int key = _ay[left];

            //当左右下标相等时，本趟比较结束
            while(left<right)
            {
                //从右到左，找到第一个小于key值得下标
                while(left< right && _ay[right]>=key)
                {
                    right--;
                }
                //交换
                swap(_ay, right, left);

                //从左到右，找到第一个大于key得值
                while (left < right && _ay[left] <= key)
                {
                    left++;
                }

                //交换
                swap(_ay, left, right);
            }

            //递归
            QuickSort(_ay, lowNum, left - 1);
            QuickSort(_ay, left + 1, highNum);
        }

        //交换函数
        public static void swap(int[] _ay1,int _ay_Index1,int _ay_Index2)
        {
            int tmp = _ay1[_ay_Index1];
            _ay1[_ay_Index1] = _ay1[_ay_Index2];
            _ay1[_ay_Index2] = tmp;
        }
        

    }
}