40、C# 数组、链表、哈希、队列、栈数据布局的特点、优点和缺点

一、数组（Array）

1.特点

• 固定长度，初始化后巨细不可变。
  
• 元素在内存中连续存储，通过索引直接访问。
  
• 支持多维数组（如二维、三维数组）。
  

2.优点

• 快速随机访问：通过索引访问元素的时间复杂度为O(1)。
  
• 内存连续：连续存储有助于缓存优化，提升访问效率。
  
• 简单易用：语法直观，得当处理固定巨细的聚集。
  

3.缺点

• 巨细固定：无法动态扩展，需手动创建新数组并复制元素。
  
• 插入/删除效率低：在中央插入或删除元素需移动大量元素，时间复杂度为O(n)。
  

4.代码示例

1. int[] array = new int[5] { 1, 2, 3, 4, 5 };
3. // 访问元素
4. int element = array[2]; // 返回3
6. // 修改元素
7. array[1] = 10; // 数组变为 [1, 10, 3, 4, 5]
9. // 遍历数组
10. foreach (int num in array)
11. {
12.     Console.WriteLine(num);
13. }

复制代码

二、链表（LinkedList）

1.特点

• 动态长度，节点通过指针毗连，无需连续内存。
  
• 支持双向链表（LinkedList），可前后遍历。
  

2.优点

• 动态扩展：无需预先分配空间，可随时增删节点。
  
• 高效插入/删除：在头部或尾部利用时间复杂度为O(1)，中央利用为O(n)（需遍历）。
  

3.缺点

• 随机访问效率低：需重新节点遍历，时间复杂度为O(n)。
  
• 额外内存开销：每个节点需存储指针，占用更多空间。
  

4.代码示例

1. using System.Collections.Generic;
3. LinkedList<int> linkedList = new LinkedList<int>();
5. // 添加元素
6. linkedList.AddLast(1); // 链表: 1
7. linkedList.AddLast(2); // 链表: 1 -> 2
9. // 插入元素
10. var node = linkedList.Find(1);
11. linkedList.AddAfter(node, 3); // 链表: 1 -> 3 -> 2
13. // 删除元素
14. linkedList.Remove(3); // 链表: 1 -> 2
16. // 遍历链表
17. foreach (int num in linkedList)
18. {
19.     Console.WriteLine(num);
20. }

复制代码

三、哈希表（Dictionary）

1.特点

• 键值对存储，通过哈希函数快速定位元素。
  
• 键唯一，值可重复。
  

2.优点

• 快速查找/插入/删除：匀称时间复杂度为O(1)，得当高频利用。
  
• 动态扩容：自动调解巨细，顺应数据厘革。
  

3.缺点

• 无序存储：元素序次不固定，大概影响遍历逻辑。
  
• 哈希辩说：非常情况下性能退化为O(n)，需公道计划哈希函数。
  
• 内存开销：需存储哈希桶和辩说办理机制。
  

4.代码示例

1. using System.Collections.Generic;
3. Dictionary<string, int> dict = new Dictionary<string, int>();
5. // 添加键值对
6. dict.Add("Alice", 25);
7. dict["Bob"] = 30; // 添加或更新
9. // 查找元素
10. if (dict.TryGetValue("Alice", out int age))
11. {
12.     Console.WriteLine($"Alice's age: {age}"); // 输出25
13. }
15. // 删除元素
16. dict.Remove("Bob");
18. // 遍历键值对
19. foreach (var kvp in dict)
20. {
21.     Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
22. }

复制代码

四、队列（Queue）

1.特点

• 先辈先出（FIFO），元素从队尾入队，从队头出队。
  

2.优点

• 高效序次处理：入队和出队时间复杂度均为O(1)。
  
• 动态巨细：无需预先分配空间。
  

3.缺点

• 随机访问受限：仅能访问队头和队尾元素。
  
• 线程安全需额外处理：多线程情况下需同步机制。
  

4.代码示例

1. using System.Collections.Generic;
3. Queue<string> queue = new Queue<string>();
5. // 入队
6. queue.Enqueue("Task1");
7. queue.Enqueue("Task2"); // 队列: Task1 -> Task2
9. // 出队
10. string firstTask = queue.Dequeue(); // 返回"Task1"，队列变为 [Task2]
12. // 查看队头元素
13. string peekTask = queue.Peek(); // 返回"Task2"
15. // 遍历队列
16. while (queue.Count > 0)
17. {
18.     Console.WriteLine(queue.Dequeue());
19. }

复制代码

五、 栈（Stack）

1.特点

• 后进先出（LIFO），元素从栈顶压入和弹出。
  

2.优点

• 高效利用：压栈和弹栈时间复杂度为O(1)。
  
• 支持递归：天然得当递归算法（如函数调用栈）。
  

3.缺点

• 随机访问受限：仅能访问栈顶元素。
  
• 容量有限：需注意栈溢出风险（可通过动态扩容缓解）。
  

4.代码示例

1. using System.Collections.Generic;
3. Stack<int> stack = new Stack<int>();
5. // 压栈
6. stack.Push(1);
7. stack.Push(2); // 栈: 2 -> 1
9. // 弹栈
10. int top = stack.Pop(); // 返回2，栈变为 [1]
12. // 查看栈顶元素
13. int peek = stack.Peek(); // 返回1
15. // 遍历栈
16. while (stack.Count > 0)
17. {
18.     Console.WriteLine(stack.Pop());
19. }

复制代码

总结与选择发起

• 数组：得当固定巨细、频仍随机访问的场景（如门天生绩）。
  
• 链表：得当动态聚集、频仍插入/删除的场景（如使命列表）。
  
• 哈希表：得当键值对存储、快速查找的场景（如缓存）。
  
• 队列：得当序次处理使命的场景（如使命调治）。
  
• 栈：得当逆序处理、递归或回溯的场景（如表达式求值）。
  

根据详细需求选择符合的数据布局，可显著提升步调效率和可读性。