数据结构学习

1.Array:底层数据结构都是数组；

           {
                //Array
                //读取快、增删慢
                Console.WriteLine("***********Array*********");
                int[] intArray = new int[3];
                intArray[0] = 123;
                string[] stringArray = new string[] { "123", "234" };
            }
            {
                //ArrayList 不定长的，连续分配的
                //元素没有类型限制，任何元素都是当成object处理，如果是值类型，会有装箱操作
                //读取快、增删慢
                ArrayList arrayList = new ArrayList();
                arrayList.Add("eleven");
                arrayList.Add("Is");
                arrayList.Add(123);//add增加长度
                //arrayList[4] = 26;//索引赋值，不会增加长度

                //删除数据
                arrayList.RemoveAt(4);
                arrayList.Remove("eleven");
            }
            {
                //List:也是Array,内存上都是连续摆放的,不定长；泛型，保证类型安全，避免装箱拆箱
                //读取快、增删慢
                List<int> intList = new List<int>() { 1, 2, 3, 4, 5 };
                intList.Add(123);
            }

2.链表：底层是链表实现

//链表
            {
                //LinkedList:泛型的特点;链表，元素不连续分配，每个元素都有记录前后节点
                Console.WriteLine("******LinkList<T>******");
                LinkedList<int> linkedList = new LinkedList<int>();
                linkedList.AddFirst(123);
                linkedList.AddLast(456);

                bool isContain = linkedList.Contains(123);
                LinkedListNode<int> node123 = linkedList.Find(123);
                linkedList.AddBefore(node123, 0);
                linkedList.AddAfter(node123, 9);

                linkedList.Remove(456);
                linkedList.Remove(node123);
                linkedList.RemoveFirst();
                linkedList.RemoveLast();
                linkedList.Clear();
            }

            {
                //queue 就是链表  先进先出  放任务延迟执行，A不断写入日志任务，B不断获取任务去执行
                Queue<string> numbers = new Queue<string>();
                numbers.Enqueue("one");
                numbers.Enqueue("two");
                numbers.Enqueue("three");
                numbers.Enqueue("four");
                numbers.Enqueue("five");
                foreach (var number in numbers)
                {
                    Console.WriteLine(number);
                }

                Console.WriteLine($"Dequeueing {numbers.Dequeue()}");//获取第一个移除元素
                Console.WriteLine($"peek :{numbers.Peek()}");//获取第一个却不移除

                Queue<string> queueCopy = new Queue<string>(numbers.ToArray());//可以直接将数组传进去
                queueCopy.Clear();//清空
            }
            {
                //Stack  就是栈  先进后出；也是个链表
                Stack<string> numbers = new Stack<string>();
                numbers.Push("one");
                numbers.Push("two");
                numbers.Push("three");
                numbers.Push("four");
                numbers.Push("five");

                foreach (var number in numbers)
                {
                    Console.WriteLine(number);
                }

                Console.WriteLine($"Pop {numbers.Pop()}");
                Console.WriteLine($"Peek {numbers.Peek()}");

                Stack<string> stackCopy = new Stack<string>(numbers.ToArray());
                stackCopy.Clear();
            }

3.Set;可去重

//HashSet
                //集合：hash分布，元素间没有关系，动态增加容量，可以去重
                //应用场景：去重
                HashSet<string> hashSet = new HashSet<string>();
                hashSet.Add("123");
                hashSet.Add("689");
                hashSet.Add("456");
                hashSet.Add("12345");
                hashSet.Add("12345");
                hashSet.Add("12345");

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

                    hashSet1.ToList();
                    hashSet1.Clear();
                }
            }

            {
                //SortSet
                //排序的集合：去重 而且排序
                SortedSet<string> sortedSet = new SortedSet<string>();
                sortedSet.Add("123");
                sortedSet.Add("689");
                sortedSet.Add("456");
                sortedSet.Add("12345");
                sortedSet.Add("12345");
                Console.WriteLine(sortedSet.Count);
                Console.WriteLine(sortedSet.Contains("12345"));

                //也能交差并补
                sortedSet.ToList();
                sortedSet.Clear();
            }

4.key-value型

//key-value
            {
                //Hashtable  key-value  体积可以动态增加，拿着key计算一个地址，然后放入key-value
                //object-装箱拆箱，如果不同的key得到相同的地址，第二个在前面地址上+1
                //查找的时候，如果地址对应数据的key不对，那就+1查找
                //浪费了空间，Hashtable是基于数组实现
                //查找个数据，一次定位，增删 一次定位  、增删改查 都很快
                //浪费空间，数据太多，重复定位，效率就下去了
                Hashtable table = new Hashtable();
                table.Add("123", "456");
                table[234] = 456;
                table[32] = 456;
                table["eleven"] = 345;
                foreach (DictionaryEntry item in table)
                {
                    Console.WriteLine(item.Key.ToString());
                    Console.WriteLine(item.Value.ToString());
                }
                Hashtable.Synchronized(table);//只有一个线程写，多个线程读，线程安全
            }
            {
                //字典：泛型：key-value,添加是有顺序的
                Dictionary<int, string> dic = new Dictionary<int, string>();
                dic.Add(1, "haha");
                dic.Add(2, "ee");
            }
            {
                //SortedDictory 排序字段，可对键进行排序
                SortedDictionary<int, string> dic = new SortedDictionary<int, string>();
            }
            {
                //SortedList 可根据键进行排序
                SortedList sortedList = new SortedList();
                sortedList.Add("jj", "e");
                sortedList.Add("jj", "f");//添加重复的键 会报错
            }

5.线程安全的集合列举

                //ConcurrentQueue  线程安全版本的Queue
                //ConcurrentStack  线程安全版本的Stack
                //ConcurrentBag  线程安全的对象集合
                //ConcurrentDictionary线程安全的Dictionary
                //BlockingCollection 

6.迭代器：延迟访问

public class Yield
    {
        public IEnumerable<int> Power()
        {
            for(int i = 0; i < 10; i++)
            {
                yield return this.Get(i);
            }
        }

        public IEnumerable<int> Common()
        {
            List<int> intList = new List<int>();
            for(int i = 0; i < 10; i++)
            {
                intList.Add(this.Get(i));
            }
            return intList;
        }

        private int Get(int i)
        {
            Thread.Sleep(2000);
            return DateTime.Now.Day * i;
        }
    }

调用如下：

Yield yield = new Yield();
                foreach (var item in yield.Common())
                {
                    Console.WriteLine(item);
                }

                foreach (var item in yield.Power()) //延迟访问
                {
                    Console.WriteLine(item);
                }