C# 小根堆

堆排序是一个完全二叉树
（来自百度百科）
同时这个完全二叉树还有这一个性质：
根节点总比两个子节点要小（或者要大）
小的叫做小根堆
大的叫做大根堆

逻辑上是一颗树
然后实际使用时，我们通过一个数组对其存储，通过从上而下，从左往右的进行遍历
每个父节点和子节点有如下对应关系：

相对的：
假设子节点为k
则父节点为：(k+1)/2-1
(偶数int+1之后再除以2不受影响)

由于之前做的那道题目用到了小根堆，所以就以小根堆为例

主要操作为
1.插入
2.移除

插入时，会将值放在数组的末尾，然后从末尾出发，如果这个值所在位置比根节点的值更小，则对其进行交换，直至确认这个值所处位置满足小根堆的特点
（这用到上面的子节点为k，父节点为(k+1)/2-1这个式子）

移除时，将根节点和最后一个值交换，同时移除最后一个值
（网上好像挺多人的做法是用一个array进行存储，然后length表示长度，交换之后length-1，这样方便恢复重建原先的小根堆，length+1然后从最后一个位置出发确定位置，相当于上面的插入那一步了）
移除最后一个值后，再从根节点出发，确认这个值的位置
假如右子树存在时，将这两个子节点中较小的一个和根交换
（用到了根节点为i，子节点分别为i2+1和i2+2）

leetCode题目如下：
给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第k小的元素。
请注意，它是排序后的第k小元素，而不是第k个元素。

示例:

matrix = [
[ 1, 5, 9],
[10, 11, 13],
[12, 13, 15]
],
k = 8,

返回 13。

说明:
你可以假设 k 的值永远是有效的, 1 ≤ k ≤ n2 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/kth-smallest-element-in-a-sorted-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

        public int KthSmallest(int[][] matrix, int k)
        {
            //int rank = 1;
            int n = matrix.Length;
            minHeap h = new minHeap();
            for (int i = 0; i < n; i++)
                for (int j = 0; j < n; j++)
                {
                    h.insert(matrix[i][j]);
                }


            return h.Sort(k);
        }

        public class minHeap
        {
            private List<int> l = new List<int>();
            public void insert(int val)
            {
                l.Add(val);
                int index = l.Count - 1;
                while ((index + 1) / 2 - 1 >= 0 && l[(index + 1) / 2 - 1] > l[index])
                {
                    int m = l[index];
                    swap(index, (index + 1) / 2 - 1);
                    index = (index + 1) / 2 - 1;
                }
            }
            public int Sort(int k)
            {
                int res = 0;
                for (int i = 0; i < k; i++)
                {
                    res = RemoveMin();
                }
                return res;
            }
            public int RemoveMin()
            {
                int min = l[0];
                int temp = l[l.Count - 1];
                l[0] = temp;
                l.RemoveAt(l.Count - 1);
                int i = 0;
                for (int k = 2 * i + 1; k < l.Count; k = 2 * k + 1)
                {
                    if (k + 1 < l.Count && l[k] > l[k + 1])
                        k++;
                    if (l[k] < temp)
                    {
                        swap(k, i);
                        i = k;
                    }
                    else
                        break;
                }
                return min;
            }
            private void swap(int index1, int index2)
            {
                int m = l[index1];
                l[index1] = l[index2];
                l[index2] = m;
            }

        }

还有好多可以优化的地方：如将list换成int数组。还有什么时候停止小根堆的构建，因为图省事用了list，并且将所有的值都放进去小根堆了，所以执行效率比较低（但是居然还能击败80%多，说明这道题用C#做的人的确很少）

小根堆插入和移除的过程：
插入：

移除（排序）