查找最小的k 个元素之C#算法实现

紧接着上一篇微软编程面试100题，这次想解决的是查找最小的K个元素，题目是：输入n 个整数，输出其中最小的k 个。例如输入1，2，3，4，5，6，7 和8 这8 个数字，则最小的4 个数字为1，2，3 和4。

看到题目的时候我第一反应，这题很简单，使用任何方式的排序将数列按顺序存储，之后遍历需要的k个元素即可，于是自己动手很容易就完成了，但是后来在网络上发现很多人对这题的解决方式是用小根堆(MinHeap)或者大根堆(MaxHeap)，这才意识到，其实出题人是醉翁之意不在酒，在乎复杂度的考虑也。

先写用排序的方式完成题目的方式吧，不仅简单，不需要费太多脑子，重要的是，正好趁这时候复习下排序，这里用快速排序完成：

        public static void Quick_Sort(int[] sort, int left, int right)
        {
            int mid = sort[(left + right) / 2];
            int i = left;
            int j = right;
            do
            {
                while (sort[i] < mid && i < right) i++;
                while (sort[j] > mid && j > left) j--;
                if (i <= j)
                {
                    int temp = sort[i];
                    sort[i] = sort[j];
                    sort[j] = temp;
                    i++;
                    j--;
                }

            } while (i <= j);

            if (j > left) Quick_Sort(sort, left, j);
            if (i < right) Quick_Sort(sort, i, right);
        }

然后定义一个MinKMethod的方法来获取所需元素：

        public static void MinKMethod(int[] sort, int k)
        {
            Quick_Sort(sort, 0, sort.Length - 1);
            if (k > sort.Length)
            {
                for (int j = 0; j < sort.Length; j++)
                {
                    Console.Write(sort[j] + " ");
                }
                Console.WriteLine();
            }
            if (k <= 0)
            {
                Console.WriteLine("Nothing Output");
            }
            if (k > 0 && k < sort.Length)
            {
                for (int j = 0; j < k; j++)
                {
                    Console.Write(sort[j] + " ");
                }
            }

        }

这么做的话，最快需要O(NlogN)的时间进行排序，然后在O(1)的时间内将k个数取出。

接下来看看如何用堆完成这个题：

        public static void FindKMin(int[] sort, int k)
        {
            int[] heap = sort;
            int rootIndex = k / 2 - 1;
            while (rootIndex >= 0)
            {
                reheap(heap, rootIndex, k - 1);
                rootIndex--;
            }

            for (int i = k, len=heap.Length; i < len; i++)
            {
                if (heap[i]<heap[0])
                {
                    heap[0] = heap[i];
                    reheap(heap, 0, k - 1);
                }
            }

            Console.WriteLine("The {0} min element =",k);
            for (int i = 0; i < k; i++)
            {
                Console.Write(heap[i] + " ");
            }
        }

        private static void reheap(int[] heap, int rootIndex, int lastInddex)
        {
            int orphan = heap[rootIndex];
            bool done = false;
            int leftIndex = rootIndex * 2 + 1;
            while (!done && leftIndex <= lastInddex)
            {
                int largerIndex = leftIndex;
                if (leftIndex+1 <= lastInddex)
                {
                    int rightIndex = leftIndex + 1;
                    if (heap[rightIndex] > heap[leftIndex])
                    {
                        largerIndex = rightIndex;
                    }
                }

                if (orphan < heap[largerIndex])
                {
                    heap[rootIndex] = heap[largerIndex];
                    rootIndex = largerIndex;
                    leftIndex = rootIndex * 2 + 1;
                }
                else
                {
                    done = true;
                }
            }

            heap[rootIndex] = orphan;
        }

用堆解决这个问题其实思路并不难，前提是，需要对堆有一定的理解。