C#中数据结构

1.Array 数组类型

数组存储在连续的内存上;数组可以直接通过下标访问;读取速度快,但是增加和删除的速度慢。

  1. 定长数组Array
    特点:数组的内容都是相同类型。
    eg: int[]
    (1)初始化数组且赋值
 int[] intArray = new int[3] { 1, 2, 3 };//初始化賦值

(2)坐標索引賦值取值

 intArray[0] = 123;//坐标索引赋值
 int num= intArray[0];//坐标索引取值123
  1. 不定长数组 ArrayList
    为了解决数组创建时必须指定长度以及只能存放相同类型的缺点而推出的数据结构。ArrayList 是System.Collections命名空间下的一部分,所以若要使用则必须引入System.Collections。
    特点:長度變化,數據類型沒有限制,任何元素都是当成object处理,所以ArrayList不是类型安全的;如果是值类型,会有装箱操作,这会有时间损耗,也就是造成效率降低。
    (1)赋值
  ArrayList arrayList = new ArrayList() { 1,2,3};
 arrayList.Add("1");
 arrayList.Add("2");

(2)修改

  arrayList[2] = 26;//根据索引修改

(3)删除数据

 arrayList.RemoveAt(2);
  arrayList.Remove(1);
 arrayList.Remove("1");

(4)遍历:因为实现了IEnumerable接口,可以foreach循环遍历。

 foreach (var item in arrayList)
  {

}
  1. 泛型数组 List< T >
    特点:不定长;泛型,保证类型安全,避免装箱拆箱
    (1)赋值
  List<int> intList = new List<int>() { 1, 2, 3, 4 };
   intList.Add(123);
  intList.Add(123);

(2)修改

 intList[0] = 123;

(3)删除数据

  intList.RemoveAt(0);
  intList.Remove(123);

(4)遍历:因为实现了IEnumerable接口,可以foreach循环遍历。

 foreach (var item in intList)
 {

   }

2.Link 链表类型

元素在內存上不是連續分配,元素根據前後節點連接。
優點:插入和刪除操作比較容易
缺點:不能通過下標訪問,找元素只能通過遍歷,查找不方便

  1. LinkedList< T > :泛型链表
    (1)添加元素
   LinkedList<int> linkedList = new LinkedList<int>() { };
   LinkedListNode<int> node;
   node=linkedList.AddFirst(123);//頭節點
    node = linkedList.AddBefore(node,111);//指定元素之前插入
   node = linkedList.AddAfter(node, 2);//指定元素之后插入
   node = linkedList.AddAfter(node, 3);
   linkedList.AddLast(456);//尾節點

(2)查找元素

LinkedListNode<int> node123 = linkedList.Find(123);  //元素123的位置  从头查找

(3)删除元素

  linkedList.Remove(456);
  linkedList.RemoveFirst();
  linkedList.RemoveLast();
  linkedList.Clear();//清空鏈錶
  1. Queue < T > 泛型队列:默认情况下,Queue< T >的初始容量为32, 增长因子为2.0。
    特点:先进先出,类型安全
    (1)插值
 Queue<string> numbers = new Queue<string>();
  numbers.Enqueue("one");//插入隊列
  numbers.Enqueue("two");

(2)取值

 Console.WriteLine($"Dequeuing '{numbers.Dequeue()}'");//取值,會將值從隊列移除
 Console.WriteLine($"Peek at next item to dequeue: { numbers.Peek()}");//取值,不會將值從隊列移除

(3)清除队列

 numbers.Clear();

(4)是否包含某元素

numbers.Contains("four");

(5)Count数

numbers.Count

(6)遍历

 foreach (string number in numbers)
  {
       Console.WriteLine(number);
  }
  1. Stack < T > 泛型栈
    特点:先進後出,類型安全
    (1)插值
 Stack<string> stackNumbers = new Stack<string>();
 stackNumbers.Push("one");//插入值,進棧
 stackNumbers.Push("two");

(2)取值

 Console.WriteLine($"Pop '{stackNumbers.Pop()}'");//获取并移除
 Console.WriteLine($"Peek at next item to dequeue: { stackNumbers.Peek()}");//获取不移除

(3)清除

 stackNumbers .Clear();

(4)是否包含某元素

stackNumbers .Contains("four");

(5)Count数

stackNumbers .Count

(6)遍历

 foreach (string number in stackNumbers )
  {
       Console.WriteLine(number);
  }

3.Set Hash类型

hash分布,元素间没关系,动态增加容量,通過hash計算內存地址存儲

  1. HashSet:去重
    (1)插值
            HashSet<string> hashSet = new HashSet<string>();
            hashSet.Add("123");//插值
            hashSet.Add("689");
            hashSet.Add("456");
            hashSet.Add("12435");
            hashSet.Add("12435");
            hashSet.Add("12435");

