十四、常用泛型数据结构

• 命名空间：System.Collections.Generic

1、List

• 泛型数组
• 声明：List list = new List();
• 使用上和 ArrayList 一样
  • 容量：list.Capacity
  • 长度：list.Count
  • 增加：list.Add(t)
    • list.AddRange(list2)
    • list.Insert(index, t)
  • 删除：list.Remove(t)
    • list.Remove(index)
    • list.Clear()
  • 修改：list[index] = t
  • 查询：list[index]
    • list.Contains(t)
    • list.IndexOf(t)
    • list.LastIndexOf(t)
• 遍历

// for 循环
for(int i = 0; i < list.Count; i++){
    Console.WriteLine(list[0]);
}

// foreach 循环
foreach(var item in list){
    Console.WriteLine(item);
}
1
2
3
4
5
6
7
8
9

2、Dictionary

• 字典，就是拥有泛型的 HashTable，也是基于键的哈希值组织起来的 键值对
• 声明：Dictionary dictionary= new Dictionary();
• 使用上和 HashTable 一样
  • 长度：dictionary.Count
  • 增加：dictionary.Add(k, v)
  • 删除：dictionary.Remove(k)
    • dictionary.Clear()
  • 修改：dictionary[k] = v
  • 查询：dictionary[k]；找不到k直接报错
    • dictionary.ContainsKey(k)
    • dictionary.ContainsValue(v)
• 遍历

// 遍历所有 键
foreach(var key in dictionary.Keys)
{
    Console.WriteLine(key);
    Console.WriteLine(dictionary[key]);
}

// 遍历所有 值
foreach(var value in dictionary.Values)
{
    Console.WriteLine(value);
}

// 遍历所有 键值对
foreach(KeyValuePair<K, V> item in dictionary)
{
    Console.WriteLine(item.Key);
    Console.WriteLine(item.Value);
}

// 迭代器遍历
IDictionaryEnumerator ite = dictionary.GetEnumerator();
while(ite.MoveNext()){
    Console.WriteLine(ite.Key);
    Console.WriteLine(ite.Value);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

3、顺序存储和链式存储

• 顺序存储：存储空间连续
  • 数组、Stack、Queue、List、ArrayList
• 链式存储：随机存储，但是每个存储单元都指向下一个存储单元
  • 单向链表、双向链表、循环链表

4、LinkedList

• 泛型双向链表
• 声明：LinkedList linkedList = new LinkedList();
  • 内部存的节点类：LinkedListNode
    • Next：下一个节点
    • Previous：上一个节点
• 使用
  • 增加
    • 尾部加：linkedList.AddLast(t)
    • 头部加：linkedFirst.AddRange(t)
    • 节点before之前添加t：linkedList.AddBefore(before, t)
    • 节点after之后添加t：linkedList.AddAfter(after, t)
  • 删除
    • 移除头结点：linkedList.RemoveFirst()
    • 移除尾节点：linkedList.RemoveLast()
    • 移除指定节点：linkedList.Remove(t)
    • 清空：linkedList.Clear()
  • 修改（节点.Value = t）：linkedList.First.Value = t
  • 查询
    • 头结点：linkedList.First
    • 尾结点：linkedList.Last
    • 指定值的节点：linkedList.Find(t)
    • 判断是否存在：linkedList.Contains(t)
• 遍历

// foreach 遍历
foreach(var value in linkedList)
{
    Console.WriteLine(value);
}

// 通过节点遍历 - 从头到尾
LinkedListNode<T> node = linkedList.First;
do {
    Console.WriteLine(node);
    node = node.Next;
} whiel(node != null);

// 通过节点遍历 - 从尾到头
LinkedListNode<T> node = linkedList.Last;
do {
    Console.WriteLine(node);
    node = node.Previous;
} whiel(node != null);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5、泛型栈和泛型队列

和普通的栈和队列用法完全一致，只是多了泛型而已

5.1、泛型栈 Stack

• 实质是 T[]，只是封装了特殊存储规则：先进后出
• 声明：Stack stack = new Stack();
• 长度：stack.Count
• 压栈：stack.Push(t)
• 出栈：stack.Pop()
• 清空：stack.Clear()
• 查栈顶元素：stack.Peek()
  • stack.Contains(t)
• 遍历如下（都是从栈顶到栈底）

// foreach 循环遍历(迭代器遍历)
forearch(var item in stack)
{
	Console.WriteLine(item);
}

// 转为 object[] 进行 for 遍历
object[] arr = stack.ToArray();
for(int i = 0; i < arr.Length; i++){
    Console.WriteLine(arr[i]);
}

// 循环弹栈
while(stack.Count > 0){
    object item = stack.Pop();
	Console.WriteLine(item);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5.2、泛型队列 Queue

• 实质是 T[]，只是封装了特殊存储规则：先进先出
• 声明：Queue que= new Queue();
• 长度：que.Count
• 入队：que.Enqueue(t)
• 出队：que.Dequeue()
• 清空：que.Clear()
• 查栈队列头部：que.Peek()
  • que.Contains(t)
• 遍历如下（都是从栈顶到栈底）

// foreach 循环遍历(迭代器遍历)
forearch(var item in que)
{
	Console.WriteLine(item);
}

// 转为 object[] 进行 for 遍历
object[] arr = que.ToArray();
for(int i = 0; i < arr.Length; i++){
    Console.WriteLine(arr[i]);
}

// 循环弹栈
while(que.Count > 0){
    object item = que.Dequeue();
	Console.WriteLine(item);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17