C#集合

 

集合（Collection）类是专门用于数据存储和检索的类，集合也可以称为数据结构；

数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集       合

非关联性集合就是不用key操作的一些集合类，通常我们可以用元素本身或者下标来操作。关 联性集合类即我们常说的键值对集合，允许我们通过Key来访问和维护集合。

非泛型集合（Collection）

ArrayList集合：

ArrayList是基于数组实现的，是一个动态数组，其容量能自动 增长

ArrayList的命名空间System.Collections

HashTable 关联性集合，键值对集合

Queue 队列，先进先出

SortedList 自动排序的关联性集合，键值对集合。

Stack 栈，先进后出

 

泛型集合(Generic Collection)

List<T> 索引列表，动态数组

LinkedList<T>链表，双向链表

Queue<T>队列，先进先出

Stack<T>栈，先进后出

Dictionary<TKey,TValue>字典，键值对集合，内部用哈希表来存储数据，所以是无序的；

SortedDictionary<TKey,TValue>键值对集合，内部是用二叉树来存储数据，按键来排序；

SortedList<TKey,TValue>键值对集合，内部结构使用数组来存储的；

 

List<T>索引列表，通过下标访问元素，动态数组

List<int> arr=new List<int>();//容量=0，count=0;

   List<string> arr=new List<string>(10);// 容 量 =10,count=0;

   List<bool> arr=new List<bool>(new bool[10]);//容量=10，count=10

方法：

 Add():添加元素

IndexOf()：搜索，返回第一个匹配项索引

LastIndexOf()：搜索，返回最后一个匹配项索引

Sort()：排序

Reverse()：倒序

Contains()：判断是否存在

Insert()：插入

Remove()：删除最后一个元素

RemoveAt() ：删除制定指定位置元素

Find()   ：搜索，并返回第一个匹配项

Dictionary字典

关联性集合，键值对集合，通过键访问值，每个元素都是一个键值对； 查字典：搜索改字的页码，根据页码找到该字解释；

苹果   大厦

京基100   水果

【(a)(b)(c)(d)】

字典里面的每个元素都是一个键值对键值对：键-值

字典集合【（1001，“苹果”）,(1003,"西瓜")】

Dictionary的定义格式：

Dictionary<键类型，值类型> arr=new Dictionary<键类型，值类型

>();

属性：

Count元素个数

Keys:返回键的集合

Values:返回值的集合索引器：

字典对象[键]返回值方法：

Add(键，值)；

Clear()清空所有元素

ContainsKey(Tkey key)检索键是否存在，存在返回true，反之false ContainsValue(TValue value)检索值是否存在，存在返回tue,反之false

Remove(Tkey key)根据键删除元素；

访问元素方式：

int ID=1001;

for (var i = 0; i < arr.Count; i++) { 

  Console.WriteLine(arr[ID + i]);

}

//foreach ...in:访问键

foreach (int key in arr.Keys) {

  Console.WriteLine("键：" + key);

}

//访问值

foreach (string value in arr.Values)

{

  Console.WriteLine("值：" + value);

}

//访问键值对

foreach (KeyValuePair<int,string> obj in arr)

{

  Console.WriteLine("键：{0},值：{1}",obj.Key,obj.Value);

}

foreach (var obj in arr)

{

  Console.WriteLine("键：{0},值：{1}", obj.Key, obj.Value);

}

注意：键不可以重复，键不可以为null;

Queue队列：先进先出属性：

Count返回元素的个数方法：

Enqueue(T value)添加元素到集合的尾部

Dequeue()删除并返回集合第一个元素

Peek()返回集合第一个元素

Contains(T value)检索元素是否存在，返回true，否则false

ToArray()返回一个相同类型的一维数组

TrimExcess()缩小容量为实际元素个数的大小，减少内存占用

 

Stack栈：先进后出，后进先出

属性：Count返回元素的个数方法：

Push(T value)添加元素到集合的首位

Pop()删除并返回集合第一个元素

Peek()返回集合第一个元素

Contains(T value)检索元素是否存在，返回true，否则false

ToArray()返回一个相同类型的一维数组

