数据结构

一、存储地址
链式存储：储存单位的地址不一定是连续的
顺序存储：储存单位的地址必须是连续的

二、存储空间利用率与分配
链式存储：利用率低，动态分配
顺序存储：利用率高，静态分配

三、修改内容速度
链式存储：修改速度快
顺序存储：修改速度慢

三、查询内容速度
链式存储：查询速度慢
顺序存储：查询速度快

Stack(堆栈)

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
private  void StackTest()
    {
        //stack 栈是一种先进后出的数据结构
        //比喻成汉诺塔叠块 最先放入的只能最后拿出来
        Stack<int> stack = new Stack<int>();

        #region 增 O(1) push 入栈 
        stack.Push(1);
        stack.Push(2);
        #endregion

        #region 删 O(1) pop出栈  每次出最上面的一个
        stack.Pop();
        #endregion

        #region 改
        //清空 无法插入
        stack.Clear();
        #endregion

        #region 查
        //查 O(1) peek 只查看不出栈 O(1)
        stack.Peek();
        //查 O(n)
        stack.Contains(111);
        #endregion

        #region 遍历
        //遍历从栈顶开始遍历也就是压入的最后一个元素开始  foreach x.ToArray
        foreach (var item in stack)
        {

        }
        var nums = stack.ToArray();
        for (int i = 0; i < nums.Length; i++)
        {

        }
        //循环弹栈
        while (stack.Count > 0)
        {
            stack.Pop();
        } 
        #endregion
    }

Queue(队列)

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
27
28
29
30
31
32
33
34
35
36
37
38
private void QueueTest()
    {
        //队列是一种先进先出的数据结构
        //比喻成  人排队 先到先得( 先出来 )
        Queue<int> queue = new Queue<int>();

        #region 增 O(1)
        queue.Enqueue(1);
        queue.Enqueue(2);
        #endregion

        #region 删除 O(1)
        queue.Dequeue();
        #endregion

        #region 改
        queue.Clear();
        #endregion

        #region 查
        queue.Peek();//O(1) 查看最上面一个 不出队列

        queue.Contains(11); //O(n) 
        #endregion

        #region 遍历
        //遍历的第一个元素就是第一个压入的元素
        foreach (var item in queue)
        {

        }
        var nums = queue.ToArray();
        for (int i = 0; i < nums.Length; i++)
        {

        }
        #endregion
    }

LinkedList(双链表)

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
27
28
29
private void LinkedListTest()
{
    //双向链表  链式存贮  修改快  查询慢 读少写多
    LinkedList<int> linkedlist = new LinkedList<int>();

    #region 增  O(1)
    linkedlist.AddFirst(1);
    linkedlist.AddLast(10);
    linkedlist.AddAfter(linkedlist.First,5); //在第一个节点后面插入一个10
    #endregion

    #region 删除 O(1)
    linkedlist.RemoveFirst();
    linkedlist.RemoveLast();
    linkedlist.Remove(5);  //移除值是O(n)
    linkedlist.Remove(linkedlist.First);//移除节点是 O(1)
    #endregion

    #region 改
    linkedlist.First.Value = 100; //直接改值
    #endregion

    #region 查
    var first = linkedlist.First;
    var last = linkedlist.Last;
    linkedlist.Find(10);  //O(n)
    linkedlist.Contains(10);//O(n)
    #endregion
}