C# 数据结构和特殊类型及适用场景

int[] arr = new int[5] { 1, 2, 3, 4, 5 };
// 【查】通过索引访问 O(1)
int val = arr[0]; 
// 【改】直接赋值
arr[0] = 10;
// 【增/删】数组本身不支持。需借助 Array.Resize 或 LINQ 创建新数组
// 模拟“添加”：创建更大的数组并复制
Array.Resize(ref arr, arr.Length + 1);
arr[arr.Length - 1] = 6;
// 模拟“删除”：通常使用 LINQ 过滤生成新数组
arr = arr.Where(x => x != 3).ToArray();

List<string> list = new List<string> { "A", "B", "C" };
// 【增】
list.Add("D");           // 尾部添加 O(1)
list.Insert(0, "Start"); // 指定位置插入 O(n)
// 【查】
string item = list[0];   // 索引访问 O(1)
bool exists = list.Contains("B"); // 线性查找 O(n)
string found = list.Find(x => x.StartsWith("A")); // 条件查找
// 【改】
list[0] = "Modified";    // 索引赋值
// 若元素是引用类型，可直接修改属性: list[0].Name = "New";
// 【删】
list.Remove("B");        // 删除第一个匹配项 O(n)
list.RemoveAt(0);        // 按索引删除 O(n)
list.RemoveAll(x => x.Length < 2); // 批量删除

using System.Collections;
ArrayList arrayList = new ArrayList();
// 【增】
arrayList.Add(1);       // 装箱
arrayList.Add("Text");
// 【查】
int first = (int)arrayList[0]; // 拆箱，需强制转换
// 【改】
arrayList[0] = 100;
// 【删】
arrayList.Remove(100);
arrayList.RemoveAt(0);

LinkedList<int> linkedList = new LinkedList<int>(new[] { 1, 2, 3 });
// 【增】
linkedList.AddFirst(0);
linkedList.AddLast(4);
LinkedListNode<int> node = linkedList.Find(2);
if (node != null) linkedList.AddAfter(node, 5); // 在节点后插入 O(1)
// 【查】
// 不支持索引 linkedList[0] 是错误的
bool exists = linkedList.Contains(2); // O(n)
LinkedListNode<int> foundNode = linkedList.Find(2); // O(n)
// 【改】
if (foundNode != null) foundNode.Value = 20;
// 【删】
linkedList.Remove(20);      // 按值删除 O(n)
linkedList.RemoveFirst();   // O(1)
linkedList.RemoveLast();    // O(1)
if (node != null) linkedList.Remove(node); // 按节点删除 O(1)

Stack<string> stack = new Stack<string>();
// 【增】
stack.Push("A");
stack.Push("B");
// 【查】仅能查看栈顶
string top = stack.Peek(); // 不移除
// 【删】仅能移除栈顶
string popped = stack.Pop();
// 注意：Stack 没有 Indexer，不能 stack[0]，也不能直接修改中间元素

Queue<string> queue = new Queue<string>();
// 【增】
queue.Enqueue("A");
queue.Enqueue("B");
// 【查】仅能查看队头
string head = queue.Peek();
// 【删】仅能移除队头
string dequeued = queue.Dequeue();
// 注意：Queue 同样不支持随机访问或修改中间元素

Dictionary<int, string> dict = new Dictionary<int, string>();
// 【增】
dict.Add(1, "One");
dict[2] = "Two"; // 若 Key 存在则覆盖，不存在则添加
// 【查】
string val = dict[1];          // 若 Key 不存在抛异常
bool hasKey = dict.ContainsKey(1); // 推荐先检查
bool tryGet = dict.TryGetValue(3, out string result); // 安全获取
// 【改】
dict[1] = "Updated One"; // 直接赋值覆盖
// 【删】
dict.Remove(1);

HashSet<string> set = new HashSet<string>();
// 【增】
set.Add("A"); // 返回 bool，若已存在则返回 false 且不添加
// 【查】
bool exists = set.Contains("A"); // O(1)
// 【改】 HashSet 不支持直接“修改”元素。
// 若要修改，需先 Remove 再 Add
set.Remove("A");
set.Add("B");
// 【删】
set.Remove("A");
set.Clear();

// SortedDictionary
SortedDictionary<int, string> sortedDict = new SortedDictionary<int, string>();
sortedDict.Add(3, "C");
sortedDict.Add(1, "A");
// 遍历按键排序: 1->A, 3->C
// 增删改查方法与 Dictionary 类似，但复杂度为 O(log n)
// SortedSet
SortedSet<int> sortedSet = new SortedSet<int>();
sortedSet.Add(5);
sortedSet.Add(1);
// 自动排序: 1, 5
// 支持范围操作
var subset = sortedSet.GetViewBetween(1, 10); 

using System.Collections.Concurrent;
ConcurrentDictionary<int, string> concDict = new ConcurrentDictionary<int, string>();
// 【增/改】原子操作
concDict.TryAdd(1, "A"); // 仅当 Key 不存在时添加
concDict[1] = "B";       // 直接赋值（线程安全但不保证原子性逻辑）
concDict.AddOrUpdate(1, "New", (key, oldVal) => "Updated"); // 原子性添加或更新
// 【查】
bool success = concDict.TryGetValue(1, out string val);
// 【删】
concDict.TryRemove(1, out string removedVal);

int[] array = { 1, 2, 3, 4, 5 };
Span<int> span = array.AsSpan();
// 【查】
int first = span[0];
Span<int> subSpan = span.Slice(1, 2); // 获取子视图 [2, 3]
// 【改】
span[0] = 10; // 直接修改底层数组
// 【增/删】不支持。Span 长度固定。
// 若需“扩容”，必须分配新的数组或 Span。

Memory<int> memory = new Memory<int>(new int[] { 1, 2, 3 });
// 【查】
int val = memory.Span[0]; // 通过 .Span 属性访问
// 【改】
memory.Span[0] = 10;
// 【增/删】不支持。同 Span，需重新分配内存。

// ValueTuple (推荐，值类型，性能高)
var person = (Id: 1, Name: "Alice");
// 【改】无法直接修改字段，需重新赋值
person = person with { Name = "Bob" }; // C# 10+ 支持 with 表达式用于元组
// 或者
person = (1, "Bob");
// 【查】
string name = person.Name;

public record Person(int Id, string Name);
var p1 = new Person(1, "Alice");
// 【改】使用 with 表达式创建修改后的副本（非破坏性更新）
var p2 = p1 with { Name = "Bob" };
// 【查】
Console.WriteLine(p2.Name);
// 【增/删】不适用，Record 是单个对象，不是集合。

IEnumerable<int> enums = new List<int> { 1, 2, 3 };
// 【查】仅支持 foreach 或 LINQ
foreach (var item in enums) { }
// 无 Add, Remove, Indexer

ICollection<string> coll = new List<string>();
coll.Add("A");      // 【增】
coll.Remove("A");   // 【删】
coll.Clear();       // 【删所有】
int count = coll.Count; // 【查数量】
// 不支持索引访问 coll[0] 是错误的

IList<string> listInterface = new List<string>();
listInterface.Add("A");     // 【增】
listInterface[0] = "B";     // 【改/查】索引器
listInterface.RemoveAt(0);  // 【删】
// 包含 Insert, IndexOf 等方法

IDictionary<int, string> dictInterface = new Dictionary<int, string>();
dictInterface.Add(1, "A");      // 【增】
dictInterface[1] = "B";         // 【改】
string val = dictInterface[1];  // 【查】
dictInterface.Remove(1);        // 【删】