TrimExcess()缩小容量为实际元素个数的大小，减少内存占用

 

LinkedList链表:双向链表

First:保存第一个节点

Last:保存最后一个节点[nodeA,nodeB,nodeC,nodeD] nodeA:value="",up=null;next=nodeC;

//nodeB:value="",up=nodeA,next=nodeC; nodeC:value="",up=nodeA,next=nodeD;

 

LinkedList里面每个元素都是一个LinkedListNode LinkedListNode:

List:返回该节点所在的集合

Next:返回下一个节点

Previous:返回上一个节点

Value:返回存储数据属性：

Count返回元素个数

First返回链表中第一个节点

Last返回链表中最后一个节点方法：

AddFirst(T value)在第一个位置添加一个节点，并把value保存到节点中

AddLast(T value)在尾部添加一个节点，并把value存储到该节点中Remove(T value)删除查找到的第一个元素

RemoveFirst()删除第一个节点

RemoveLast()删除最后一个节点

Contains(T value)检索value是否存在，存在返回true，否则返回false

Find(T value)返回第一个检索到存储了value的节点FindLast(T value)返回最后一个检索到存储了value的节点

AddAfter(LinkedListNode node,LinkedListNode newnode) 在node后面添加一个newNode;

AddBefore(LinkedListNode node,LinkedListNode newnode) 在node前面添加一个newNode

AddFirst(node)在第一个位置添加一个节点

AddLast(node)在最后一个位置添加一个节点

Rmove(node)删除指定节点

 

SortedDictionay<key,value>

有序的键值对集合，跟字典非常相似； SortedList<key,value>

有序的键值对集合，内部存储用数组存储SortedSet<T>

有序集合，非关联性集合

时间复杂度

时间复杂度是一个函数，它定量描述了该算法的运行时间。

常见的时间复杂度有以下几种。

1，log(2)n，n，n log(2)n ，n的平方，n的三次方，2的n次方，n!

1指的是常数。即，无论算法的输入n是多大，都不会影响到算法的运行 时间。这种是最优的算法。而n！（阶乘）是非常差的算法。当n变大 时，算法所需的时间是不可接受的。

用通俗的话来描述，我们假设n=1所需的时间为1秒。那么当n = 10，

000时。

O（1）的算法需要1秒执行完毕。

O（n）的算法需要10，000秒 ≈ 2.7小时 执行完毕。

O（n2）的算法需要100，000，000秒 ≈ 3.17年 执行完毕。

O（n！）的算法需要XXXXXXXX(系统的计算器已经算不出来了)。可见算法的时间复杂度影响有多大。

所以O（1）和O（n）差了2.7小时，区别显而易见。

集合	顺序排 列	连顺 存储	直接访问方式	访问时间	操作时间	备注
Dictionary		是	Key	Key: O(1)	O(1)	访问性能最 快，不支持排 序
SortedDinctionar y	顺序排列	否	Key	Key: O(log n)	O(log n)	快速访问和支持排序的折衷
SortedList	顺序排列	是	Key	Key: O(log n)	O(n)	和SortedDictio nary相似，只是内部用数据

						替代树作为存 储结构。
List	使用者可以精确控制元素的 位置	是	Index	Index: O(1) Value: O(n)	O(n)	最适合需要直接访问每一个元素的少量集合。
LinkedList	使用者可以精确控制元素的位置	否	不支持	Value: O(n)	O(1)	最适合不需要直接访问单个元素，但是在集合中添加/移除非常频繁的 场景。
HashSet	不支持	是	Key	Key: O(1)	O(1)	能保持元素唯 一性的集合。 不支持排序
SortedSet	顺序排列	否	Key	Key: O(log n)	O(log n)	能保持元素唯一性并且支持 排序。
Stack	LIFO	是	只能获取顶部元素	Top: O(1)	O(1)
Queue	FIFO	是	只能获取顶部元素	Front: O( 1)	O(1

备注：LIFO last in first out; FIFO:first in fisrt out

集合有关网址：https://www.cnblogs.com/jesse2013/p/CollectionsInCSharp.html