【C#每日一记】常用泛型数据结构类及题单实践回顾

---

‍个人主页：@元宇宙-秩沅

‍ hallo 欢迎 点赞 收藏⭐ 留言 加关注✅!

‍ 本文由 秩沅 原创

‍ 收录于专栏：unity之c#专题篇

⭐️⭐

---

---

---

⭐常用泛型数据结构类及题单实践回顾⭐

---

（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.继承的时候，子类默认先调用父类的构造函数

  /// 

    /// 13.List的删除和存取
    /// 
    //class Program
   // {
        //List和ArrayList的区别：前者结合了泛型，避免了拆箱装箱，效率更加优化
        //static void Main(string[] args)
        //{ 
        //    List text = new List();
        //    int[] arrary = new int[10]{ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
        //    int i = 0;
        //    while (i
        //    {
        //        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#专题篇】—核心章题单实践练习

---

你们的点赞 收藏⭐ 留言 关注✅是我持续创作，输出优质内容的最大动力！、

---

---