c#之数据结构

1 数据结构类型

线型结构：一对一，比如：ArrayList ，List，数组等。 在内存中是连续存储的，所以节省内存，读取快 但是删除新增慢。

代码： 

      //1.节省内存  读取快   删除新增慢
            #region Array 数组
            {
                //Array：在内存上连续分配的，而且元素类型是一样的
                //可以坐标访问  读取快--增删慢，长度不变
                Console.WriteLine("***************Array******************");
                int[] intArray = new int[3];
                intArray[0] = 123;
                string[] stringArray = new string[] { "123", "234" };//Array
            }
            {
                //ArrayList  也是Array，内存上都是连续摆放; 不定长的，连续分配的；
                //元素没有类型限制，任何元素都是当成object处理，如果是值类型，会有装箱操作
                //读取快--增删慢
                Console.WriteLine("***************ArrayList******************");
                ArrayList arrayList = new ArrayList();
                arrayList.Add("MyProjectApi.Common");
                arrayList.Add("Is");
                arrayList.Add(32);//add增加长度
                //arrayList[4] = 26;//索引复制，不会增加长度
                //删除数据
                //arrayList.RemoveAt(4);
                var value = arrayList[2];
                arrayList.RemoveAt(0);
                arrayList.Remove("MyProjectApi.Common");
            }
            {
                //List:也是Array，内存上都是连续摆放;不定长；泛型，避免装箱拆箱
                //相对于ArrayLlist是能够保证类型安全，因为一开始就定义了类型，后续肯定就是这个类型，不存在类型转换时出的错误。 
                //读取快--增删慢
                Console.WriteLine("***************List<T>******************");
                List<int> intList = new List<int>() { 1, 2, 3, 4 };
                intList.Add(123);
                intList.Add(123);
                //intList.Add("123");
                //intList[0] = 123;
                List<string> stringList = new List<string>();
                //stringList[0] = "123";//异常的
                foreach (var item in intList)
                { 
                }
            }
            #endregion

链表：删除新增方便，查询较慢

      #region 链表
            {
                //LinkedList(双向链表)：泛型；存储元素不连续分配；每个存储元素记录前后每个元素的节点；
                //节点值不能重复： 
                // 删除新增方便，查询较慢
                Console.WriteLine("***************LinkedList<T>******************");
                LinkedList<int> linkedList = new LinkedList<int>();
                //var resutlt= linkedList[3]
                linkedList.AddFirst(123);
                linkedList.AddLast(456);

                bool isContain = linkedList.Contains(123);
                LinkedListNode<int> node123 = linkedList.Find(123);  //元素123的位置  从头查找
                linkedList.AddBefore(node123, 123);
                linkedList.AddBefore(node123, 123);
                linkedList.AddAfter(node123, 9);
                linkedList.Remove(456);
                linkedList.Remove(node123);
                linkedList.RemoveFirst();
                linkedList.RemoveLast();
                linkedList.Clear();

            }

            {
                //Queue 队列，也是链表：先进先出；
                //比如多线程写日志的时候，可以使用队列
                Console.WriteLine("***************Queue<T>******************");
                Queue<string> numbers = new Queue<string>();
                numbers.Enqueue("one");
                numbers.Enqueue("two");
                numbers.Enqueue("three");
                numbers.Enqueue("four");
                numbers.Enqueue("four");
                numbers.Enqueue("five");

                foreach (string number in numbers)
                {
                    Console.WriteLine(number);
                }
                //Dequeue 移除队头  Peek取出队头元素
                Console.WriteLine($"Dequeuing '{numbers.Dequeue()}'"); //移除
                Console.WriteLine($"Peek at next item to dequeue: { numbers.Peek()}");
                Console.WriteLine($"Dequeuing '{numbers.Dequeue()}'");

                Queue<string> queueCopy = new Queue<string>(numbers.ToArray());
                foreach (string number in queueCopy)
                {
                    Console.WriteLine(number);
                }

                Console.WriteLine($"queueCopy.Contains("four") = {queueCopy.Contains("four")}");
                queueCopy.Clear();
                Console.WriteLine($"queueCopy.Count = {queueCopy.Count}");
            }
            {
                //Stack 就是链表  先进后出  解析表达式目录树的时候，先产生的数据后使用
                //操作记录为命令，撤销的时候是倒序的
                Console.WriteLine("***************Stack<T>******************");
                Stack<string> numbers = new Stack<string>();
                numbers.Push("one");
                numbers.Push("two");
                numbers.Push("three");
                numbers.Push("four");
                numbers.Push("five");//放进去

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

                Stack<string> stackCopy = new Stack<string>(numbers.ToArray());
                foreach (string number in stackCopy)
                {
                    Console.WriteLine(number);
                }
                Console.WriteLine($"stackCopy.Contains("four") = {stackCopy.Contains("four")}");
                stackCopy.Clear();
                Console.WriteLine($"stackCopy.Count = {stackCopy.Count}");
            }
            #endregion

