C#中常用容器的使用与底层数据结构，特点（2）hash集合，二叉树集合，

hash集合类型：HashSet<>，Hashtable,Dictionary<>

 和线性集合比较，hash集合特点在于，通过索引键值来访问，

（HashSet除外，存储一系列对象，而不是键值对）

Hashtable 几乎等于Dictionary<object,object>,它是非类型安全的，即需要装箱拆箱

Hashtable迭代元素为DictionaryEntry类型

Dictionary迭代元素为KeyValuePair类型

200_000条数据

-----------------------------------------------------------------------

二叉树集合类型：SortedList<>,SortedSet<>,SortedDictionary<>

最大区别在于，二叉树类型集合根据键自动排序的，不管先后插入，

遍历List<>,SortedDictionary<>都是KeyValuePair类型

因而明显速度慢于hash集合，200_000条数据

建议调试查看集合中数据顺序，

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

namespace CollectionDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            TestHashSet();
            TestHashtable();
            TestDictionary();
            Console.ReadKey();
           
        }

        public static void TestHashSet() {
            HashSet<int> hs = new HashSet<int>();
            for (int i = 0; i < 10; i++)
            {
                hs.Add(i);
            }
            hs.Remove(5);
            bool flag=hs.Contains(2);
            int[] t = new int[10];
            //int s=hs[2];
            
            foreach (int item in hs)
            {

            }
            hs.CopyTo(t);
            hs.ExceptWith(new int[]{ 1,3,5});
            //int tt = hs[5];
            //测试性能
            Stopwatch sw = new Stopwatch();
            HashSet<int> hashset = new HashSet<int>();
            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                hashset.Add(i);
            }
            Console.WriteLine($"hashset.Add():{sw.ElapsedMilliseconds}ms");
            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                hashset.Remove(i);
            }
            Console.WriteLine($"hashset.Remove():{sw.ElapsedMilliseconds}ms");
        }

        public static void TestHashtable() {
            Hashtable ht = new Hashtable();
            ht.Add("1", 1);
            ht.Add(1,1);
            //可以通过索引器访问，
            object o = ht[""];
            //不让重复
            //ht.Add("1",2);
            ICollection keys = ht.Keys;
            bool f=ht.Contains("2");

            //int类型，竟然没有报错
            foreach (DictionaryEntry item in ht)
            {
                Console.WriteLine(item.Value);
            }

            Stopwatch sw = new Stopwatch();
            Hashtable hastable = new Hashtable();
            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                hastable.Add(i,i);
            }
            Console.WriteLine($"hashtable.Add():{sw.ElapsedMilliseconds}ms");
            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                hastable.Remove(i);
            }
            //不用调整索引下标顺序，效率还可以
            //不过官方宣称 https://docs.microsoft.com/zh-cn/dotnet/api/system.collections.hashtable?view=netcore-3.1
            //建议不要将 Hashtable 类用于新的开发。 相反，我们建议使用泛型 Dictionary<TKey,TValue> 类。 
            //但是话又说回来，对于一系列不同类型的键值对来说，好像也挺香的
            //对于替换方式便是Dictionary<object,object>
            Console.WriteLine($"hashtable.Remove():{sw.ElapsedMilliseconds}ms");
        }

        public static void TestDictionary()
        {
            Dictionary<string, int> dic = new Dictionary<string,int>();
            dic.Add("b", 2);
            dic.ContainsKey("");
            dic.Remove("");
            //可以通过索引器访问，
            //必须判断key存在，才能访问
            int d =dic["b"];
            //dic.s
            //ht.Add("1",2);
            ICollection keys = dic.Keys;
            bool f = dic.ContainsValue(4);

            foreach (KeyValuePair<string,int> item in dic)
            {
                Console.WriteLine(item.Value);
            }

            Stopwatch sw = new Stopwatch();
            Dictionary<string, int> dictionary =new Dictionary<string, int>();
            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                dictionary.Add(i.ToString(), i);
            }
            Console.WriteLine($"dictionary.Add():{sw.ElapsedMilliseconds}ms");
            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                dic.Remove(i.ToString());
            }
            //不用调整索引下标顺序，效率还可以
            Console.WriteLine($"dictionary.Remove():{sw.ElapsedMilliseconds}ms");

            
        }
        //放‘少量有限的一对对的数据’
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

namespace SortedDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            TestSortedDictionary();
            TestSortedList();
            TestSortedSet();
            Console.WriteLine("Hello World!");
        }

        public static void TestSortedDictionary() {
            SortedDictionary<string, int> sdic = new SortedDictionary<string, int>();
            sdic.Add("",1);
            sdic.Add("1",2);
            sdic.Add("4", 2);
            sdic.Add("3", 2);
            sdic.Add("2", 2);
            sdic.Remove("");

            foreach (KeyValuePair<string,int> item in sdic)
            {

            }
            //测试性能
            Stopwatch sw = new Stopwatch();
            SortedDictionary<string, int> sdic1 = new SortedDictionary<string, int>();
            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                sdic1.Add(i.ToString(),i);
            }
            Console.WriteLine($"SortedDictionary.Add():{sw.ElapsedMilliseconds}ms");

            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                sdic1.Remove(i.ToString());
            }
            Console.WriteLine($"SortedDictionary.Remove():{sw.ElapsedMilliseconds}ms");
        }

        public static void TestSortedList()
        {
            //SortedList<string> si11 = new SortedList<string>();
            //使用泛型需要两个参数
            SortedList sl = new SortedList();
            
            //sl.Add(2, "2");
            //必须同一类型
            sl.Add("1", "");
            sl.Add("3", "3");
            SortedList<string,int> si = new SortedList<string,int>();
            si.Add("",1);
            foreach (string item in sl)
            {

            }
            foreach (KeyValuePair<string,int> item in si)
            {

            }
            //测试性能
            Stopwatch sw = new Stopwatch();
            SortedList<string, int> si1 = new SortedList<string, int>();
            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                si1.Add(i.ToString(), i);
            }
            Console.WriteLine($"SortedList.Add():{sw.ElapsedMilliseconds}ms");

            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                si1.Remove(i.ToString());
            }
            Console.WriteLine($"SortedList.Remove():{sw.ElapsedMilliseconds}ms");
        }

        public static void TestSortedSet()
        {
            //SortedSet ts = new System.Collections.Generic.SortedSet();
            SortedSet<int> ss = new SortedSet<int>();
            ss.Add(1);
            ss.Add(4);
            ss.Add(2);
            ss.Remove(1);

            foreach (int item in ss)
            {

            }
            //测试性能
            Stopwatch sw = new Stopwatch();
            SortedSet<int> ss1 = new SortedSet<int>();
            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                ss1.Add(i);
            }
            Console.WriteLine($"SortedSet.Add():{sw.ElapsedMilliseconds}ms");

            sw.Restart();
            for (int i = 0; i < 200_000; i++)
            {
                ss.Remove(i);
            }
            Console.WriteLine($"SortedSet.Remove():{sw.ElapsedMilliseconds}ms");
        }
    }
}