C#进阶03——常用泛型数据结构类
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>();