C#数据结构汇总

对C#涉及到的数据结构做了一下简单的汇总，若有遗漏，欢迎补充~~

还是以学习为目的，在此只是简单的介绍一下，希望对大家能有所帮助，能力有限为了不误导大家，不做详细深入的解析，还望见谅，非常欢迎大大们补充~~

1. 数组 Array

int[] array = new int[] ｛ ｝;
//  常用，长度固定，需要在初始化时指定长度

//  在内存中是连续的，遍历速度快，增加删除元素慢，即增删慢，改查快
//  增删元素，最好从数组最后一个或第一个位置操作，尽量避免从中间增删

优点：比如说数组在内存中是连续存储的，所以它的索引速度是非常的快，而且赋值与修改元素也很简单

缺点：在数组的两个数据间插入数据也是很麻烦的。还有我们在声明数组的时候，必须同时指明数组的长度，数组的长度过长，会造成内存浪费，数组和长度过短，会造成数据溢出的错误。这样如果在声明数组时我们并不清楚数组的长度，就变的很棘手了。

 void ArrayTest()
 ｛
 //数组比较常用
 int[] intArr01 = new int[];
 int[] intArr02 = new int[] ｛ , , , ,  ｝;
 int[] intArr03 = new int[] ｛ , , , ,  ｝;
 int[] intArr04 = ｛ , , , ,  ｝;
 //多维数组，声明赋值同上
 int[,] intArr05 = new int[, ];
 int[,,] intArr06 = new int[, , ];
 //交错数组，可以理解为元素是int[]的数组
 //与多维数组不同的是，子数组长度可以不同
 int[][] intArr07 = new int[][];
 intArr07[] = new int[];
 intArr07[] = new int[];
 ｝

2. 列表 List<T>

List<int> list = new List<int>();

//  常用，与数组互补，长度不固定

//  在内存中不连续，每个元素内存地址分别记录，遍历速度慢，增删速度快，方便从任意插入或删除元素

　1.需要在声明时通过泛型指定类型

    2.没有拆箱装箱操作，因此在大多数情况下List要比ArrayList效率高且类型安全

常用，不多说

3. 字典 Dictionary

Dictionary<int, string> dictionary = new Dictionary<int, string>();

//  常用，采用键值对的方式，key与value一一对应，key不能为空不能重复，value任意

//  长度不固定，根据Key值查找元素，速度较快，增删改查速度都较快，不足之处就是消耗内存较大

4. 动态数组 ArrayList

ArrayList arrayList = new ArrayList();

//  ArrayList类实际上是Array类的优化版本。与数组类似，长度不固定，会自动修改ArrayList长度

// ArrayList的元素都是object类型的，都可加入到ArrayList, 因此需要进行装箱和拆箱操作，内存分配的代价很高，而Array的元素通常是特定类型的。

//  就需要装箱、拆箱操作，（ int a = 10; object obj = (object)a; ），既不安全又耗性能，不推荐使用

C# 动态数组（ArrayList）

http://www.runoob.com/csharp/csharp-arraylist.html

5. 排序列表 SortedList

SortedList<int, string> sortedList = new SortedList<int, string>();

//  与字典相似，键值对的方式，根据key值自动进行排序

C# 排序列表（SortedList）

http://www.runoob.com/csharp/csharp-sortedlist.html

void SortedListTest()
 ｛
      SortedList<int, string>; sorteList = new SortedList<int, string>();
      sorteList.Add(, "四");
      sorteList.Add(, "一");
      sorteList.Add(, "三");
      sorteList.Add(, "二");
      sorteList.Add(, "五");
  foreach (var item in sorteList)
 ｛
         Debug.Log(item.Key + " " + item.Value);
     ｝
 ｝

6. 排序字典 SortedDictionary

SortedDictionary<int, string> sortedDictionary = new SortedDictionary<int, string>();

//  与SortedList无比相似

异同对比：  C# Dictionary, SortedDictionary, SortedList

https://blog.csdn.net/ma_jiang/article/details/78600043

7. 双向链表 LinkedList

LinkedList<int> linkedList = new LinkedList<int>();