集合set; 纯粹的集合；

 //set纯粹的集合，容器，东西丢进去，唯一性 无序的

            #region Set
            {
                //HashSet:去掉重复：比如在投票的时候可以用
                Console.WriteLine("***************HashSet<string>******************");
                HashSet<string> hashSet = new HashSet<string>();
                hashSet.Add("123");
                hashSet.Add("689");
                hashSet.Add("456");
                hashSet.Add("12435");
                hashSet.Add("12435");
                hashSet.Add("12435");
                //hashSet[0];
                foreach (var item in hashSet)
                {
                    Console.WriteLine(item);
                }
                Console.WriteLine(hashSet.Count);
                Console.WriteLine(hashSet.Contains("12345"));

                {
                    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);//交 
                }
                hashSet.ToList();
                hashSet.Clear();
            }
            {
                //排序的集合：去重 （统计） 而且排序   排名 排行榜
                //统计排名--每统计一个就丢进去集合
                Console.WriteLine("***************SortedSet<string>******************");
                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");
                foreach (var item in sortedSet)
                {
                    Console.WriteLine(item);
                }
                Console.WriteLine(sortedSet.Count);
                Console.WriteLine(sortedSet.Contains("12345"));
                {
                    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);//交
                }

                sortedSet.ToList();
                sortedSet.Clear();
            }
            #endregion

字典： 读取快！删除新增也快！

            //读取快！删除新增也快！
            //key-value  一段连续空间存储Value,基于Key有个算法计算出一个索引，索引和Value是对应的；
            //如果有多个key计算出同一个Value的位置（散列冲突）  可以让第二个+1 
            //多个Key 计算相同的结果频率过高是出现在大数据量的时候！
            //如果数据量过大，也会出现性能的持续降低！
            //三万左右数据量时候，就会有明显的性能降低！
            #region key-value
            {
                Console.WriteLine("***************Hashtable******************");
                Hashtable table = new Hashtable();
                table.Add("123", "456");
                table[234] = 456;
                table[234] = 567;
                table[32] = 4562;
                table[1] = 456;
                table["MyProjectApi.Common"] = 456;
                foreach (DictionaryEntry objDE in table)
                {
                    Console.WriteLine(objDE.Key.ToString());
                    Console.WriteLine(objDE.Value.ToString());
                }
                //线程安全
                Hashtable.Synchronized(table);//只有一个线程写  多个线程读
            }
            {
                //字典：泛型；key - value，增删查改 都很快；有序的
                //  字典不是线程安全 ConcurrentDictionary
                Console.WriteLine("***************Dictionary******************");
                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");
                foreach (var item in dic)
                {
                    Console.WriteLine($"Key:{item.Key}, Value:{item.Value}");
                }
            }
            {
                Console.WriteLine("***************SortedDictionary******************");
                SortedDictionary<int, string> dic = new SortedDictionary<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");
                foreach (var item in dic)
                {
                    Console.WriteLine($"Key:{item.Key}, Value:{item.Value}");
                }
            }
            {
                //"a".GetHashCode();

                Console.WriteLine("***************SortedList******************");
                SortedList sortedList = new SortedList();//IComparer
                sortedList.Add("First", "Hello");
                sortedList.Add("Second", "World");
                sortedList.Add("Third", "!");

                sortedList["Third"] = "~~";//
                sortedList.Add("Fourth", "!");
                sortedList.Add("Fourth", "!");//重复的Key Add会错
                sortedList["Fourth"] = "!!!";
                var keyList = sortedList.GetKeyList();
                var valueList = sortedList.GetValueList();

                sortedList.TrimToSize();//用于最小化集合的内存开销

                sortedList.Remove("Third");
                sortedList.RemoveAt(0);
                sortedList.Clear();
            }
            #endregion 

 补充：在多线程情况下的一些用法：

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

 比如其中；ConcurrentQueue

补充：

 //只有实现了IEnumerable 才能进行遍历
            {
                List<string> fruits =
                new List<string> { "apple", "passionfruit", "banana", "mango",
                    "orange", "blueberry", "grape", "strawberry" };
                IEnumerable<string> query = fruits.Where(fruit => fruit.Length < 6);
                foreach (var item in query)//遍历才会去查询比较   迭代器 yield
                {

                }
                IQueryable<string> queryable = fruits.AsQueryable<string>().Where(s => s.Length > 5);
                foreach (var item in queryable)//表达式目录树的解析，延迟到遍历的时候才去执行  EF的延迟查询
                {

                }
            }

树形结构：表达式目录树 / 菜单 / 文件夹 /
图状结构：多对多 / 地图 / 拓扑图