1.List

1.List的本质

List是一个C#为我们封装好的类

它的本质是一个可变类型的泛型数组

List类帮助我们实现了很多方法

比如泛型数组的增删查改

2.申明

需要引用命名空间

using System.Collections.Generic

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

List<string> list2 = new List<string>();

List<bool> list3 = new List<bool>();

3.增删查改

1.增

            //单个加
            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Add(4);
            list2.Add("123");
 
            //范围加
            List<string> listStr = new List<string>();
            listStr.Add("123");
            list2.AddRange(listStr);
 
            //插入
            list.Insert(0, 999);
            Console.WriteLine(list[0]);

2.删

            //1.移除指定元素
            list.Remove(1);
 
            //2.移除指定位置的元素
            list.RemoveAt(0);
 
            //3.清空
            list.Clear();
 
            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Add(4);

3.查

            //1.得到指定位置的元素
            Console.WriteLine(list[0]);
 
            //2.查看元素是否存在
            if (list.Contains(1))
            {
                Console.WriteLine("存在元素1");
            }
 
            //3.正向查找元素位置
            //  找到就返回位置 找不到 就返回-1
            int index = list.IndexOf(5);
            Console.WriteLine(index);
 
            //4.反向查找元素位置
            //  找到就返回位置 找不到 就返回-1
            index = list.LastIndexOf(2);
            Console.WriteLine(index);

4.改

            Console.WriteLine(list[0]);
            list[0] = 99;
            Console.WriteLine(list[0]);

5.遍历

            //长度
            Console.WriteLine(list.Count);
            //容量
            //避免产生垃圾
            Console.WriteLine(list.Capacity);
 
            for (int i = 0; i < list.Count; i++)
            {
                Console.Write(" " + list[i]);
            }
            Console.WriteLine();
            foreach (int item in list)
            {
                Console.Write(" " + item);
            }

2.Dictionary

1.Dictionary的本质

可以将Dictionary理解为拥有泛型的Hashtable

它也是基于键的哈希代码组织起来的键/值对

键值对类型从Hashtable的object变为了可以自己制定的泛型

2.申明

需要引用命名空间

using System.Collections.Generic

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

3.增删查改

1.增

            //值可以相同，键不能
            dictionary.Add(1, "111");
            dictionary.Add(2, "222");
            dictionary.Add(3, "333");

2.删

            //1.只能通过键去删除
            //  删除不存在键 没反应
            dictionary.Remove(1);
 
            //2.清空
            dictionary.Clear();
 
            dictionary.Add(1, "111");
            dictionary.Add(2, "222");
            dictionary.Add(3, "333");

3.查

            //1.通过键查看值
            //  找不到直接报错
            Console.WriteLine(dictionary[1]);
            Console.WriteLine(dictionary[2]);
 
            //2.查看是否存在
            //  根据键检测
            if (dictionary.ContainsKey(1))
            {
                Console.WriteLine("存在键为1的键值对");
            }
 
            //  根据值检测
            if (dictionary.ContainsValue("111"))
            {
                Console.WriteLine("存在值为111的键值对");
            }

4.改

            Console.WriteLine(dictionary[1]);
            dictionary[1] = "555";
            Console.WriteLine(dictionary[1]);

5.遍历

            //长度
            Console.WriteLine(dictionary.Count);
 
            //1.遍历所有键
            foreach (int item in dictionary.Keys)
            {
                Console.WriteLine(item);
                Console.WriteLine(dictionary[item]);
            }
            Console.WriteLine();
            //2.遍历所有值
            foreach (string item in dictionary.Values)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine();
 
            //3.键值对一起遍历
            foreach (KeyValuePair<int,string> item in dictionary)
            {
                Console.WriteLine("键：" + item.Key + " 值" + item.Value);
            }

3.顺序存储和链式存储

1.数据结构

数据结构

数据结构是计算机存储、组织数据的方式（规则）

数据结构是指相互之间存在一种或多种特定关系的数据元素的集合

比如自定义的一个类也可以称为一种数据结构自己定义的数据组合规则

不要把数据结构想的太复杂

简单点理解，就是人定义的存储数据和表示数据之间关系的规则而已

常用的数据结构（前辈总结和制定的一些经典规则）

数组、栈、队列、链表、树、图、堆、散列表

2.线性表

线性表是一种数据结构，是由n个具有相同特性的数据元素的有限序列

比如数组、ArrayList、Stack、Queue、链表等等

顺序存储和链式存储是数据结构中两种存储结构

3.顺序存储

数组、Stack、Queue、List、ArrayList —— 顺序存储

只是数组、Stack、Queue的组织规则不同而已

顺序存储：用一组地址连续的存储单元依次存储线性表的各个数据元素

4.链式存储

单向链表、双向链表、循环链表 ——链式存储

链式存储（链接存储）：用一组任意的存储单元存储线性表中的各个数据元素

            //测试
            LinkedList<int> link = new LinkedList<int>();
            link.Add(1);
            link.Add(2);
            link.Add(3);
            link.Add(4);
            LinkedNode<int> node = link.head;
            while (node != null)
            {
                Console.Write(node.value+" ");
                node = node.nextNode;
            }
            Console.WriteLine();
 
            link.Remove(2);
            node = link.head;
            while (node != null)
            {
                Console.Write(node.value+" ");
                node = node.nextNode;
            }

