标签：源码 数值 one 引用 就是 blank data 最大 删除节点
数据结构部分，复习栈，队列，数组，链表和红黑树，参考博客和资料学习后记录到这里方便以后查看，感谢被引用的博主。
栈(stack)又称为堆栈，是线性表，它只能从栈顶进入和取出元素，有先进后出，后进先出(LIFO, last in first out)的原则，并且不允许在除了栈顶以外任何位置进行添加、查找和删除等操作。栈就相当如手枪的弹夹，先进入栈的数据被压入栈底(bottom)，而后入栈的数据存放在栈顶(top)。当需要出栈时，是先让栈顶的数据出去后，下面的数据才能出去，这就是先进后出的特点。插入数据一般称为进栈或压栈(push)，删除数据则称为出栈或弹栈(pop)。
下面参考博文，地址：https://www.cnblogs.com/ysocean/p/7911910.html，底层使用数组来模拟一个栈的功能，具有push，pop，peek等常用方法，原生的stack是继承自vector类的子类，其具备父类的所有方法，这里模拟除了前面三种方法外，还写了判断自定义栈是否为空，以判断自定义栈是否满等方法。
1 package dataStructure; 2 /** 3 * 自定义栈，使用数组来实现 4 */ 5 public class MyStack { 6 7 private int size;//数组大小 8 private String[] arr;//数组 9 private int top=-1;//默认栈顶位置 10 11 //构造方法 12 public MyStack(int size) { 13 this.size = size; 14 arr=new String[size]; 15 } 16 17 //压栈 18 public void push(String value){ 19 //top范围0到size-1 20 if(top<=size-2){ 21 arr[++top]=value; 22 } 23 } 24 25 //出栈 26 public String pop(){ 27 //原栈顶元素设置为null，等待gc自动回收 28 return arr[top--]; 29 } 30 31 //查看栈顶 32 public String peek(){ 33 if(top>-1){ 34 return arr[top]; 35 }else{ 36 return null; 37 } 38 } 39 40 //检查栈是否为空 41 public boolean Empty(){ 42 return top<0; 43 } 44 45 //检查栈是否满 46 public boolean Full(){ 47 return top==size-1; 48 } 49 50 //检查栈中元素数量 51 public String size(){ 52 int count=top+1; 53 return "栈中元素:"+count+" | 栈容量"+size; 54 } 55 56 }
测试代码，验证自定义栈中的方法。
1 package dataStructure; 2 3 public class TestMyStack { 4 5 public static void main(String[] args) { 6 //测试自定义Stack 7 MyStack stack=new MyStack(3); 8 //压入栈顶 9 stack.push("Messi"); 10 stack.push("Ronald"); 11 stack.push("Herry"); 12 13 //查看栈中元素数量 14 System.out.println(stack.size()); 15 16 //查看栈顶元素 17 System.out.println(stack.peek()); 18 19 //循环遍历栈中元素 20 while(!stack.Empty()){ 21 System.out.println(stack.pop()); 22 } 23 24 //判断栈是否为空 25 System.out.println(stack.Empty()); //true 26 System.out.println(stack.size()); 27 28 } 29 30 }
控制台输出情况。
在上面例子的基础上，依然参考上述博文，自定义一个栈并能实现栈容量自动扩容，以及栈中可以存储不同的数据类型。
1 package dataStructure; 2 3 import java.util.Arrays; 4 import java.util.EmptyStackException; 5 6 /** 7 * 自定义栈，使用数组来实现，可以实现数组自动扩容，以及存储不同的数据类型 8 */ 9 public class MyArrayStack { 10 //定义属性 11 private int size;//容量 12 private Object[] arr;//对象数组 13 private int top;//栈顶位置 14 15 //默认构造方法 16 public MyArrayStack() { 17 this.size=10; 18 this.arr=new Object[10]; 19 this.top=-1; 20 } 21 22 //自定义数组容量的构造方法 23 public MyArrayStack(int size) { 24 if(size<0){ 25 throw new IllegalArgumentException("栈容量不能小于0"+size); 26 } 27 this.size = size; 28 this.arr=new Object[size]; 29 this.top=-1; 30 } 31 32 //压栈 33 public Object push(Object value){ 34 //压栈之前欠判断数组容量是否足够，不够就扩容 35 getNewCapacity(top+1); 36 arr[++top]=value; 37 return value; 38 } 39 40 //出栈 41 public Object pop(){ 42 if(top==-1){ 43 throw new EmptyStackException(); 44 } 45 Object obj=arr[top]; 46 //删除原来栈顶的位置，默认设置为null，等待gc自动回收 47 arr[top--]=null; 48 return obj; 49 } 50 51 //查找栈顶的元素 52 public Object peek(){ 53 return arr[top]; 54 } 55 56 //判断栈是否为空 57 public boolean Empty(){ 58 return top==-1; 59 } 60 61 //检查栈中元素 62 public String size(){ 63 int count=top+1; 64 return "栈中元素:"+count+" | 栈容量"+size; 65 } 66 67 //返回栈顶到数组末端内容 68 public void printWaitPosition(){ 69 if(top<arr.length-1){ 70 for(int i=top+1;i<arr.length;i++){ 71 System.out.println("空闲位置数值为："+arr[i]); 72 } 73 }else{ 74 System.out.println("没有空闲位置"); 75 } 76 } 77 78 79 //写一个方法判断数组是否需要自动扩容 80 public boolean getNewCapacity(int index){ 81 //判断压入后的数组下标，是否超过了数组容量限制，超出就扩容 82 if(index>size-1){ 83 //扩容2倍 84 int newSize=0; 85 if((size<<1)-Integer.MAX_VALUE>0){ 86 newSize=Integer.MAX_VALUE; 87 }else{ 88 newSize=size<<1; 89 } 90 //数组扩容后复制原数组数据，扩容的部分，默认为Object初始值 91 this.size=newSize; 92 arr=Arrays.copyOf(arr, newSize); 93 return true; 94 }else{ 95 return false; 96 } 97 } 98 }
测试代码，验证自动扩容，空闲位置是什么。
1 package dataStructure; 2 3 public class TestMyArrayStack { 4 5 public static void main(String[] args) { 6 // 测试自定义MyArrayStack 7 MyArrayStack stack=new MyArrayStack(2); 8 stack.push("Messi"); 9 stack.push("Ronald"); 10 System.out.println(stack.size()); 11 System.out.println(stack.peek()); 12 //超出容量后继续压栈 13 stack.push("boy you will have a good future"); 14 System.out.println(stack.size()); 15 System.out.println(stack.peek()); 16 //打印stack中空闲位置内容 17 stack.printWaitPosition(); 18 //压入数字 19 stack.push(8848); 20 System.out.println(stack.size()); 21 System.out.println(stack.peek()); 22 stack.printWaitPosition(); 23 //压入布尔类型 24 stack.push(true); 25 System.out.println(stack.size()); 26 System.out.println(stack.peek()); 27 stack.printWaitPosition(); 28 } 29 }
控制台输出情况。
在参考博文中，栈除了以上用途外，还可以巧妙用在将字符串反转，还有验证分隔符是否匹配，以后如果有需要可以参考引用的博文。
队列(queue)，跟堆栈类似，也是线性表，它是仅允许在尾部(tail)进行插入，在头部(head)进行删除，满足先进先出(FIFO)的原则，类似火车头进入山洞，先进入山洞的车厢就先出来山洞，后进入山洞的火车头后出来山洞。查看队列源码，可以看到接口有如下方法。
简单的整理一下如下。
（1）插入元素到tail尾部：add(e)，offer(e)，前者为执行失败时抛出异常，后者不会抛出但返回特殊值(null或false)。
（2）移除head头部元素：remove()，poll()，前者为执行失败时抛出异常，后者不会抛出但返回特殊值(null或false)。
（3）查看列头head元素：element()，peek()，前者为执行失败时抛出异常，后者不会抛出但返回特殊值(null或false)。
下面分别使用两种类型的方法进行queue操作。
1 package DataCompose; 2 3 import java.util.LinkedList; 4 import java.util.PriorityQueue; 5 import java.util.Queue; 6 7 /** 8 * 测试队列，队列Queue具有先进先出的特点 9 */ 10 public class QueueTest { 11 12 public static void main(String[] args) { 13 //创建一个队列，使用LinkedList来创建对象，并被接口指向 14 Queue<String> queue=new LinkedList<String>(); 15 //Queue<String> queue=new PriorityQueue<String>(); 16 //使用会抛出异常的方法，添加元素到尾部，删除头部元素，以及查看头部元素操作 17 18 //1 添加元素 add方法 19 queue.add("Messi"); 20 queue.add("Herry"); 21 queue.add(null); 22 System.out.println(queue); 23 24 //2 删除头部元素 remove方法 25 String str=queue.remove(); 26 System.out.println(str); 27 System.out.println(queue); 28 29 //3 查看头部元素 element方法 30 System.out.println(queue.element()); 31 32 } 33 }
控制台输出结果，可以看出如果实现类为LinkedList时可以插入null，并且看出先加入的Messi，如果执行remove方法后也是先移除，执行element方法也是先查询得到头部元素，因此遵循先进先出原则。
如果不往集合中add元素，直接执行remove方法会发生如下报错，提示没有元素异常，并发现执行remove方法，会执行LinkedList底层的removeFirst方法，说明其移除的就是第一个元素。
同样如果不往集合中添加元素，直接执行element方法会报如下错，也提示没有元素异常，并发现执行element方法时会调用底层的getFirst方法，说明它取得是第一个元素。
可以看出当队列的实现类为LinkedList时，是可以插入null的，如果把实现类更换为PriorityQueue，会发生什么呢？发现会报空指针异常，原因是优先队列不允许插入null。
以上是使用queue的add，remove和element方法，上述同样的情况下，如果更换成offer，poll和peek方法后会是什么情况，看如下代码测试。
1 package DataCompose; 2 3 import java.util.LinkedList; 4 import java.util.PriorityQueue; 5 import java.util.Queue; 6 7 /** 8 * 测试队列，队列Queue具有先进先出的特点 9 */ 10 public class QueueTest1 { 11 12 public static void main(String[] args) { 13 //创建一个队列，使用LinkedList来创建对象，并被接口指向 14 Queue<String> queue=new LinkedList<String>(); 15 //Queue<String> queue=new PriorityQueue<String>(); 16 //使用会抛出异常的方法，添加元素到尾部，删除头部元素，以及查看头部元素操作 17 18 //1 添加元素 offer方法 19 queue.offer("Messi"); 20 queue.offer("Herry"); 21 queue.offer(null); 22 System.out.println(queue); 23 24 //2 删除头部元素 poll方法 25 String str=queue.poll(); 26 System.out.println(str); 27 System.out.println(queue); 28 29 //3 查看头部元素 peek方法 30 System.out.println(queue.peek()); 31 32 } 33 }
以上代码正常情况下执行跟第一种情况一模一样的结果，如果集合为空，直接调用poll方法和peek方法，查看执行结果如下，发现输出均为null，说明在集合为空的情况下这两种方法不会抛出异常。
同样如果将实现类更换为PriorityQueue，往里面添加null，会是什么结果呢？发现依然抛出异常，主要原因查看offer源码发现，如果实现类不支持null就会抛出异常。
另外还有一个deque，是queue的子接口，为双向队列，可以有效的在头部和尾部同时添加或删除元素，其实现类为ArrayDeque和LinkedList类，如果需要一个循环数组队列，选择ArrayDeque，如果需要一个链表队列，使用实现了Queue接口的LinkedList类。
由于Deque实现了Queue接口，因此其可以表现为完全的Queue特征，同时也可以当做栈来使用，具体是Queue还是栈，根据执行的方法来选择，一般来说如果添加元素和删除元素都是在同一端执行(方法后面都为First)，就表现为栈的特性，否则就是Queue的特性，以下是Deque接口的方法。
从以上的方法列表中，大概可以总结出以下几个特点：
（1）凡是以add，remove和get开头的方法，都可能在执行的过程中抛出异常，而以offer，poll和peek的方法往往返回null或者其他。
（2）凡是方法后面有Queue接口标志的方法，说明其是继承自接口Queue的方法，有Collection标志的说明是继承自Collection接口的通用方法。
Deque方法参考博文，分类总结如下：
下面简单的用deque的方法来实现集合操作，从队列两端添加，删除和查看元素，和栈以及queue的相关方法不在这里测试了，未来工作中继续感受。
1 package DataCompose; 2 3 import java.util.Deque; 4 import java.util.LinkedList; 5 6 /** 7 * 测试双向队列，其可以表现为Queue，也可以表现为Stack，这里测试双向列队 8 */ 9 public class DequeTest { 10 11 public static void main(String[] args) { 12 //使用链表实现 13 Deque<String> deque=new LinkedList<>(); 14 15 //先在head插入元素 16 deque.offerFirst("Messi"); 17 deque.offerFirst("Ronald"); 18 deque.offerFirst("Herry"); 19 System.out.println(deque); 20 21 //在tail插入元素 22 deque.offerLast("clyang"); 23 System.out.println(deque); 24 25 //在head查看元素 26 System.out.println(deque.peekFirst()); 27 28 //在tail查看元素 29 System.out.println(deque.peekLast()); 30 31 //在head删除元素 32 deque.pollFirst(); 33 System.out.println(deque); 34 35 //在tail删除元素 36 deque.pollLast(); 37 System.out.println(deque); 38 39 } 40 }
控制台输出结果，可以看出deque可以在head和tail两端进行插入、删除和查看操作。
数组(Array)，是一种有序的元素序列，数组在内存中开辟一段连续的空间，并在连续的空间存放数据，查找数组可以通过数组索引来查找，因此查找速度快，但是增删元素慢。数组创建以后在程序运行期间长度是不变的，如果要增加一个元素，会创建一个新的数组，将新元素存储到索引位置，并将原数组根据索引一一复制到新数组，原来的数组被gc回收，新数组的内存地址赋值给数组变量。
关于数组部分，直接可以从自己写的博客查看具体内容，博客地址：https://www.cnblogs.com/youngchaolin/p/10987960.html，另外参考了大牛博客，进行一些知识面的扩展。
底层利用数组，也可以实现数据结构的基本功能，简单概括一下，就是需要具备增删改查循环遍历的功能，这样才能算实现基本的数据结构，下面参考博客，进行这些功能的封装，实现一个基于数组的简单数据结构。
1 package DataCompose; 2 3 /** 4 * 数组测试，理解最基本数据结构，利用数组封装一个简单的数据结构，实现增删改查和循环遍历 5 */ 6 public class ArrayTest { 7 //底层数组，使用Object类型 8 private Object[] arr; 9 //数组占用长度 10 private int length; 11 //数组容量 12 private int maxSize; 13 14 //默认构造方法，仿造ArrayList，默认长度为10 15 public ArrayTest() { 16 this.length=0; 17 this.maxSize=10; 18 arr=new Object[maxSize]; 19 } 20 21 //自定义数组长度 22 public ArrayTest(int maxSize) { 23 this.maxSize = maxSize; 24 this.length=0; 25 arr=new Object[maxSize]; 26 } 27 //增加元素 28 public boolean add(Object obj){ 29 //增加元素暂时不使用底层再创建一个新的数组，进行数组内容复制，参考博客直接添加 30 if(length==maxSize){ 31 System.out.println("数组容量达到极限，无法自动扩容"); 32 return false; 33 } 34 //原数组后面再添加一个元素，否则就是初始值null 35 arr[length++]=obj; 36 return true; 37 } 38 //查找元素，本来先要写删，但是删元素之前需要先查是否存在，因此先写查询方法 39 public int find(Object obj){ 40 int n=-1; 41 for (int i= 0; i< length; i++) { 42 if(obj.equals(arr[i])){ 43 n=i; 44 break; 45 } 46 } 47 return n; 48 } 49 //删除元素 50 public boolean remove(Object obj){ 51 52 if(obj==null){ 53 System.out.println("不能删除null，请输入正常内容"); 54 return false; 55 } 56 int index=find(obj); 57 if(index==-1){ 58 System.out.println("不存在的元素:"+obj); 59 return false; 60 } 61 //数组元素覆盖操作 62 if(index==length-1){ 63 length--; 64 }else{ 65 for(int i=index;i<length-1;i++){ 66 arr[i]=arr[i+1]; 67 } 68 length--; 69 } 70 return true; 71 } 72 //修改元素，直接修改数组索引上的元素 73 public boolean modify(int index,Object obj){ 74 if(index<0||index>length-1){ 75 System.out.println("数组下标越界"); 76 return false; 77 }else{ 78 arr[index]=obj; 79 return true; 80 } 81 } 82 //遍历输出内容 83 public void toArrayString() { 84 System.out.print("["); 85 for (int i = 0; i < length; i++) { 86 if(i<length-1){ 87 System.out.print(arr[i] + ","); 88 }else{ 89 System.out.print(arr[i]); 90 } 91 } 92 System.out.print("]"); 93 //换行 94 System.out.println(); 95 } 96 97 }
测试类来测试上面写的数据结构。
1 package DataCompose; 2 3 /** 4 * 测试自己底层用数组写的数据结构 5 */ 6 public class TestArrayTest { 7 8 public static void main(String[] args) { 9 ArrayTest arr=new ArrayTest(5); 10 //添加元素 11 arr.add("boy you will have girl"); 12 arr.add(true); 13 arr.add("how many would you like"); 14 arr.add(1); 15 16 //打印数组 17 arr.toArrayString(); 18 19 //查询为1的元素 20 System.out.println(arr.find(1)); 21 22 //查询‘你好‘ 23 System.out.println(arr.find("你好")); 24 25 //修改下标为3的数组为100 26 arr.modify(3,100); 27 arr.toArrayString(); 28 29 //再添加一个元素 30 arr.add("哈哈哈"); 31 arr.toArrayString(); 32 33 //继续添加 34 arr.add("ok?"); 35 36 //删除最后的元素 37 boolean result=arr.remove("哈哈哈"); 38 System.out.println(result); 39 arr.toArrayString(); 40 41 } 42 }
控制台输出情况，发现可以正常的实现增删改查和循环遍历的功能。
链表(linked list),是由一系列结点node组成，结点包含两个部分，一个是存储数据的数据域，一个是存储下一个节点地址以及自己地址的地址域，即链表是双向链接的(double linked)，多个节点通过地址进行连接，组成了链表，其特点是增删元素快，只要创建或删除一个新的节点，内存地址重新指向规划就行，但是查询元素慢，需要通过连接的节点从头开始依次向后查找。
链表有单向链表和双向链表之分。
单向链表：链表中只有一条‘链子‘，元素存储和取出的顺序可能不一样，不能保证元素的顺序。
双向链表：链表中除了有单向链表一条链子外，还有一条链子用于记录元素的顺序，因此它可以保证元素的顺序。
依然参考博主系列文章的链表，自己实现一个自定义的链表，并具有增加头部元素、删除指定元素、修改指定元素、查找元素以及展示链表内容等功能。
1 package DataCompose; 2 3 /** 4 * 单向列表测试， 5 */ 6 public class SingleLinkTest { 7 //定义链表大小 8 private int size; 9 //定义头节点，只需要定义一个头，其他元素都可以通过这个节点头来找到 10 private Node head; 11 12 public SingleLinkTest() { 13 this.size = 0; 14 this.head = null; 15 } 16 17 //在链表头部增加元素 18 public Object addHead(Object obj) { 19 //得到一个新的节点 20 Node newNode = new Node(obj); 21 //链表为空，将头元素数据设置为obj 22 if (size == 0) { 23 head = newNode; 24 } else { 25 newNode.next = head; 26 head = newNode; 27 } 28 this.size++; 29 return obj; 30 } 31 32 //在链表中删除元素 33 public boolean delete(Object obj) { 34 //要删除一个元素，需要首先找到这个元素，将这个元素前一个元素next属性指向这个元素的下一个元素 35 if (size == 0) { 36 System.out.println("链表为空，无法删除！"); 37 return false; 38 } 39 //都是从头部开始查询，有找到需要删除的节点就删除，删除后将这个节点前一个节点next属性指向删除节点的下一个节点 40 //需要重新指向的话，需要删除节点数据，也需要删除节点前一个节点的数据，刚开始都使用头部节点数据 41 Node previousNode = head; 42 Node currentNode = head; 43 //什么时候找到这个元素什么时候停止 44 while (!currentNode.data.equals(obj)) { 45 //节点往后遍历，寻找下一个节点数据 46 if (currentNode.next == null) { 47 System.out.println("已到链表末尾，无需要删除的元素"); 48 return false; 49 } else { 50 //重置当前结点和当前结点前一个结点 51 previousNode = currentNode; 52 currentNode = currentNode.next; 53 } 54 } 55 56 //能执行到这里说明有需要删除的元素 57 size--; 58 if (currentNode == head) { 59 head = currentNode.next; 60 } else { 61 previousNode.next = currentNode.next; 62 } 63 return true; 64 } 65 66 //修改元素 67 public boolean modify(Object old, Object newObj) { 68 if (size == 0) { 69 System.out.println("链表为空，无法修改元素"); 70 return false; 71 } 72 Node currentNode = head; 73 while (!currentNode.data.equals(old)) { 74 if (currentNode.next == null) { 75 System.out.println("已到链表末尾，无需要删除的元素"); 76 return false; 77 } else { 78 currentNode = currentNode.next; 79 } 80 } 81 82 //能执行到这里说明有相同的元素 83 currentNode.data = newObj; 84 return true; 85 86 } 87 88 //查找元素 89 public boolean find(Object obj) { 90 if (size == 0) { 91 System.out.println("链表为空"); 92 } 93 Node currentNode = head; 94 while (!currentNode.data.equals(obj)) { 95 if (currentNode.next == null) { 96 System.out.println("已到链表末尾，无查找的元素"); 97 return false; 98 } else { 99 currentNode = currentNode.next; 100 } 101 } 102 103 //能执行到这里说明查找到了元素 104 System.out.println("查找元素存在链表中"); 105 return true; 106 } 107 108 //遍历输出元素 109 public void toLinkString() { 110 if (size > 0) { 111 if (size == 1) { 112 System.out.println("[" + head.data + "]"); 113 } 114 //结点先从头部开始 115 Node currentNode = head; 116 for (int i = 0; i < size; i++) { 117 if (i == 0) { 118 System.out.print("[" + currentNode.data); 119 } else if (i < size - 1) { 120 System.out.print("--->" + currentNode.data); 121 } else{ 122 System.out.print("--->"+currentNode.data+"]"); 123 } 124 currentNode = currentNode.next; 125 } 126 } else { 127 System.out.println("[]"); 128 } 129 System.out.println(); 130 } 131 132 }
Node外部类，参考很多博客都是写成内部类，但是自己写的编译无法通过先写成外部类。
1 package DataCompose; 2 3 /** 4 * 节点，外部类实现，自定义链表用 5 */ 6 public class Node { 7 //数据部分 8 public Object data; 9 //指向下一个节点，没有修改其中值得情况下默认为null 10 public Node next; 11 12 public Node(Object data) { 13 this.data = data; 14 } 15 16 }
测试类代码。
1 package DataCompose; 2 3 /** 4 * 测试自定义单向链表 5 */ 6 public class TestSingleLinkTest { 7 8 public static void main(String[] args) { 9 //默认容量为0的链表 10 SingleLinkTest Link=new SingleLinkTest(); 11 //头部添加元素 12 Link.addHead("clyang"); 13 Link.addHead(8848); 14 Link.addHead(true); 15 Link.toLinkString(); 16 17 //查找元素8848 18 boolean r=Link.find(8848); 19 System.out.println(r); 20 21 //更新元素 22 Link.modify(8848,"success people"); 23 Link.toLinkString(); 24 25 //删除元素 26 Link.delete("Messi"); 27 Link.toLinkString(); 28 29 } 30 }
控制台输出结果，发现可以正常表现为链表的功能。
二叉树(binary tree)，是每个结点不超过2的有序树(tree)，每个结点上最多只能有两个子结点，顶上的结点叫做根结点，两边的分别叫做左子树和右子树。
排序树/查找树，排序树是基于二叉树，左子树数值小，右子树数值大，查找数字会很快。
平衡树，也是基于二叉树，左子树和右子树的数量相等
不平衡树，基于二叉树，左子树和右子树数量不相等。
红黑树，特点是趋近于平衡树，查找叶子节点的最大次数和最小次数不能超过2倍，其查询速度非常的快。
红黑树还有以下约束：
1 节点可以是红色或者黑色的
2 根节点是黑色的
3 叶子节点(空节点)是黑色的
4 每个红色节点的子节点都是黑色
5 任何节点，到其下面每一个叶子节点的路径上，黑色节点数是相同的
参考博文：
（1）《Java核心技术卷》第8版
（2）https://www.cnblogs.com/ysocean/p/7911910.html 栈
（3）https://www.cnblogs.com/youngchaolin/p/10463887.html 二进制
（4）https://segmentfault.com/a/1190000016524796 队列
（5）https://www.cnblogs.com/ysocean/p/7894448.html 数组
（6）https://www.cnblogs.com/ysocean/p/7928988.html 链表
（7）https://www.cnblogs.com/shamo89/p/6774080.html 队列
标签：源码 数值 one 引用 就是 blank data 最大 删除节点
原文地址：https://www.cnblogs.com/youngchaolin/p/11032616.html