(2)遍历

            foreach (var item in hashSet)
            {
                Console.WriteLine(item);
            }

(3)是否包含

  Console.WriteLine(hashSet.Contains("12345"));//是否包含某元素

(4)Count数

Console.WriteLine(hashSet.Count);//Count數

(5)交叉并补

                HashSet<string> hashSet1 = new HashSet<string>();
                hashSet1.Add("123");
                hashSet1.Add("689");
                hashSet1.Add("789");
                hashSet1.Add("12435");
                hashSet1.Add("12435");
                hashSet1.Add("12435");
                hashSet1.SymmetricExceptWith(hashSet);//补
                hashSet1.UnionWith(hashSet);//并
                hashSet1.ExceptWith(hashSet);//差
                hashSet1.IntersectWith(hashSet);//交

(6)转为泛型数组

 hashSet.ToList();

(7)清除

 hashSet.Clear();
  1. SortedSet :去重且排序
    (1)插值
        SortedSet<string> sortedSet = new SortedSet<string>();
            //IComparer<T> comparer  自定义对象要排序,就用这个指定
            sortedSet.Add("123");//插值
            sortedSet.Add("689");
            sortedSet.Add("456");
            sortedSet.Add("12435");
            sortedSet.Add("12435");
            sortedSet.Add("12435");

(2)遍历

        foreach (var item in sortedSet)
            {
                Console.WriteLine(item);
            }

(3)是否包含

  Console.WriteLine(sortedSet.Contains("12345"));//是否包含某元素

(4)Count数

 Console.WriteLine(sortedSet.Count);//Count數

(5)交叉并补

                SortedSet<string> sortedSet1 = new SortedSet<string>();
                sortedSet1.Add("123");
                sortedSet1.Add("689");
                sortedSet1.Add("456");
                sortedSet1.Add("12435");
                sortedSet1.Add("12435");
                sortedSet1.Add("12435");
                sortedSet1.SymmetricExceptWith(sortedSet);//补
                sortedSet1.UnionWith(sortedSet);//并
                sortedSet1.ExceptWith(sortedSet);//差
                sortedSet1.IntersectWith(sortedSet);//交

(6)转为泛型数组

 sortedSet.ToList();

(7)清除

 sortedSet.Clear();

4.key-value 鍵值對类型

体积可以动态增加,根據Key计算一个地址,然后放入key - value,如果不同的key得到相同的地址,第二个在前面地址上 + 1;查找的时候,如果地址对应数据的key不对,那就 + 1查找。
優點:增删查改 都很快
缺點:浪费空间,数据太多,重复定位定位,效率下降

  1. Hashtable:Hashtable是基于数组实现
    (1)赋值
            Hashtable table = new Hashtable();
            table.Add("123", "456");
            table[234] = 456;
            table[234] = 567;
            table[32] = 4562;
            table[1] = 456;
            table["ddd"] = 456;

(2)遍历

            foreach (DictionaryEntry objDE in table)
            {
                Console.WriteLine(objDE.Key.ToString());
                Console.WriteLine(objDE.Value.ToString());
            }

(3)线程安全包装

 Hashtable.Synchronized(table);//只有一个线程写  多个线程读
  1. Dictionary<int, string> 字典:泛型;key - value,字典不是线程安全,線程安全字典:ConcurrentDictionary
    (1)赋值
             Dictionary<int, string> dic = new Dictionary<int, string>();
            dic.Add(1, "HaHa");
            dic.Add(5, "HoHo");
            dic.Add(3, "HeHe");
            dic.Add(2, "HiHi");
            dic.Add(4, "HuHu1");
            dic[4] = "HuHu";
            dic.Add(4, "HuHu");

(2)遍历

            foreach (var item in dic)
            {
                Console.WriteLine($"Key:{item.Key}, Value:{item.Value}");
            }
  1. SortedDictionary<int, string> 去重
    (1)赋值
            SortedDictionary<int, string> dicSorted = new SortedDictionary<int, string>();
            dicSorted.Add(1, "HaHa");
            dicSorted.Add(5, "HoHo");
            dicSorted.Add(3, "HeHe");
            dicSorted.Add(2, "HiHi");
            dicSorted.Add(4, "HuHu1");
            dicSorted[4] = "HuHu";
            dicSorted.Add(4, "HuHu");

(2)遍历

            foreach (var item in dicSorted)
            {
                Console.WriteLine($"Key:{item.Key}, Value:{item.Value}");
            }
10-07 11:19