编程之美-电梯调度-快速排序-查找第K大数

亚洲微软研究院所在的希格玛大厦一共有6部电梯。在高峰时间，每层都有人上下，电梯每层都停。实习生小飞常常会被每层都停的电梯弄的很不耐烦，于是他提出了这样一个办法：
由于楼层并不算太高，那么在繁忙的上下班时间，每次电梯从一层往上走时，我们只允许电梯停在其中的某一层。所有乘客从一楼上电梯，到达某层后，电梯停下来，所有乘客再从这里爬楼梯到自己的目的层。在一楼的时候，每个乘客选择自己的目的层，电梯则计算出应停的楼层。
问：电梯停在哪一层楼，能够保证这次乘坐电梯的所有乘客爬楼梯的层数之和最少？

 

分析:如果只有两个人到不同的楼层,A到4楼,B到9楼,那么电梯停在[4,9]区间之间，他们爬楼梯的总和都是一样的，共爬5个楼层。

如果有三个人：A到4楼，B到6楼，C到9楼，那么停在6楼的时候爬的楼层最少。

如果有四个人：A到4楼，B到5楼，C到7楼，D到11楼,那么停在[5,7]区间之间时，爬的楼层总和最少。

由上可得，就是找中位数的问题。本文用快速排序查找。

 

快速排序(Quicksort)是对冒泡排序的一种改进.

它的基本思路是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据比另外一部分的所有数据都要小,然后再按此方法对这两部分分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列.

时间复杂度: T(n)=θ（nlogn）

样例演示：

 

代码主体：

using System.Collections.Generic;

namespace QuickSortArithmetic
{
    /// <summary>
    /// 用快速排序查找第K大的数
    /// </summary>
    public class QuickSortOfKMaxNum
    {
        //最后返回的第K大的数
        private int? _theKmaxNum = null;
        //第K大的数的顺序，也就是K
        public int K;//改为小写k试试

        public int? TheKmaxNum { get; set; }

        public int? GetKmaxNum(List<int> list, int k)
        {
            K = k - 1;
            QuickSort(list, 0, list.Count - 1);
            return TheKmaxNum;
        }

        public void QuickSort(List<int> list, int _left, int _right)
        {
            if (_left > _right)
                return;

            //把数据集的最左边和最右边标量保存下来
            int left = _left, right = _right;

            //选取数据集的第一个数为基准数，并保存在变量x上
            int x = list[left];
            while (left < right)
            {
                //从数据集的最右边开始找，在找到比x小的数之前，不断的从右边向左边查找，
                //直到找到比x小的数，每次比较都向左边移动一个距离right--
                while (x < list[right] && left < right)
                    right--;

                //如果找到比x小的数，那么就就和left位置的数交换数值，
                //第一次运行时是第一个位置，交换之后，第一个位置就是比x小的数值，第right位置的数值就是x的数值
                //同时left++，即向右边移动一个距离，因为left位置的数值就是刚刚交换过来比x小的数，不需要比较了
                if (list[right] < x && left < right)
                {
                    Swap(list, left, right);
                    left++;
                }

                //右边查找到一个符合的数之后，反过来开始从左边标量left向右边right查找比x大的数
                //直到找到符合的数，每次比较都想右边移动一个距离left++
                while (list[left] < x && left < right)
                    left++;

                //如果找到比x大的数，那么就和right位置的数交换
                if (x < list[left] && left < right)
                {
                    Swap(list, left, right);
                    right--;
                }
            }
            list[left] = x;

            //因为经过上面排序之后，已经知道在K之前的数都比K小，在K之后的数都比K大，
            //如果刚好left（此时left和right相等）等于K，那么left位置的值就是第K大的数
            if (left == K)
                TheKmaxNum = list[left];

            //如果left大于K，那么就是说第K大的数至少比left位置的数大，
            //而比left位置大的数都在它的右边，所以只需要从右边开始找
            else if (left > K)
            {
                QuickSort(list, left + 1, _right);
            }
            else
            {
                QuickSort(list, _left, left - 1);
            }
        }

        private void Swap(List<int> s, int i, int j)
        {
            int temp = s[j];
            s[j] = s[i];
            s[i] = temp;
        }
    }
}

 

执行代码：

using System;
using System.Collections.Generic;

namespace QuickSortArithmetic
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> s = new List<int>();
            Random rd = new Random();
            for (int i = 0; i < 10; i++)
            {
                s.Add(rd.Next(0, 50));
            }

            //第K大的数
            QuickSortOfKMaxNum quick = new QuickSortOfKMaxNum();
            int? kmax = quick.GetKmaxNum(s, 4);
        }
    }
}