【从零开始入门unity游戏开发之——C#篇32】C#其他不常用的泛型数据结构类、顺序存储和链式存储

文章目录

• 一、其他不常用的泛型数据结构类（了解即可，不常用）
• • 1、LinkedList<T>双向链表
  • 2、**HashSet<T>**
  • [3、**SortedList<TKey, TValue>**](#3、SortedList<TKey, TValue>)
  • 4、**SortedSet<T>**
  • 5、总结
• 二、顺序存储和链式存储
• • [1、顺序存储（Array-based Storage）](#1、顺序存储（Array-based Storage）)
  • • [1.1. **数组（Array）**：](#1.1. 数组（Array）：)
    • [1.2. **List<T>**：](#1.2. List<T>：)
    • [1.3. **String**：](#1.3. String：)
    • [1.4. **Dictionary<TKey, TValue>**（顺序存储和哈希表结合）：](#1.4. Dictionary<TKey, TValue>（顺序存储和哈希表结合）：)
  • [2、链式存储（Linked Storage）](#2、链式存储（Linked Storage）)
  • • [2.1. **LinkedList<T>**：](#2.1. LinkedList<T>：)
    • [2.2. **Queue<T>（基于链式存储）**：](#2.2. Queue<T>（基于链式存储）：)
    • [2.3. **Stack<T>（基于链式存储）**：](#2.3. Stack<T>（基于链式存储）：)
• 专栏推荐
• 完结

一、其他不常用的泛型数据结构类（了解即可，不常用）

1、LinkedList双向链表

LinkedList<T> 是一种双向链表，支持高效的插入和删除操作，但随机访问元素的性能较差。

• 常用方法：
  • AddFirst(T item)：将元素添加到链表的开头。
  • AddLast(T item)：将元素添加到链表的末尾。
  • Remove(T item)：删除链表中的指定元素。
  • Find(T item)：查找指定元素在链表中的位置。

LinkedList<string> linkedList = new LinkedList<string>();
linkedList.AddLast("First");
linkedList.AddFirst("Zero");
linkedList.AddLast("Second");

foreach (var item in linkedList)
{
    Console.WriteLine(item);
}
// 输出：
// Zero
// First
// Second

2、HashSet

HashSet<T> 是一个不允许重复元素的集合，它提供快速查找、插入和删除操作。它不保证元素的顺序，因此如果需要按照特定顺序存储元素，可以使用 SortedSet<T>。

• 常用方法 ：
  • Add(T item)：向集合添加元素，如果元素已存在，则不添加。
  • Remove(T item)：从集合中删除指定的元素。
  • Contains(T item)：检查集合中是否包含指定的元素。
  • Count：获取集合中元素的数量。

HashSet<int> set = new HashSet<int> { 1, 2, 3, 4 };
set.Add(5);
set.Add(2);  // 不会添加，因为 2 已经存在
Console.WriteLine(set.Count); // 输出 5

3、SortedList<TKey, TValue>

SortedList<TKey, TValue> 是一个键值对集合，键是排序的，提供按键的升序访问。其底层实现类似于一个有序的字典。

• 常用方法 ：
  • Add(TKey key, TValue value)：添加键值对。
  • Remove(TKey key)：删除指定键的键值对。
  • ContainsKey(TKey key)：检查字典中是否包含指定的键。
  • Keys 和 Values：获取按排序顺序排列的所有键和值。

SortedList<int, string> sortedList = new SortedList<int, string>();
sortedList.Add(3, "Three");
sortedList.Add(1, "One");
sortedList.Add(2, "Two");

foreach (var kvp in sortedList)
{
    Console.WriteLine($"{kvp.Key}: {kvp.Value}");
}
// 输出：
// 1: One
// 2: Two
// 3: Three

4、SortedSet

SortedSet<T> 是一个不允许重复元素的集合，但与 HashSet<T> 不同，SortedSet<T> 保证元素是排序的（默认升序）。适用于需要自动排序的场景。

• 常用方法 ：
  • Add(T item)：添加元素，如果元素已存在则不添加。
  • Remove(T item)：删除指定元素。
  • Contains(T item)：检查集合中是否包含指定的元素。
  • Count：获取集合中元素的数量。

SortedSet<int> sortedSet = new SortedSet<int> { 3, 1, 4, 2 };
sortedSet.Add(5);  // 添加 5
Console.WriteLine(string.Join(", ", sortedSet));  // 输出 1, 2, 3, 4, 5

5、总结

这些泛型数据结构类为 C# 提供了丰富的集合操作，能够满足大多数常见的数据存储和操作需求。每种数据结构都有其独特的特点和使用场景，可以根据具体需求选择合适的数据结构。

---

二、顺序存储和链式存储

• 顺序存储适用于查找和修改操作较频繁的情况。
• 链式存储适用于插入和删除操作较频繁的场景，尤其是在频繁插入或删除的情况下，链表表现更好。

1、顺序存储（Array-based Storage）

顺序存储是指数据元素在内存中是连续存放的，这样可以通过索引直接访问数据，因此顺序存储对于查找和修改操作非常高效。C# 中顺序存储的主要数据结构有：

1.1. 数组（Array）：

• 数组是最典型的顺序存储结构，元素在内存中是连续的。
• 优点：查找和修改操作非常高效。
• 缺点：插入和删除操作效率较低，尤其是在数组中间插入或删除时需要移动大量元素。

int[] arr = {1, 2, 3, 4, 5};  // 顺序存储

1.2. List：

• List<T> 是基于数组实现的泛型集合类，存储的数据是顺序存储的。
• 优点：通过动态数组实现，当元素超出当前数组容量时，会进行扩容。
• 缺点：插入和删除操作（尤其是在列表的中间位置）可能需要移动元素，时间复杂度为 O(n)。

List<int> list = new List<int> { 1, 2, 3, 4, 5 };  // 顺序存储

1.3. String：

• 字符串在 C# 中是不可变的，实际上它内部是一个字符数组（char[]），因此也可以看作是顺序存储。
• 优点：支持高效的字符查找和修改。
• 缺点：字符串是不可变的，所以修改时需要生成新字符串，可能会涉及内存重新分配。

string str = "Hello";  // 顺序存储

1.4. Dictionary<TKey, TValue>（顺序存储和哈希表结合）：

• Dictionary<TKey, TValue> 是基于哈希表实现的，但它在底层维护一个数组来存储元素。
• 优点：查找、插入、删除操作非常高效。
• 缺点：哈希冲突可能影响性能，尤其是在哈希函数不够理想时。

Dictionary<int, string> dict = new Dictionary<int, string>();
dict.Add(1, "one");
dict.Add(2, "two");  // 顺序存储和哈希表结合

2、链式存储（Linked Storage）

链式存储是指数据元素在内存中不需要连续存放，而是通过指针（或引用）将元素连接起来。这使得在插入和删除时更为高效，但在查找时需要遍历链表，因此查找操作的时间复杂度较高。C# 中链式存储的常见数据结构有：

2.1. LinkedList：

• LinkedList<T> 是 C# 中的双向链表实现，每个元素（节点）都包含指向前一个节点和下一个节点的引用。
• 优点：插入和删除操作效率高，特别是在链表的头部或中间插入/删除时。
• 缺点：查找元素时需要遍历链表。

LinkedList<int> linkedList = new LinkedList<int>();
linkedList.AddLast(1);  // 链式存储
linkedList.AddLast(2);

2.2. Queue（基于链式存储）：

• Queue<T> 是一种先进先出（FIFO）的队列数据结构，C# 中的 Queue<T> 使用链表（或环形缓冲区）实现。
• 优点：对于入队和出队操作效率高。
• 缺点：在队列中间插入或删除操作的复杂度较高，因为它是一个 FIFO 结构。

Queue<int> queue = new Queue<int>();
queue.Enqueue(1);  // 链式存储
queue.Enqueue(2);

2.3. Stack（基于链式存储）：

• Stack<T> 是一种后进先出（LIFO）的栈数据结构，C# 中的 Stack<T> 实际上是基于链表实现的。
• 优点：对于推入和弹出操作效率高。
• 缺点：和队列一样，栈是基于链式存储的，因此访问栈中间的元素比较慢。

Stack<int> stack = new Stack<int>();
stack.Push(1);  // 链式存储
stack.Push(2);

---

专栏推荐

地址
【从零开始入门unity游戏开发之------C#篇】
【从零开始入门unity游戏开发之------unity篇】
【制作100个Unity游戏】
【推荐100个unity插件】
【实现100个unity特效】
【unity框架开发】

完结

赠人玫瑰，手有余香！如果文章内容对你有所帮助，请不要吝啬你的点赞评论和关注，你的每一次支持都是我不断创作的最大动力。当然如果你发现了文章中存在错误或者有更好的解决方法，也欢迎评论私信告诉我哦！

好了，我是向宇，https://xiangyu.blog.csdn.net

一位在小公司默默奋斗的开发者，闲暇之余，边学习边记录分享，站在巨人的肩膀上，通过学习前辈们的经验总是会给我很多帮助和启发！如果你遇到任何问题，也欢迎你评论私信或者加群找我， 虽然有些问题我也不一定会，但是我会查阅各方资料，争取给出最好的建议，希望可以帮助更多想学编程的人，共勉~