stack还有一个拓展方法toarray，可以将栈中的元素复制到一个新的元组中。【还有count】

队列的笔记：先进先出，后进后出

栈的操作笔记

字典Dictionary<TKey,Tvalue>笔记

字典dictionary<Tkey,Tvalue>

字典容器储存的是一系列的键值对，每一个值对应一个唯一的键。键的意义在于，我们通过键相对的高效的访问到值。

栈：先进后出

栈的操作：出栈pop入栈push获取栈顶元素peek

队列：先进先出，两端开口。

队列的操作：出队 Dequeue 入队 Enqueue

字典操作：

remove关键字是key ,不是value

常用集合：

1. 动态数组：ArrayList  
   

2. 列表：List 初始化，可以不指定大小，获取长度使用属性Count 添加Add 删除Remove，RemoveAt 访问[index]

3. 字典：字典容器存储是一系列的键值对，每个值对应唯一一个键 Dictionary 数量 Count 添加Add（key，value） 删除 Remove 访问 [key]

4. 队列：Queue 先进先出，类似一个两端开口的羽毛球筒  Dequeue出队 Enqueue入队

5. 栈：Stack 先进后出，后进先出的一种容器好比一个开口的羽毛球筒 出栈Pop 入栈Push 获取栈顶元素Peek

字典的操作

队列，排队啊，先进先出

dictionary ==》java.Map

字典Dictionary<Tkey,Tvalue>

字典容器存储的是一系列的键值对，每个值对应一个唯一的键。

键的意义在于我们可以通过键相对高效的访问到底。

字典操作：

数量  Count

添加  Add(key,value)

删除  Remove

访问  [key]

栈：先进后出，后进先出

出栈  Pop

入栈  Push

获取栈顶元素  Peek

队列：先进先出

出队  Dequeue

入队  Enqueue

            //字典

            Dictionary<string, Dog> dic = new Dictionary<string, Dog>();

            dic.Add("A", new Dog("A"));

            dic.Add("B", new Dog("B"));

            dic.Add("C", new Dog("C"));

            dic.Add("D", new Dog("D"));

            dic["A"].name();

            //堆栈 先进后出 后进先出

            Stack<Pet> pets = new Stack<Pet>();

            pets.Push(new Dog("A"));

            pets.Push(new Cat("B"));

            pets.Peek().name();

            //弹出最后进入的对象

            pets.Pop();

            pets.Peek().name();

            //队列 出队顺序与入队顺序相同

            Queue<Pet> queue =new Queue<Pet>();

            queue.Enqueue(new Dog("A"));

            queue.Enqueue(new Dog("B"));

            queue.Enqueue(new Dog("C"));

            Pet pet = null;

            pet = queue.Dequeue();

            pet.name();

            pet = queue.Dequeue();

            pet.name();

            pet = queue.Dequeue();

            pet.name();

队列（Queue）：

  队列是先进先出的容器。

操作：

    出队：Dequeue

    入队：Enqueue

栈（Stack）：

    栈是先进后出，后进先出的一种容器。

操作：

  出栈：Pop

  入栈：Push

  获取栈顶元素：Peek

字典操作，键值对

字典，唯一标识

栈 （Stack）先进后出，后进先出

字典Dictionary<Tkey,Tvalue>

字典容器存储的是一系列的键值对，每个值对应一个唯一的键。

键的意义在于我们可以通过键相对高效的访问到底。

字典操作：

数量  Count

添加  Add(key,value)

删除  Remove

访问  [key]

栈：先进后出，后进先出

出栈  Pop

入栈  Push

获取栈顶元素  Peek

队列：先进先出

出队  Dequeue

入队  Enqueue

字典Dictionary<TKey,Tvalue>

字典容器存储的是一系列的键值对，每个值对应一个唯一的键。键的意义在于，我们可以通过键相对高效的访问到值。

字典操作

1. 数量 Count

2. 添加 Add(key,value)

3. 删除 Remove

4. 访问 [key]

栈：先进后出，后进先出的一种容器

栈的操作：

1. 出栈： Pop

2. 入栈： Push

3. 获取栈顶元素： Peek

队列：先进先出的容器。

队列的操作：

1. 出队 Dequeye

2. 入队 Enqueue

Queue队列类型集合：先进先出，两端开口的筒。

队列的操作：

• 出对 Dequue

• 入队 Enqueue
  

Stack 栈集合类型：先进后出，后进先出的一种容器。

栈的操作：

• 出栈  Pop

• 入栈 Push

• 获取栈顶的元素 Peek

Dictionary型集合：存储一系列键值对，键和值一一对应的，通过键可以高效的访问它对应的值。

Dictionary<TKey,Tvalue>

它的操作有如下：通过键key访问它们

• 数量 Count

• 添加 Add(key,value)

• 删除 Remove

• 访问 [Key]

1. 字典集合Dictionary<TKey(键),TValue(值)>

2. 栈集合Stack<>：出栈(Pop())，入栈(Push(入栈数据))，获取栈顶元素Peek()

3. 队列Queue<>:入队(Enqueue(入队数据))，出队(Dequeue())

   
   

1.字典集合Dictionary<TKey(键),TValue(值)> 2.栈集合Stack<>：出栈(Pop())，入栈(Push(入栈数据))，获取栈顶元素Peek() 3.队列Queue<>:入队(Enqueue(入队数据))，出队(Dequeue())