【C#进阶】高级数据结构和算法_2024-06-22

当我们深入到编程的世界，我们会发现，掌握高级数据结构和算法就像是拥有了一套高级工具箱，它们能帮助我们更高效、更优雅地解决问题。今天，我们就来一探究竟，看看这些高级工具是如何工作的。

首先，让我们来谈谈高级数据结构。

数据结构就像是我们用来存放东西的容器，高级数据结构就是一些更复杂的容器。

它们就像是我们编程中的“存储神器”，能让我们以不同的方式组织和访问数据。比如：

• 栈，它就像是一个只能从顶部放入和取出物品的容器，遵循“后进先出”的原则。
• 队列，它则像是一个有序的队伍，遵循“先进先出”的规则。
• 链表，它则提供了一种灵活的方式来存储数据，每个数据点都指向下一个数据点，形成一个链条。

1. 栈、队列、链表

栈（Stack）

想象一下你叠盘子。每次新放一个盘子都在最上面，拿走的时候也只能从最上面开始拿。这就是栈，后进先出（LIFO, Last In First Out）的数据结构。

// C#中使用Stack<T>类实现栈
using System.Collections.Generic;

public class StackExample
{
    public static void Main()
    {
        Stack<int> myStack = new Stack<int>();
        
        // 入栈：像叠盘子一样添加元素
        myStack.Push(1);
        myStack.Push(2);
        myStack.Push(3);
        
        Console.WriteLine("Top element: " + myStack.Peek()); // 查看但不移除顶部元素
        
        // 出栈：移除并返回顶部元素
        while (myStack.Count > 0)
        {
            Console.WriteLine("Popped: " + myStack.Pop());
        }
    }
}

队列（Queue）

想象排队买票，先来的先买，后来的后买。队列就是这样的，先进先出（FIFO, First In First Out）。

// 使用Queue<T>类实现队列
using System.Collections.Generic;

public class QueueExample
{
    public static void Main()
    {
        Queue<string> myQueue = new Queue<string>();
        
        // 入队：像排队一样加入元素
        myQueue.Enqueue("Alice");
        myQueue.Enqueue("Bob");
        myQueue.Enqueue("Charlie");
        
        Console.WriteLine("Front of queue: " + myQueue.Peek()); // 查看队首但不移除
        
        // 出队：移除并返回队首元素
        while (myQueue.Count > 0)
        {
            Console.WriteLine("Dequeued: " + myQueue.Dequeue());
        }
    }
}

链表（LinkedList）

链表就像是一串用绳子串起来的珠子，每个珠子（节点）都连着下一颗珠子。它不像数组那样连续存储，所以插入和删除操作更快，但访问特定位置的元素较慢。

// 使用LinkedList<T>类实现链表
using System.Collections.Generic;

public class LinkedListExample
{
    public static void Main()
    {
        LinkedList<int> myList = new LinkedList<int>();
        
        // 插入节点
        myList.AddFirst(3);      // 在头部添加
        myList.AddLast(5);       // 在尾部添加
        myList.AddBefore(myList.First, 2); // 在第一个元素前添加
        
        // 遍历链表
        foreach (int value in myList)
        {
            Console.WriteLine(value);
        }
    }
}

2. 排序和搜索算法

接下来是排序和搜索算法，它们是我们在处理大量数据时的好帮手。排序算法帮助我们把数据排成有序的序列，而搜索算法则帮助我们快速找到所需的数据。

排序算法（以冒泡排序为例）

冒泡排序就像是玩扑克牌，每次比较相邻两张，如果顺序不对就交换，一轮轮下来，最大的牌就像泡泡一样浮到最上面。

public static void BubbleSort(int[] arr)
{
    int n = arr.Length;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - 1 - i; j++) // 每轮少比较一次
        {
            if (arr[j] > arr[j + 1]) // 如果前一个大于后一个，交换
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

搜索算法（线性搜索）

线性搜索就像是在书架上找一本书，从头开始一本本检查，直到找到为止。

public static int LinearSearch(int[] arr, int target)
{
    for (int i = 0; i < arr.Length; i++)
    {
        if (arr[i] == target)
        {
            return i; // 找到了，返回位置
        }
    }
    return -1; // 没找到，返回-1
}

3. 泛型编程

最后，我们还有泛型编程，这是一种编写代码的方式，它允许我们创建可以处理多种数据类型的组件，使得代码更加通用和灵活。

比如能够处理多种数据类型的代码，不用为每种类型重复写相似逻辑。就像制作一个“万能模具”，不管是做蛋糕还是面包，只要换原料就行。

// 泛型方法示例
public static T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

public static void Main()
{
    Console.WriteLine(Max(10, 20));    // 整数比较
    Console.WriteLine(Max("apple", "banana")); // 字符串比较
}

通过泛型，我们让Max方法既能比较整数大小，也能比较字符串的字典序，无需为每种类型单独写函数。