C# | 堆.TrimExcess 方法与示例

在 C# 中，堆是一种常见的数据结构，可以用于许多应用程序中，包括排序和查找。堆 类提供的 TrimExcess 方法是一个非常有用的方法，它可以清除堆中的所有不必要的空间，从而提高程序的效率。

概述

TrimExcess 方法可以减少堆中的内存占用，并且不会影响堆中的元素。它是通过将堆的容量设置为堆中元素的实际数目来实现的。这样，就可以清除堆中的所有不必要的空间，从而提高程序的效率。

用法

TrimExcess 方法非常容易使用。只需调用 Heap 对象的 TrimExcess 方法即可。以下是其语法：

public void TrimExcess();

TrimExcess 方法不需要任何参数，因为它会自动计算要去掉多少空间。

示例

下面是一个示例，演示如何使用 TrimExcess 方法来清除堆中的所有不必要的空间。

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        // 创建一个堆并添加元素
        Heap<int> heap = new Heap<int>();
        heap.Add(10);
        heap.Add(20);
        heap.Add(30);

        // 打印堆中的元素数目和容量
        Console.WriteLine("Count: {0}", heap.Count); // Count: 3
        Console.WriteLine("Capacity: {0}", heap.Capacity); // Capacity: 4

        // 调用 TrimExcess 方法来清除堆中的所有不必要的空间
        heap.TrimExcess();

        // 再次打印堆中的元素数目和容量
        Console.WriteLine("Count: {0}", heap.Count); // Count: 3
        Console.WriteLine("Capacity: {0}", heap.Capacity); // Capacity: 3
    }
}

class Heap<T> where T : IComparable<T>
{
    List<T> items = new List<T>();

    public int Count
    {
        get { return items.Count; }
    }

    public int Capacity
    {
        get { return items.Capacity; }
    }

    public void Add(T item)
    {
        items.Add(item);
        BubbleUp(items.Count - 1);
    }

    public T Remove()
    {
        T first = items[0];
        int lastIndex = items.Count - 1;
        items[0] = items[lastIndex];
        items.RemoveAt(lastIndex);
        BubbleDown(0);
        return first;
    }

    void BubbleUp(int index)
    {
        int parentIndex = (index - 1) / 2;

        while (index > 0 && items[index].CompareTo(items[parentIndex]) > 0)
        {
            Swap(index, parentIndex);
            index = parentIndex;
            parentIndex = (index - 1) / 2;
        }
    }

    void BubbleDown(int index)
    {
        int childIndex1 = index * 2 + 1;
        int childIndex2 = index * 2 + 2;
        int largerIndex;

        while (childIndex1 < items.Count)
        {
            if (childIndex2 >= items.Count || items[childIndex1].CompareTo(items[childIndex2]) > 0)
            {
                largerIndex = childIndex1;
            }
            else
            {
                largerIndex = childIndex2;
            }

            if (items[largerIndex].CompareTo(items[index]) > 0)
            {
                Swap(largerIndex, index);
                index = largerIndex;
                childIndex1 = index * 2 + 1;
                childIndex2 = index * 2 + 2;
            }
            else
            {
                break;
            }
        }
    }

    void Swap(int index1, int index2)
    {
        T temp = items[index1];
        items[index1] = items[index2];
        items[index2] = temp;
    }

    public void TrimExcess()
    {
        items.TrimExcess();
    }
}

在上面的示例中，我们创建了一个堆并添加了三个元素。然后，我们打印了堆中的元素数目和容量。接着，我们调用了 TrimExcess 方法来清除堆中的所有不必要的空间，并再次打印了元素数目和容量。

输出如下所示：

Count: 3
Capacity: 4
Count: 3
Capacity: 3

如你所见，TrimExcess 方法成功地清除了堆中的所有不必要的空间，使其容量减少了一个。这将大大提高代码的效率，特别是在处理大型数据集时。