//  元素指向前后元素，只能从第一个依次访问

//  插入新元素，只需修改插入位置的前后元素引用即可

void LinkedListTest()
｛
        LinkedList<int> linkedList = new LinkedList<int>();
        //定义第一个元素，返回节点
        LinkedListNode<int> firstNode = linkedList.AddFirst();
        //定义最后一个元素，返回节点
        LinkedListNode<int> lastNode = linkedList.AddLast();
        //在指定节点之后插入元素
        linkedList.AddAfter(firstNode, );
        //在指定节点之前插入元素
        linkedList.AddBefore(lastNode, );
        //移除元素
        linkedList.Remove();
        linkedList.RemoveFirst();
        linkedList.RemoveLast();
        //更多方法可查看定义，在此不一一列举
｝                                

8. 哈希表 Hashtable

Hashtable hashtable = new Hashtable();

//  与字典类似，采用键值对的方式，使用哈希算法进行无序存储

//  key、value均为object类型，存储是需要类型转换

void HashtableTest()
｛
        Hashtable hashtable = new Hashtable();
        //hashtable.Add(object key, object value);
        hashtable.Add(, "Test01");
        hashtable.Add("", "Test02");
        hashtable.Remove();
        int count = hashtable.Count;
        hashtable.Clear();
        //更多方法可查看定义
｝

C# 哈希表（Hashtable）

http://www.runoob.com/csharp/csharp-hashtable.html

9. 堆栈 Stack

先进后出原则，最先插入的元素最后被访问，最后被插入的元素最先被访问

Stack stack = new Stack();

//先进后出，元素为object

void StackTest()
｛
        Stack stack = new Stack();
        //添加元素
        stack.Push();
        //获取并移除元素，取最后一位添加的元素
        object obj = stack.Pop();
        //获取但不移除元素，取最后添加的元素
        obj = stack.Peek();
｝

C# 堆栈（Stack）

http://www.runoob.com/csharp/csharp-stack.html

10. 队列 Queue

先进先出的原则(类似于管道)，最先插入的元素最先被访问，最后插入的元素最后被访问

Queue queue = new Queue();

//  先进先出，与Stack相反，元素为object

void QueueTest()
｛
        //用法与Stack类似
        Queue queue = new Queue();
        //添加元素
        queue.Enqueue();
        //获取并移除元素，取最先添加的元素
        object obj = queue.Dequeue();
        //获取但不移除元素，取最先添加的元素
        obj = queue.Peek();
｝

C# 队列（Queue）

http://www.runoob.com/csharp/csharp-queue.html

栈(stack)与队列(Queue)的相同点：

1.都是线性结构。

2.插入操作都是限定在表尾进行。

3.都可以通过顺序结构和链式结构实现。、

栈与队列的不同点：

1.删除数据元素的位置不同，栈的删除操作在表尾进行，队列的删除操作在表头进行。

2.顺序栈能够实现多栈空间共享，而顺序队列不能

3.遍历数据速度不同。

栈只能从头部取数据，也就最先放入的需要遍历整个栈最后才能取出来，而且在遍历数据的时候还得为数据 开辟临时空间，保持数据在遍历前的一致性。

队列则不同，它基于地址指针进行遍历，而且可以从头或尾部开始遍历，但不能同时遍历，无需开辟临时空间，因为在遍历的过程中不影像数据结构，速度要快的多

C#中的哈希表和字典的区别

工作以后就会发现，项目中有时候用到哈希表，有时候用到字典表，这两个都是索引、值得表现形式，那么它们的区别在哪里？

以下是笔者总结的区别：

1，单线程里面用字典，多线程里面用哈希表。

2，字典的排序就是按照插入的顺序来的，而哈希表未必是。

3，哈希表允许单线程写入，多线程读取。

4，哈希表最大的优势在于其索引方式，它是经过散列处理过的，在数据量大的时候尤其如此。

C#中为什么字典的查询速度比List快

List实际上是顺序存储的,由于存储结构是顺序的,所以查询起来就很费劲. ​ 但是字典这种数据类型是为了查询做了专门的优化,目的在于快速查找. ​ 所以效率要比List高很多