5.自己实现一个最简单的单向链表

    class LinkedNode<T>
    {
        public T value;
        //存储下一个元素是谁 相当于钩子
        public LinkedNode<T> nextNode;
 
        public LinkedNode(T value)
        {
            this.value = value;
        }
    }
    /// <summary>
    /// 单向链表类 管理 节点 管理 添加等等
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class LinkedList<T>
    {
        public LinkedNode<T> head;
        public LinkedNode<T> last;
        public void Add(T value)
        {
            //添加节点 必然是 new 一个新的节点
            LinkedNode<T> node = new LinkedNode<T>(value);
            if (head == null)
            {
                head = node;
                last = node;
            }
            else
            {
                last.nextNode = node;
                last = node;
            }
        }
        public void Remove(T value)
        {
            if (head == null)
            {
                return;
            }
            if (head.value.Equals(value))
            {
                head = head.nextNode;
                //如果头节点 被移除 发现头节点变空
                //证明只有一个节点 那尾也要清空
                if (head == null)
                {
                    last = null;
                }
                return;
            }
            LinkedNode<T> node = head;
            while (node.nextNode!=null)
            {
                if (node.nextNode.value.Equals(value))
                {
                    //让当前找到的这个元素的 上一个节点
                    //指向 自己的下一个节点
                    node.nextNode = node.nextNode.nextNode;
                    break;
                }
            }
        }
    }

6.顺序存储和链式存储的优缺点

从增删查改的角度思考

增：链式存储计算上优于顺序存储（中间插入时链式不用像顺序一样去移动位置）

删：链式存储计算上优于顺序存储（中间删除时链式不用像顺序一样去移动位置）

查：顺序存储使用上优于链式存储（数组可以直接通过下标得到元素，链式需要遍历）

改：顺序存储使用上优于链式存储（数组可以直接通过下标得到元素，链式需要遍历）

4.LinkedList

1.LinkedList

LinkedList是一个C#为我们封装好的类

它的本质是一个可变类型的泛型双向链表

2.申明

需要引用命名空间

using System.Collections.Generic

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

LinkedList<string> linkedList2 = new LinkedList<string>();

链表对象需要掌握两个类

一个是链表本身一个是链表节点类LinkedListNode

3.增删查改

1.增

            //1.在链表尾部添加元素
            linkedList.AddLast(10);
 
            //2.在链表的头部添加元素
            linkedList.AddFirst(20);
 
            //3.在某一个节点之后添加一个节点
            //  要指定节点 先得到一个节点
            LinkedListNode<int> n = linkedList.Find(20);
            linkedList.AddAfter(n, 15);
 
            //4.在某一个节点之前添加一个节点
            //  要指定节点 先得到一个节点
            linkedList.AddBefore(n, 11);

2.删

            //1.移除头节点
            linkedList.RemoveFirst();
 
            //2.移除尾节点
            linkedList.RemoveLast();
 
            //3.移除指定节点
            //  无法通过位置直接移除
            linkedList.Remove(20);
 
            //4.清空
            linkedList.Clear();
 
            linkedList.AddLast(1);
            linkedList.AddLast(2);
            linkedList.AddLast(3);
            linkedList.AddLast(4);

3.查

            //1.头节点
            LinkedListNode<int> first = linkedList.First;
 
            //2.尾节点
            LinkedListNode<int> last = linkedList.Last;
 
            //3.找到指定值的节点
            //  无法通过下标获取中间元素
            //  只有通过遍历查找指定位置元素
            LinkedListNode<int> node = linkedList.Find(3);
            Console.WriteLine(node.Value);
            node = linkedList.Find(5);
 
            //4.判断是否存在
            if (linkedList.Contains(1))
            {
                Console.WriteLine("链表中存在1");
            }

4.改

            //要先得再改 得到节点 再改变其中的值
            Console.WriteLine(linkedList.First.Value);
            linkedList.First.Value = 10;
            Console.WriteLine(linkedList.First.Value);

5.遍历

            //1.foreach遍历
            foreach (int item in linkedList)
            {
                Console.WriteLine(item+" ");
            }
            Console.WriteLine();
            //2.通过节点遍历
            //  从头到尾
            LinkedListNode<int> nowNode = linkedList.First;
            while (nowNode != null)
            {
                Console.Write(nowNode.Value+" ");
                nowNode = nowNode.Next;
            }
            Console.WriteLine();
 
            //  从尾到头
            nowNode = linkedList.Last;
            while (nowNode != null)
            {
                Console.Write(nowNode.Value+" ");
                nowNode = nowNode.Previous;
            }

5.泛型栈和队列

需要引用命名空间空间 using System.Cllections.Generic

使用上和之前的Stack和Queue一模一样

Stack<int> stack = new Stack<int>();

Queue<object> queue = new Queue<object>();

原文链接：https://blog.csdn.net/weixin_45274937/article/details/126607751

1.List

1.List的本质

2.申明

3.增删查改

1.增

2.删

3.查

4.改

5.遍历

2.Dictionary

1.Dictionary的本质

2.申明

3.增删查改

1.增

2.删

3.查

4.改

5.遍历

3.顺序存储和链式存储

1.数据结构

2.线性表

3.顺序存储

4.链式存储

5.自己实现一个最简单的单向链表

6.顺序存储和链式存储的优缺点

4.LinkedList

1.LinkedList

2.申明

3.增删查改

1.增

2.删

3.查

4.改

5.遍历

5.泛型栈和队列

你可能也喜欢