👨💻个人主页：@元宇宙-秩沅
👨💻 hallo 欢迎 点赞👍 收藏⭐ 留言📝 加关注✅!
👨💻 本文由 秩沅 原创
👨💻 收录于专栏：unity之c#专题篇
⭐🅰️⭐
文章目录
- ⭐🅰️⭐
- ⭐常用泛型数据结构类及题单实践回顾⭐
- 🎶（==A==）<font color=green >常用泛型数据结构类——List泛型类
- 🎶（==B==）<font color=green >常用泛型数据结构类——Dictionary泛型类
- 🎶（==C==）<font color=green >数据结构存储方式——顺序存储和链式存储
- 🎶（==D==）<font color=green >常用泛型数据结构类——LinkedList泛型类
- 🎶（==E==）<font color=green >常用泛型数据结构类——泛型栈和队列
- 🎶（==F==）<font color=green >常用数据容器的不同应用情况
- 🎶（==H==）实践——List类
- 🎶（==J==）实践——Dictionary类
- 🎶（==L==）实践——顺序存储和链式存储
- 🎶（==M==）实践——LinkedList类
- 🎶（==N==）实践
- ⭐🅰️⭐
⭐常用泛型数据结构类及题单实践回顾⭐
🎶（A）常用泛型数据结构类——List泛型类
🎶（B）常用泛型数据结构类——Dictionary泛型类
- hashtable的遍历 和 Dictionary 遍历API的区别对比
+
🎶（C）数据结构存储方式——顺序存储和链式存储
🎶（D）常用泛型数据结构类——LinkedList泛型类
🎶（E）常用泛型数据结构类——泛型栈和队列
- 本质API和Stack类Queue类一样，加上了泛型
- 并且前者再system.collection命名空间里
- 后者在system.collection,Generic里
🎶（F）常用数据容器的不同应用情况
总结数组，list,Dectionary,Stack,Queue,LinkedList等存储容器。我们怎么来使用
-
数组：简单的数据类型存储的时候，或者只需要查改数据的时候
-
List：它是ArraryList的泛型升级，适合一切对象的存储，适合查改的情况下使用
-
LinkeList：它是泛型双向链表，适合频繁增删的数据对象的情况下使用
-
Dectionary：它是Hashtable的泛型升级，适合键值对象的存储
-
Stack：适合先进后出的情况下使用
-
Queue：适合先进先出的情况下使用
🎶（H）实践——List类
- 实践经验：
1.构造函数中调用自身对象用this
2.LIst的函数和ArrryList的函数基本一致
3.List和ArraryList最大的区别就是前者的本质是泛型数组，后者的本质是Object数组
4.继承的时候，子类默认先调用父类的构造函数
/// <summary>
/// 13.List的删除和存取
/// </summary>
//class Program
// {
//List和ArrayList的区别：前者结合了泛型，避免了拆箱装箱，效率更加优化
//static void Main(string[] args)
//{
// List<int> text = new List<int>();
// int[] arrary = new int[10]{ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// int i = 0;
// while (i<arrary.Length)
// {
// text.Add(arrary[i++]);
// }
// text.RemoveAt(5);
// foreach (int item in text)
// {
// Console.WriteLine(item);
// }
//}
//}
///在构造函数中用List存取元素
class Monster
{
static public List<Monster> control = new List<Monster>();
public Monster()
{
control.Add(this);
}
virtual public void attack() { }
}
class Boss : Monster
{
public override void attack()
{
Console.WriteLine("放大招");
}
}
class Gablin : Monster
{
public override void attack()
{
Console.WriteLine("哥布林的技能");
}
}
class Program
{
static void Main(string[] args)
{
Boss boss1 = new Boss();
Gablin boss2 = new Gablin();
Monster text = new Monster();
foreach (Monster item in Monster .control )
{
item.attack();
}
}
}
🎶（J）实践——Dictionary类
- 实践经验：
1.不能再foreach迭代器里面修改键值不然会报错
2.只要存在从一个数据获得另一个数据就可以应用Dictionary
private Dictionary<int, string> text = new Dictionary<int, string>();
public Program()
{
string[] upperArrary = { "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖", "拾" };
for (int i = 0; i < upperArrary.Length; i++)
{
text.Add(i + 1, upperArrary[i]);
}
}
public void Upper( string num )
{
for (int i = 0; i < num.Length; i++)
{
int index = num[i] - '0';
Console.Write(text[index]);
}
}
static void Main(string[] args)
{
Program Exam = new Program();
Console.WriteLine(Exam.text[3]);
try
{
Console.WriteLine("请输入一个不超过三位数的整数");
int num = int.Parse(Console.ReadLine());
Exam.Upper(num.ToString());
}
catch (Exception)
{
throw;
}
}
Dictionary<char, int> text = new Dictionary<char, int>();
public void Multiplay(string arrray )
{
for (int i = 0; i < arrray.Length; i++)
{
if(text.ContainsKey(arrray[i]))
{
text[arrray[i]] += 1;
}
else
{
text.Add(arrray[i],1);
}
}
}
public void Print()
{
foreach (KeyValuePair<char ,int> item in text)
{
Console.WriteLine(item);
}
}
static void Main(string[] args)
{
Program text = new Program();
string arrary = "Welcome to Unity World";
string Arrary = arrary.ToUpper();
text.Multiplay(Arrary);
text.Print();
}
🎶（L）实践——顺序存储和链式存储
- 实践经验：
1.最大的应用区别在于顺序存储适合查改，链式存储适合增删
2.构建链表时要考虑全面，考虑到每个节点相互之间的关系，看代码的逻辑性是否严谨
//1.
//顺序存储是一组连续的存储单元依次存储在线性表中的存储 方式(连续存储)
//链式存储是将一组任意不连续的存储单元存储在线性表中存储方式（任意存储）
//2.
//顺序存储的查改效率大于链式存储
//链式存储的增删效率大于顺序存储
//3.
//常用的数据结构有：数组，链表，栈，队列，数，图，堆，散列表
class LinkedNode<T>
{
public T vaule;
public LinkedNode(T Vaule)
{
this.vaule = Vaule;
}
public LinkedNode<T> peakLink = null;
public LinkedNode<T> nextLink = null;
}
class Link<T>
{
private int count = 0;
private LinkedNode<T> head;
private LinkedNode<T> last;
public int Count { get => count; }
public LinkedNode<T> Peak { get => head; }
public LinkedNode<T> Last { get => last; }
public void Add(LinkedNode<T> node) //添加节点
{
if (head == null)
{
head = node;
last = node;
count++;
}
else
{
//尾插法
LinkedNode<T> temp = last; ;
last.nextLink = node;
last = node;
last.peakLink = temp;
count++;
}
}
public void RemoveAt(int index) //删除节点
{
LinkedNode<T> Lnode = head ;
int temp = 1;
if (index > count || index < 1)
{
Console.WriteLine("超出链表规定范围，请输入正确范围进行移除操作！");
return;
}
else if (index == 1)
{
Console.WriteLine("指令为删除头节点");
head = head.nextLink;
}
else if (index == count)
{
Console.WriteLine("指令为删除尾节点");
last = last.peakLink;
Console.WriteLine("此时尾节点为：" + last.vaule);
last.nextLink = null;
}
else
{
while (true)
{
if (temp == index)
{
if (Lnode.peakLink != null)
Lnode.peakLink.nextLink = Lnode.nextLink;
if (Lnode.nextLink != null)
Lnode.nextLink.peakLink = Lnode.peakLink;
break;
}
temp++;
count--;
Lnode = Lnode.nextLink;
}
}
}
public void Print() //遍历所有节点
{
LinkedNode<T> Lnode = head;
while(Lnode != null )
{
Console.WriteLine("节点的值为："+Lnode.vaule );
Lnode = Lnode.nextLink;
}
}
}
class Program
{
static void Main(string[] args)
{
Program text = new Program();
LinkedNode<int> node1 = new LinkedNode<int>(1);
LinkedNode<int> node2 = new LinkedNode<int>(2);
LinkedNode<int> node3 = new LinkedNode<int>(3);
Link<int> list = new Link<int>();
list.Add(node1);
list.Add(node2);
list.Add(node3);
Console.WriteLine("此时链表的长度为：" + list.Count);
list.RemoveAt(2);
list.Print();
}
}
🎶（M）实践——LinkedList类
- 实践经验：
1.本质上就是泛型的双向链表
2.当需要进行节点操作的时候，才用到节点类的API
3.所以需要掌握LinkedList 和LinkedListNode两个类
LinkedList<int> list = new LinkedList<int>();
Random rand = new Random();
int temp = 10;
while(temp-->=1)
{
list.AddFirst(rand.Next(101));
}
//foreach遍历
//foreach (var item in list)
//{
// Console.WriteLine(item);
//}
LinkedListNode<int> node = list.First;
//节点遍历——头节点遍历
Console.WriteLine("从头部开始 遍历了");
while(node!= null )
{
Console.WriteLine(node.Value);
node = node.Next;
}
//节点遍历 ——尾节点遍历\
Console.WriteLine("从尾部开始 遍历了");
node = list.Last;
while (node != null)
{
Console.WriteLine(node.Value);
node = node.Previous ;
}
🎶（N）实践
总结数组，list,Dectionary,Stack,Queue,LinkedList等存储容器。我们怎么来使用
- 数组：简单的数据类型存储的时候，或者只需要查改数据的时候
- List：它是ArraryList的泛型升级，适合一切对象的存储
- LinkeList：它是泛型双向链表，适合频繁增删的数据对象的情况下使用
- Dectionary：它是Hashtable的泛型升级，适合键值对象的存储
- Stack：适合先进后出的情况下使用
- Queue：适合先进先出的情况下使用
⭐🅰️⭐
⭐【Unityc#专题篇】之c#进阶篇】
⭐【Unityc#专题篇】之c#核心篇】
⭐【Unityc#专题篇】之c#基础篇】
⭐【Unity-c#专题篇】之c#入门篇】
⭐【Unityc#专题篇】—进阶章题单实践练习
⭐【Unityc#专题篇】—基础章题单实践练习
⭐【Unityc#专题篇】—核心章题单实践练习
你们的点赞👍 收藏⭐ 留言📝 关注✅是我持续创作，输出优质内容的最大动力！、
