1.1 顺序表

线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。
image.png
前驱元素: 若A元素在B元素的前面，则称A为B的前驱元素
后继元素: 若B元素在A元素的后面，则称B为A的后继元素
线性表的特征:数据元素之间具有一种“一对一”的逻辑关系。

  1. 第一个数据元素没有前驱，这个数据元素被称为头结点;
  2. 最后一个数据元素没有后继，这个数据元素被称为尾结点;
  3. 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继。

如果把线性表用数学语言来定义，则可以表示为(a1,…ai-1,ai,ai+1,…an)，ai-1领先于ai,ai领先于ai+1，称ai-1是ai的 前驱元素，ai+1是ai的后继元素
image.png
线性表的分类:
线性表中数据存储的方式可以是顺序存储，也可以是链式存储，按照数据的存储方式不同，可以把线性表分为顺序表和链表。
顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。
image.png

1.1.1 顺序表的实现

顺序表API设计:

  1.             |                     类名                                                                         | SequenceList                                                                                         |

| —- | —- | | 构造方法 | SequenceList(int capacity):创建容量为capacity的SequenceList对象 | | 成员方法 | 1.public void clear():空置线性表
2.publicboolean isEmpty():判断线性表是否为空，是返回true，否返回false
3.public int length():获取线性表中元素的个数
4.public T get(int i):读取并返回线性表中的第i个元素的值
5.public void insert(int i,T t):在线性表的第i个元素之前插入一个值为t的数据元素。
6.public void insert(T t):向线性表中添加一个元素t
7.public T remove(int i):删除并返回线性表中第i个数据元素。
8.public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返 回-1。 | | 成员变量 | 1.private T[] eles:存储元素的数组
2.private int N:当前线性表的长度 |

  1.     <br />**顺序表的代码实现:**                                                                                                                        
  1. public class SequenceList<T> {
  2.     //存储元素的数组
  3.     private T[] eles;
  5.     /**
  6.      * 记录当前顺序表中的个数
  7.      **/
  8.     private int n;
  10.     public SequenceList(int capacity) {
  11.         this.eles = (T[]) new Object[capacity];
  12.         this.n = 0;
  13.     }
  15.     //将一个线性表置为空表
  16.     public void clear() {
  17.         this.n = 0;
  18.     }
  20.     //判断当前线性表是否为空表
  21.     public boolean isEmpty() {
  22.         return this.n == 0;
  23.     }
  25.     //获取线性表的长度
  26.     public int length() {
  27.         return this.n;
  28.     }
  30.     //获取指定位置的元素
  31.     public T get(int i) {
  32.         if (i < 0 || i >= n) {
  33.             throw new RuntimeException("当前元素不存在!");
  34.         }
  36.         return this.eles[i];
  37.     }
  39.     //向线型表中添加元素t
  40.     public void insert(T t) {
  41.         if (this.n == eles.length) {
  42.             throw new RuntimeException("当前表已满");
  43.         }
  44.         eles[n++] = t;
  46.     }
  48.     public void insert(int i, T t) {
  49.         if (i == eles.length) {
  50.             throw new RuntimeException("当前表已满");
  51.         }
  52.         if (i < 0 || i > n) {
  53.             throw new RuntimeException("插入的位置不合法");
  54.         }
  55.         //把i位置空出来，i位置及其后面的元素依次向后移动一位
  56.         for (int index = n; index > i; index--) {
  57.             eles[index] = eles[index - 1];
  58.         }
  59.         eles[i] = t;
  60.         this.n++;
  61.     }
  64.     public T remove(int i) {
  65.         if (i < 0 || i > n - 1) {
  66.             throw new RuntimeException("当前要删除的元素不存在");
  67.         }
  69.         T t = eles[i];
  71.         for (int index = i; index < n - 1; index++) {
  72.             eles[index] = eles[index + 1];
  73.         }
  75.         //当前元素数量-1
  76.         this.n--;
  78.         return t;
  80.     }
  82.     public int indexOf(T t) {
  83.         if (t == null) {
  84.             throw new RuntimeException("查找的元素不合法");
  85.         }
  86.         for (int index = 0; index < n; index++) {
  87.             if (t.equals(this.eles[index])) {
  88.                 return index;
  89.             }
  90.         }
  91.         return -1;
  92.     }
  95.     public static void main(String[] args) {
  96.         //创建顺序表对象
  97.         SequenceList<String> sl = new SequenceList<>(10); //测试插入
  98.         sl.insert("姚明");
  99.         sl.insert("科比");
  100.         sl.insert("麦迪");
  101.         sl.insert(1, "詹姆斯");
  102.         //测试获取
  103.         String getResult = sl.get(1);
  104.         System.out.println("获取索引1处的结果为:" + getResult); //测试删除
  105.         String removeResult = sl.remove(0);
  106.         System.out.println("删除的元素是:" + removeResult);
  107.         //测试清空
  108.         sl.clear();
  109.         System.out.println("清空后的线性表中的元素个数为:" + sl.length());
  110.     }
  111. }

1.1.2 顺序表的遍历

一般作为容器存储数据，都需要向外部提供遍历的方式，因此我们需要给顺序表提供遍历方式。
在java中，遍历集合的方式一般都是用的是foreach循环，如果想让我们的SequenceList也能支持foreach循环，则 需要做如下操作:

  1. 让SequenceList实现Iterable接口，重写iterator方法;
  2. 在SequenceList内部提供一个内部类SIterator,实现Iterator接口，重写hasNext方法和next方法;

代码:

  1. public class SequenceList<T> implements Iterable<T> {
  2.     //存储元素的数组
  3.     private T[] eles;
  5.     /**
  6.      * 记录当前顺序表中的个数
  7.      **/
  8.     private int n;
  10.     public SequenceList(int capacity) {
  11.         this.eles = (T[]) new Object[capacity];
  12.         this.n = 0;
  13.     }
  15.     //将一个线性表置为空表
  16.     public void clear() {
  17.         this.n = 0;
  18.     }
  20.     //判断当前线性表是否为空表
  21.     public boolean isEmpty() {
  22.         return this.n == 0;
  23.     }
  25.     //获取线性表的长度
  26.     public int length() {
  27.         return this.n;
  28.     }
  30.     //获取指定位置的元素
  31.     public T get(int i) {
  32.         if (i < 0 || i >= n) {
  33.             throw new RuntimeException("当前元素不存在!");
  34.         }
  36.         return this.eles[i];
  37.     }
  39.     //向线型表中添加元素t
  40.     public void insert(T t) {
  41.         if (this.n == eles.length) {
  42.             throw new RuntimeException("当前表已满");
  43.         }
  44.         eles[n++] = t;
  46.     }
  48.     public void insert(int i, T t) {
  49.         if (i == eles.length) {
  50.             throw new RuntimeException("当前表已满");
  51.         }
  52.         if (i < 0 || i > n) {
  53.             throw new RuntimeException("插入的位置不合法");
  54.         }
  55.         //把i位置空出来，i位置及其后面的元素依次向后移动一位
  56.         for (int index = n; index > i; index--) {
  57.             eles[index] = eles[index - 1];
  58.         }
  59.         //把t放到i位置处
  60.         eles[i] = t;
  61.         //元素数量+1
  62.         this.n++;
  63.     }
  66.     public T remove(int i) {
  67.         if (i < 0 || i > n - 1) {
  68.             throw new RuntimeException("当前要删除的元素不存在");
  69.         }
  71.         T t = eles[i];
  73.         for (int index = i; index < n - 1; index++) {
  74.             eles[index] = eles[index + 1];
  75.         }
  77.         //当前元素数量-1
  78.         this.n--;
  80.         return t;
  82.     }
  84.     public int indexOf(T t) {
  85.         if (t == null) {
  86.             throw new RuntimeException("查找的元素不合法");
  87.         }
  88.         for (int index = 0; index < n; index++) {
  89.             if (t.equals(this.eles[index])) {
  90.                 return index;
  91.             }
  92.         }
  93.         return -1;
  94.     }
  96.     public void showEles() {
  97.         for (int i = 0; i < n; i++) {
  98.             System.out.print(eles[i] + " ");
  99.         }
  100.         System.out.println();
  101.     }
  104.     @Override
  105.     public Iterator<T> iterator() {
  106.         return new SIterator();
  107.     }
  109.     private class SIterator implements Iterator {
  110.         private int cur;
  112.         public SIterator() {
  113.             this.cur = 0;
  114.         }
  116.         @Override
  117.         public boolean hasNext() {
  118.             return cur < n;
  119.         }
  121.         @Override
  122.         public T next() {
  123.             return eles[cur++];
  124.         }
  125.     }
  128.     public static void main(String[] args) {
  129.         SequenceList<String> squence = new SequenceList<>(5); //测试遍历
  130.         squence.insert(0, "姚明");
  131.         squence.insert(1, "科比");
  132.         squence.insert(2, "麦迪");
  133.         squence.insert(3, "艾佛森");
  134.         squence.insert(4, "卡特");
  135.         for (String s : squence) {
  136.             System.out.println(s);
  137.         }
  138.     }
  139. }

1.1.3 顺序表的容量可变

在之前的实现中，当我们使用SequenceList时，先new SequenceList(5)创建一个对象，创建对象时就需要指定容 器的大小，初始化指定大小的数组来存储元素，当我们插入元素时，如果已经插入了5个元素，还要继续插入数 据，则会报错，就不能插入了。这种设计不符合容器的设计理念，因此我们在设计顺序表时，应该考虑它的容量的 伸缩性。
考虑容器的容量伸缩性，其实就是改变存储数据元素的数组的大小，那我们需要考虑什么时候需要改变数组的大
小?

  1. 添加元素时:

    添加元素时，应该检查当前数组的大小是否能容纳新的元素，如果不能容纳，则需要创建新的容量更大的数组，我们这里创建一个是原数组两倍容量的新数组存储元素。
    image.png

  2. 移除元素时:

移除元素时，应该检查当前数组的大小是否太大，比如正在用100个容量的数组存储10个元素，这样就会造成内存 空间的浪费，应该创建一个容量更小的数组存储元素。如果我们发现数据元素的数量不足数组容量的1/4，则创建 一个是原数组容量的1/2的新数组存储元素。
image.png
顺序表容量可变代码：

  1. public class SequenceList<T> implements Iterable<T> {
  2.     //存储元素的数组
  3.     private T[] eles;
  5.     /**
  6.      * 记录当前顺序表中的个数
  7.      **/
  8.     private int n;
  10.     public SequenceList(int capacity) {
  11.         this.eles = (T[]) new Object[capacity];
  12.         this.n = 0;
  13.     }
  15.     //将一个线性表置为空表
  16.     public void clear() {
  17.         this.n = 0;
  18.     }
  20.     //判断当前线性表是否为空表
  21.     public boolean isEmpty() {
  22.         return this.n == 0;
  23.     }
  25.     //获取线性表的长度
  26.     public int length() {
  27.         return this.n;
  28.     }
  30.     //获取指定位置的元素
  31.     public T get(int i) {
  32.         if (i < 0 || i >= n) {
  33.             throw new RuntimeException("当前元素不存在!");
  34.         }
  36.         return this.eles[i];
  37.     }
  39.     //向线型表中添加元素t
  40.     public void insert(T t) {
  41.         if (this.n == eles.length) {
  42.             resize(eles.length * 2);
  43.         }
  44.         eles[n++] = t;
  46.     }
  48.     public void insert(int i, T t) {
  49.         if (i < 0 || i > n) {
  50.             throw new RuntimeException("插入的位置不合法");
  51.         }
  52.         if (this.n == eles.length) {
  53.             resize(eles.length * 2);
  54.         }
  55.         //把i位置空出来，i位置及其后面的元素依次向后移动一位
  56.         for (int index = n; index > i; index--) {
  57.             eles[index] = eles[index - 1];
  58.         }
  59.         //把t放到i位置处
  60.         eles[i] = t;
  61.         //元素数量+1
  62.         this.n++;
  63.     }
  66.     public T remove(int i) {
  67.         if (i < 0 || i > n - 1) {
  68.             throw new RuntimeException("当前要删除的元素不存在");
  69.         }
  71.         T t = eles[i];
  73.         for (int index = i; index < n - 1; index++) {
  74.             eles[index] = eles[index + 1];
  75.         }
  77.         //当前元素数量-1
  78.         this.n--;
  80.         if (n > 0 && n < eles.length / 4) {
  81.             resize(eles.length / 2);
  82.         }
  85.         return t;
  87.     }
  89.     public int indexOf(T t) {
  90.         if (t == null) {
  91.             throw new RuntimeException("查找的元素不合法");
  92.         }
  93.         for (int index = 0; index < n; index++) {
  94.             if (t.equals(this.eles[index])) {
  95.                 return index;
  96.             }
  97.         }
  98.         return -1;
  99.     }
  101.     //改变容量
  102.     public void resize(int n) {
  103.         T[] newEles = (T[]) new Object[n];
  105.         for (int i = 0; i < n; i++) {
  106.             newEles[i] = this.eles[i];
  107.         }
  108.         this.eles = newEles;
  110.     }
  112.     public void showEles() {
  113.         for (int i = 0; i < n; i++) {
  114.             System.out.print(eles[i] + " ");
  115.         }
  116.         System.out.println();
  117.     }
  120.     @Override
  121.     public Iterator<T> iterator() {
  122.         return new SIterator();
  123.     }
  125.     private class SIterator implements Iterator {
  126.         private int cur;
  128.         public SIterator() {
  129.             this.cur = 0;
  130.         }
  132.         @Override
  133.         public boolean hasNext() {
  134.             return cur < n;
  135.         }
  137.         @Override
  138.         public T next() {
  139.             return eles[cur++];
  140.         }
  141.     }

1.1.4 顺序表的时间复杂度

get(i):不难看出，不论数据元素量N有多大，只需要一次eles[i]就可以获取到对应的元素，所以时间复杂度为O(1);
insert(int i,T t):每一次插入，都需要把i位置后面的元素移动一次，随着元素数量N的增大，移动的元素也越多，时 间复杂为O(n);
remove(int i):每一次删除，都需要把i位置后面的元素移动一次，随着数据量N的增大,移动的元素也越多，时间复 杂度为O(n);
由于顺序表的底层由数组实现，数组的长度是固定的，所以在操作的过程中涉及到了容器扩容操作。这样会导致顺序表在使用过程中的时间复杂度不是线性的，在某些需要扩容的结点处，耗时会突增，尤其是元素越多，这个问题越明显。

1.1.5 java中ArrayList实现

java中ArrayList集合的底层也是一种顺序表，使用数组实现，同样提供了增删改查以及扩容等功能。

  1. 是否用数组实现;
  2. 有没有扩容操作;
  3. 有没有提供遍历方式;

1.2 链表

之前我们已经使用顺序存储结构实现了线性表，我们会发现虽然顺序表的查询很快，时间复杂度为O(1),但是增删的效率是比较低的，因为每一次增删操作都伴随着大量的数据元素移动。这个问题有没有解决方案呢?有，我们可以 使用另外一种存储结构实现线性表，链式存储结构。
链表是一种物理存储单元上非连续、非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑顺序，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点(链表中的每一个元素称为结点)组成，
结点可以在运行时动态生成。
image.png
image.png
image.png

那我们如何使用链表呢?按照面向对象的思想，我们可以设计一个类，来描述结点这个事物，用一个属性描述这个
结点存储的元素，用来另外一个属性描述这个结点的下一个结点。
结点API设计:

类名



Node




构造方法



Node(T t,Node next):创建Node对象




成员变量



T item:存储数据
Node next:指向下一个结点

结点类实现:

  1. public class Node<T> {
  2.     //存储元素
  3.     public T item;
  4.     //指向下一个结点
  5.     public Node next;
  7.     public Node(T item, Node next) {
  8.         this.item = item;
  9.         this.next = next;
  10.     }
  11. }

生成链表:

  1. public static void main(String[] args) throws Exception { 
  2.         //构建结点
  3.         Node<Integer> first = new Node<Integer>(11, null);
  4.         Node<Integer> second = new Node<Integer>(13, null);
  5.         Node<Integer> third = new Node<Integer>(12, null);
  6.         Node<Integer> fourth = new Node<Integer>(8, null);
  7.         Node<Integer> fifth = new Node<Integer>(9, null);
  8.         //生成链表
  9.         first.next = second;
  10.         second.next = third;
  11.         third.next = fourth;
  12.         fourth.next = fifth;
  13.     }

1.2.1 单向链表

单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点。
image.png

1.2.1.1 单向链表API设计

  1.             |                     **类名**                                                                         | **LinkList**                                                                                         |

| —- | —- | | 构造方法 | LinkList():创建LinkList对象 | | 成员方法 |
1. public void clear():空置线性表
1. publicboolean isEmpty():判断线性表是否为空，是返回true，否返回false
1. public int length():获取线性表中元素的个数
1. public T get(int i):读取并返回线性表中的第i个元素的值
1. public void insert(T t):往线性表中添加一个元素;
1. public void insert(int i,T t):在线性表的第i个元素之前插入一个值为t的数据元素。
1. public T remove(int i):删除并返回线性表中第i个数据元素。
1. public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则 返回-1。
| | 成员内部类 | private class Node:结点类 | | 成员变量 |
1. private Node head:记录首结点
1. private int N:记录链表的长度
|

1.2.1.2 单向链表代码实现

  1. public class LinkList<T> implements Iterable<T> {
  3.     //记录头结点
  4.     private Node head;
  5.     //记录链表的长度
  6.     private int N;
  8.     public LinkList() {
  9.         //初始化头结点
  10.         head = new Node(null, null);
  11.         N = 0;
  12.     }
  14.     //清空链表
  15.     public void clear() {
  16.         head.next = null;
  17.         head.item = null;
  18.         this.N = 0;
  19.     }
  21.     //获取链表的长度
  22.     public int length() {
  23.         return N;
  24.     }
  26.     //判断链表是否为空
  27.     public boolean isEmpty() {
  28.         return N == 0;
  29.     }
  31.     //获取指定位置i出的元素
  32.     public T get(int i) {
  33.         if (i < 0 || i > N) {
  34.             throw new RuntimeException("位置不合法!");
  35.         }
  37.         Node n = head.next;
  38.         for (int index = 0; index < i; index++) {
  39.             n = n.next;
  40.         }
  41.         return n.item;
  42.     }
  44.     //向链表中添加元素t
  45.     public void insert(T t) {
  46.         // 找到最后后一个节点
  47.         Node node = head;
  48.         while (node.next != null) {
  49.             node = node.next;
  50.         }
  51.         //创建一个新的节点
  52.         Node newNode = new Node(t, null);
  54.         //将最后个节点指向新的节点
  55.         node.next = newNode;
  57.         // 链表长度加1
  58.         N++;
  59.     }
  61.     //向指定位置i处，添加元素t
  62.     public void insert(int i, T t) {
  63.         //校验 i是否合法
  64.         if (i < 0 || i > N) {
  65.             throw new RuntimeException("位置不合法!");
  66.         }
  68.         //找到i-1的节点
  69.         Node pre = head;
  70.         for (int index = 0; index < i; index++) {
  71.             pre = pre.next;
  72.         }
  73.         Node curNode = pre.next;
  75.         //创建新的节点
  76.         Node newNode = new Node(t, curNode);
  78.         // 让之前的结点指向新结点
  79.         pre.next = newNode;
  81.         // 链表的长度加1
  82.         N++;
  84.     }
  86.     //删除指定位置i处的元素，并返回被删除的元素
  87.     public T remove(int i) {
  88.         if (i < 0 || i >= N) {
  89.             throw new RuntimeException("位置不合法");
  90.         }
  92.         //寻找i之前的元素
  93.         Node pre = head;
  94.         for (int index = 0; index <= i - 1; index++) {
  95.             pre = pre.next;
  96.         }
  97.         //当前i位置的结点
  98.         Node curr = pre.next;
  99.         //前一个结点指向下一个结点，删除当前结点
  100.         pre.next = curr.next;
  101.         //长度-1
  102.         N--;
  103.         return curr.item;
  104.     }
  106.     //查找元素t在链表中第一次出现的位置
  107.     public int indexOf(T t) {
  108.         Node n = head;
  109.         for (int i = 0; n.next != null; i++) {
  110.             n = n.next;
  111.             if (n.item.equals(t)) {
  112.                 return i;
  113.             }
  114.         }
  115.         return -1;
  116.     }
  118.     //结点类
  119.     private class Node {
  120.         //存储数据
  121.         T item;
  122.         //下一个结点
  123.         Node next;
  125.         public Node(T item, Node next) {
  126.             this.item = item;
  127.             this.next = next;
  128.         }
  129.     }
  131.     @Override
  132.     public Iterator<T> iterator() {
  133.         return new LIterator();
  134.     }
  136.     private class LIterator implements Iterator<T> {
  138.         private Node n;
  140.         public LIterator() {
  141.             this.n = head;
  142.         }
  144.         @Override
  145.         public boolean hasNext() {
  146.             return n.next != null;
  147.         }
  149.         @Override
  150.         public T next() {
  151.             n = n.next;
  152.             return n.item;
  153.         }
  154.     }
  155. }
  157. public class LinkListTest {
  159.     public static void main(String[] args) {
  160.         LinkList<String> list = new LinkList<>();
  161.         list.insert(0, "张三");
  162.         list.insert(1, "李四");
  163.         list.insert(2, "王五");
  164.         list.insert(3, "赵六");
  165.         //测试length方法
  166.         for (String s : list) {
  167.             System.out.println(s);
  168.         }
  169.         System.out.println(list.length());
  170.         System.out.println("-------------------"); //测试get方法
  171.         System.out.println(list.get(2));
  172.         System.out.println("------------------------"); //测试remove方法
  173.         String remove = list.remove(1);
  174.         System.out.println(remove);
  175.         System.out.println(list.length());
  176.         System.out.println("----------------");
  177.         ;
  178.         for (String s : list) {
  179.             System.out.println(s);
  180.         }
  181.     }
  182. }

1.2.2 双向链表

双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用 来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存 储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。
image.png按照面向对象的思想，我们需要设计一个类，来描述结点这个事物。由于结点是属于链表的，所以我们把结点类作 为链表类的一个内部类来实现

1.2.2.1 结点API设计

  1.             |                     **类名**                                                                         | **Node**                                                                                         |

| —- | —- | | 构造方法 | Node(T t,Node pre,Node next):创建Node对象 | | 成员变量 | T item:存储数据
Node next:指向下一个结点
Node pre:指向上一个结点 |

1.2.2.2 双向链表API设计

  1.             |                     **类名**                                                                         | **TowWayLinkList**                                                                                         |

| —- | —- | | 构造方法 | TowWayLinkList():创建TowWayLinkList对象 | | 成员方法 | 1.public void clear():空置线性表
2.publicboolean isEmpty():判断线性表是否为空，是返回true，否返回false
3.public int length():获取线性表中元素的个数
4.public T get(int i):读取并返回线性表中的第i个元素的值
5.public void insert(T t):往线性表中添加一个元素;
6.public void insert(int i,T t):在线性表的第i个元素之前插入一个值为t的数据元素。7.public T remove(int i):删除并返回线性表中第i个数据元素。
8.public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则 返回-1。
9.public T getFirst():获取第一个元素
10.public T getLast():获取最后一个元素 | | 成员内部类 | private class Node:结点类 | | 成员变量 | 1.private Node first:记录首结点
2.private Node last:记录尾结点
3.private int N:记录链表的长度 |

1.2.2.3 双向链表代码实现

  1. public class TowWayLinkList<T> implements Iterable<T> {
  2.     //首结点
  3.     private Node head;
  4.     //最后一个结点
  5.     private Node last;
  6.     //链表的长度
  7.     private int N;
  9.     public TowWayLinkList() {
  10.         last = null;
  11.         head = new Node(null, null, null);
  12.         N = 0;
  13.     }
  15.     //清空链表
  16.     public void clear() {
  17.         last = null;
  18.         head.next = last;
  19.         head.pre = null;
  20.         head.item = null;
  21.         N = 0;
  22.     }
  24.     //获取链表长度
  25.     public int length() {
  26.         return N;
  27.     }
  29.     //判断链表是否为空
  30.     public boolean isEmpty() {
  31.         return N == 0;
  32.     }
  34.     //插入元素t
  35.     public void insert(T t) {
  36.         if (last == null) {
  37.             last = new Node(t, head, null);
  38.             head.next = last;
  39.         } else {
  40.             Node oldLast = last;
  41.             Node node = new Node(t, oldLast, null);
  42.             oldLast.next = node;
  43.             last = node;
  44.         }
  45.         //长度+1
  46.         N++;
  47.     }
  49.     //向指定位置i处插入元素t
  50.     public void insert(int i, T t) {
  51.         if (i < 0 || i >= N) {
  52.             throw new RuntimeException("位置不合法");
  53.         }
  54.         //找到位置i的前一个结点
  55.         Node pre = head;
  56.         for (int index = 0; index < i; index++) {
  57.             pre = pre.next;
  58.         }
  59.         //当前结点
  60.         Node curr = pre.next;
  61.         //构建新结点
  62.         Node newNode = new Node(t, pre, curr);
  63.         curr.pre = newNode;
  64.         pre.next = newNode;
  65.         //长度+1
  66.         N++;
  67.     }
  69.     //获取指定位置i处的元素
  70.     public T get(int i) {
  71.         if (i < 0 || i >= N) {
  72.             throw new RuntimeException("位置不合法");
  73.         }
  74.         //寻找当前结点
  75.         Node curr = head.next;
  76.         for (int index = 0; index < i; index++) {
  77.             curr = curr.next;
  78.         }
  79.         return curr.item;
  80.     }
  82.     //找到元素t在链表中第一次出现的位置
  83.     public int indexOf(T t) {
  84.         Node n = head;
  85.         for (int i = 0; n.next != null; i++) {
  86.             n = n.next;
  87.             if (n.next.equals(t)) {
  88.                 return i;
  89.             }
  90.         }
  91.         return -1;
  92.     }
  94.     //删除位置i处的元素，并返回该元素
  95.     public T remove(int i) {
  96.         if (i < 0 || i >= N) {
  97.             throw new RuntimeException("位置不合法");
  98.         }
  99.         //寻找i位置的前一个元素
  100.         Node pre = head;
  101.         for (int index = 0; index < i; index++) {
  102.             pre = pre.next;
  103.         }
  104.         //i位置的元素
  105.         Node curr = pre.next; //i位置的下一个元素
  106.         Node curr_next = curr.next;
  107.         pre.next = curr_next;
  108.         curr_next.pre = pre; //长度-1;
  109.         N--;
  110.         return curr.item;
  111.     }
  113.     //获取第一个元素
  114.     public T getFirst() {
  115.         if (isEmpty()) {
  116.             return null;
  117.         }
  118.         return head.next.item;
  119.     }
  121.     //获取最后一个元素
  122.     public T getLast() {
  123.         if (isEmpty()) {
  124.             return null;
  125.         }
  126.         return last.item;
  127.     }
  129.     //结点类
  130.     private class Node {
  131.         public Node(T item, Node pre, Node next) {
  132.             this.item = item;
  133.             this.pre = pre;
  134.             this.next = next;
  135.         }
  137.         //存储数据
  138.         public T item;
  139.         //指向上一个结点
  140.         public Node pre;
  141.         //指向下一个结点
  142.         public Node next;
  143.     }
  146.     @Override
  147.     public Iterator<T> iterator() {
  148.         return new TIterator();
  149.     }
  151.     private class TIterator implements Iterator {
  152.         private Node n = head;
  154.         @Override
  155.         public boolean hasNext() {
  156.             return n.next != null;
  157.         }
  159.         @Override
  160.         public Object next() {
  161.             n = n.next;
  162.             return n.item;
  163.         }
  164.     }
  165. }
  168. public class TowWayTest {
  170.     public static void main(String[] args) {
  171.         TowWayLinkList<String> list = new TowWayLinkList<>();
  172.         list.insert("乔峰");
  173.         list.insert("虚竹");
  174.         list.insert("段誉");
  175.         list.insert(1, "鸠摩智");
  176.         list.insert(3, "叶二娘");
  177.         for (String str : list) {
  178.             System.out.println(str);
  179.         }
  180.         System.out.println("----------------------");
  181.         String tow = list.get(2);
  182.         System.out.println(tow);
  183.         System.out.println("-------------------------");
  184.         String remove = list.remove(3);
  185.         System.out.println(remove);
  186.         System.out.println(list.length());
  187.         System.out.println("--------------------");
  188.         System.out.println(list.getFirst());
  189.         System.out.println(list.getLast());
  190.     }
  191. }

1.2.2.4 java中LinkedList实现

java中LinkedList集合也是使用双向链表实现，并提供了增删改查等相关方法

  1. 底层是否用双向链表实现;

  2. 结点类是否有三个域

    1.2.3 链表的复杂度分析

    get(int i):每一次查询，都需要从链表的头部开始，依次向后查找，随着数据元素N的增多，比较的元素越多，时间复杂度为O(n)
    insert(int i,T t):每一次插入，需要先找到i位置的前一个元素，然后完成插入操作，随着数据元素N的增多，查找的元素越多，时间复杂度为O(n);
    remove(int i):每一次移除，需要先找到i位置的前一个元素，然后完成插入操作，随着数据元素N的增多，查找的元素越多，时间复杂度为O(n)
    相比较顺序表，链表插入和删除的时间复杂度虽然一样，但仍然有很大的优势，因为链表的物理地址是不连续的，它不需要预先指定存储空间大小，或者在存储过程中涉及到扩容等操作,,同时它并没有涉及的元素的交换。 相比较顺序表，链表的查询操作性能会比较低。因此，如果我们的程序中查询操作比较多，建议使用顺序表，增删操作比较多，建议使用链表。

    1.2.4 链表反转

    单链表的反转，是面试中的一个高频题目。
    需求:
    原链表中数据为:1->2->3>4
    反转后链表中数据为:4->3->2->1
    反转API:
    public void reverse():对整个链表反转
    public Node reverse(Node curr):反转链表中的某个结点curr,并把反转后的curr结点返回
    使用递归可以完成反转，递归反转其实就是从原链表的第一个存数据的结点开始，依次递归调用反转每一个结点，直到把最后一个结点反转完毕，整个链表就反转完毕。
    image.png代码: ```java public void reverse() {

    1.  if (N == 0) {
    2.      //当前是空链表，不需要反转
    3.      return;
    4.  }
    5.  reverse(head.next);

    }

    public Node reverse(Node curr) {

    1.  //已经到了最后一个元素
    2.  if (curr.next == null) {
    3.      //反转后，头结点应该指向原链表中的最后一个元素
    4.      head.next = curr;
    5.      return curr;
    6.  }
    7.  //当前结点的上一个结点
    8.  Node pre = reverse(curr.next);
    9.  pre.next = curr;
    10.  //当前结点的下一个结点设为null
    11.  curr.next = null;
    12.  // 返回当前结点
    13.  return curr;

    }

//测试代码 public class Test { public static void main(String[] args) throws Exception { LinkList list = new LinkList<>(); list.insert(1); list.insert(2); list.insert(3); list.insert(4); for (Integer i : list) { System.out.print(i+” “); } System.out.println(); System.out.println(“——————————“); list.reverse(); for (Integer i : list) { System.out.print(i+” “); } } }

  1. <a name="3pGUw"></a>
  2. ## 1.2.5 快慢指针
  3. 快慢指针指的是定义两个指针，这两个指针的移动速度一块一慢，以此来制造出自己想要的差值，这个差值可以让我们找到链表上相应的结点。一般情况下，快指针的移动步长为慢指针的两倍
  4. <a name="g9O7W"></a>
  5. ### 1.2.5.1 中间值问题
  6. 我们先来看下面一段代码，然后完成需求。
  7. ```java
  8. public class MiddleTest {
  10.     public static void main(String[] args) {
  11.         Node<String> first = new Node<String>("aa", null);
  12.         Node<String> second = new Node<String>("bb", null);
  13.         Node<String> third = new Node<String>("cc", null);
  14.         Node<String> fourth = new Node<String>("dd", null);
  15.         Node<String> fifth = new Node<String>("ee", null);
  16.         Node<String> six = new Node<String>("ff", null);
  17.         Node<String> seven = new Node<String>("gg", null);
  19.         first.next = second;
  20.         second.next = third;
  21.         third.next = fourth;
  22.         fourth.next = fifth;
  23.         fifth.next = six;
  24.         six.next = seven;
  26.         //查找中间值
  27.         String mid = getMid(first);
  28.         System.out.println("中间值为:" + mid);
  30.     }
  32.     /**
  33.      * @param first 链表的首结点 * @return 链表的中间结点的值
  34.      */
  35.     public static String getMid(Node<String> first) {
  36.         return null;
  37.     }
  40.     //结点类
  41.     private static class Node<T> {
  42.         //存储数据
  43.         T item;
  44.         //下一个结点
  45.         Node next;
  47.         public Node(T item, Node next) {
  48.             this.item = item;
  49.             this.next = next;
  50.         }
  51.     }
  52. }

需求:
请完善测试类Test中的getMid方法，可以找出链表的中间元素值并返回。
利用快慢指针，我们把一个链表看成一个跑道，假设a的速度是b的两倍，那么当a跑完全程后，b刚好跑一半，以 此来达到找到中间节点的目的。
如下图，最开始，slow与fast指针都指向链表第一个节点，然后slow每次移动一个指针，fast每次移动两个指针。
image.png
代码：

  1.  /**
  2.      * @param first 链表的首结点
  3.      *              
  4.      * @return 链表的中间结点的值
  5.      */
  6.     public static String getMid(Node<String> first) {
  7.         Node<String> slow = first;
  8.         Node<String> fast = first;
  10.         while (fast != null && fast.next != null) {
  11.             slow = slow.next;
  12.             fast = fast.next.next;
  13.         }
  14.         return slow.item;
  15.     }

1.2.5.2 单向链表是否有环问题

image.png
看下面代码，完成需求:

  1. public class IsCircleTest {
  3.     public static void main(String[] args) {
  4.         Node<String> first = new Node<String>("aa", null);
  5.         Node<String> second = new Node<String>("bb", null);
  6.         Node<String> third = new Node<String>("cc", null);
  7.         Node<String> fourth = new Node<String>("dd", null);
  8.         Node<String> fifth = new Node<String>("ee", null);
  9.         Node<String> six = new Node<String>("ff", null);
  10.         Node<String> seven = new Node<String>("gg", null);
  12.         //完成结点之间的指向
  13.         first.next = second;
  14.         second.next = third;
  15.         third.next = fourth;
  16.         fourth.next = fifth;
  17.         fifth.next = six;
  18.         six.next = seven;
  19.         //产生环
  20.         seven.next = third;
  21.         //判断链表是否有环
  22.         boolean circle = isCircle(first);
  24.         System.out.println("first链表中是否有环:" + circle);
  26.     }
  28.     /**
  29.      * 判断链表中是否有环
  30.      *
  31.      * @param first 链表首结点
  32.      * @return ture为有环，false为无环
  33.      */
  34.     public static boolean isCircle(Node<String> first) {
  35.         return false;
  36.     }
  39.     //结点类
  40.     private static class Node<T> {
  41.         //存储数据
  42.         T item;
  43.         //下一个结点
  44.         Node next;
  46.         public Node(T item, Node next) {
  47.             this.item = item;
  48.             this.next = next;
  49.         }
  50.     }
  51. }


需求:
请完善测试类Test中的isCircle方法，返回链表中是否有环。
使用快慢指针的思想，还是把链表比作一条跑道，链表中有环，那么这条跑道就是一条圆环跑道，在一条圆环跑道中，两个人有速度差，那么迟早两个人会相遇，只要相遇那么就说明有环。

代码:**

  1. /**
  2.      * 判断链表中是否有环
  3.      *
  4.      * @param first 链表首结点
  5.      * @return ture为有环，false为无环
  6.      */
  7.     public static boolean isCircle(Node<String> first) {
  9.         Node<String> slow = first;
  10.         Node<String> fast = first;
  12.         while (fast != null && fast.next != null) {
  13.             slow = slow.next;
  14.             fast = fast.next.next;
  16.             if(Objects.equals(slow.item, fast.item)) {
  17.                 return true;
  18.             }
  19.         }
  20.         return false;
  21.     }

1.2.5.3 有环链表入口问题

同样看下面这段代码，完成需求:

  1. public class CircleEntranceTest {
  3.     public static void main(String[] args) {
  4.         Node<String> first = new Node<String>("aa", null);
  5.         Node<String> second = new Node<String>("bb", null);
  6.         Node<String> third = new Node<String>("cc", null);
  7.         Node<String> fourth = new Node<String>("dd", null);
  8.         Node<String> fifth = new Node<String>("ee", null);
  9.         Node<String> six = new Node<String>("ff", null);
  10.         Node<String> seven = new Node<String>("gg", null);
  12.         //完成结点之间的指向
  13.         first.next = second;
  14.         second.next = third;
  15.         third.next = fourth;
  16.         fourth.next = fifth;
  17.         fifth.next = six;
  18.         six.next = seven;
  19.         //产生环
  20.         seven.next = third;
  22.         //查找环的入口结点
  23.         Node<String> entrance = getEntrance(first);
  24.         System.out.println("first链表中环的入口结点元素为:" + entrance.item);
  27.     }
  29.     /**
  30.      * 查找有环链表中环的入口结点 
  31.      * @param first 链表首结点
  32.      *
  33.      * @return 环的入口结点
  34.      */
  35.     public static Node getEntrance(Node<String> first) {
  36.         return null;
  37.     }
  39.     /**
  40.      * 判断链表中是否有环
  41.      *
  42.      * @param first 链表首结点
  43.      * @return ture为有环，false为无环
  44.      */
  45.     public static boolean isCircle(Node<String> first) {
  47.         Node<String> slow = first;
  48.         Node<String> fast = first;
  50.         while (fast != null && fast.next != null) {
  51.             slow = slow.next;
  52.             fast = fast.next.next;
  54.             if (Objects.equals(slow.item, fast.item)) {
  55.                 return true;
  56.             }
  57.         }
  58.         return false;
  59.     }
  62.     //结点类
  63.     private static class Node<T> {
  64.         //存储数据
  65.         T item;
  66.         //下一个结点
  67.         Node next;
  69.         public Node(T item, Node next) {
  70.             this.item = item;
  71.             this.next = next;
  72.         }
  73.     }
  74. }

需求:
请完善Test类中的getEntrance方法，查找有环链表中环的入口结点。
当快慢指针相遇时，我们可以判断到链表中有环，这时重新设定一个新指针指向链表的起点，且步长与慢指针一样 为1，则慢指针与“新”指针相遇的地方就是环的入口。证明这一结论牵涉到数论的知识，这里略，只讲实现。
image.png
image.png
image.png
代码:

  1. /**
  2.      * 查找有环链表中环的入口结点
  3.      *
  4.      * @param first 链表首结点
  5.      * @return 环的入口结点
  6.      */
  7.     public static Node getEntrance(Node<String> first) {
  8.         Node<String> slow = first;
  9.         Node<String> fast = first;
  10.         Node<String> temp = null;
  11.         while (fast != null && fast.next != null) {
  12.             fast = fast.next.next;
  13.             slow = slow.next;
  14.             if (fast.equals(slow)) {
  15.                 temp = first;
  16.                 continue;
  17.             }
  18.             if (temp != null) {
  19.                 temp = temp.next;
  20.                 if (temp.equals(slow)) {
  21.                     return temp;
  22.                 }
  23.             }
  24.         }
  25.         return null;
  26.     }

1.2.6 循环链表

循环链表，顾名思义，链表整体要形成一个圆环状。在单向链表中，最后一个节点的指针为null，不指向任何结
点，因为没有下一个元素了。要实现循环链表，我们只需要让单向链表的最后一个节点的指针指向头结点即可。
image.png**

1.2.7 约瑟夫问题

问题描述:
传说有这样一个故事，在罗马人占领乔塔帕特后，39 个犹太人与约瑟夫及他的朋友躲到一个洞中，39个犹太人决 定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，第一个人从1开始报数，依次往 后，如果有人报数到3，那么这个人就必须自杀，然后再由他的下一个人重新从1开始报数，直到所有人都自杀身亡 为止。然而约瑟夫和他的朋友并不想遵从。于是，约瑟夫要他的朋友先假装遵从，他将朋友与自己安排在第16个与 第31个位置，从而逃过了这场死亡游戏 。
问题转换:
41个人坐一圈，第一个人编号为1，第二个人编号为2，第n个人编号为n。1.编号为1的人开始从1报数，依次向后，报数为3的那个人退出圈;2.自退出那个人开始的下一个人再次从1开始报数，以此类推;3.求出最后退出的那个人的编号。
图示:
image.png
解题思路:

  1. 构建含有41个结点的单向循环链表，分别存储1~41的值，分别代表这41个人;
  2. 使用计数器count，记录当前报数的值;
  3. 遍历链表，每循环一次，count++;
  4. 判断count的值，如果是3，则从链表中删除这个结点并打印结点的值，把count重置为0;

代码:

  1. public class JospheTest {
  3.     public static void main(String[] args) {
  4.         Node<Integer> first = null;
  5.         Node<Integer> pre = null;
  7.         for (int i = 1; i <= 41; i++) {
  8.             if (i == 1) {
  9.                 Node<Integer> node = new Node(i, null);
  10.                 first = node;
  11.                 pre = node;
  12.                 continue;
  13.             }
  15.             Node<Integer> node = new Node(i, null);
  16.             pre.next = node;
  17.             pre = node;
  19.             if (i == 41) {
  20.                 //构建循环链表，让最后一个结点指向第一个结点
  21.                 pre.next = first;
  22.             }
  23.         }
  25.         Node<Integer> cur = first;
  26.         int cnt = 1;
  27.         while (cur.next != cur) {
  28.             cnt++;
  29.             if(cnt == 3) {
  30.                 Node<Integer> next = cur.next;
  31.                 System.out.println("退出的是：" + next.item);
  32.                 //删除当前结点
  33.                 cur.next = next.next;
  34.                 //重置
  35.                 cnt = 1;
  36.             }
  37.             cur = cur.next;
  38.         }
  40.         System.out.println("最后剩下：" + cur.item);
  43.     }
  45.     //结点类
  46.     private static class Node<T> {
  47.         //存储数据
  48.         T item;
  49.         //下一个结点
  50.         Node next;
  52.         public Node(T item, Node next) {
  53.             this.item = item;
  54.             this.next = next;
  55.         }
  56.     }
  57. }

1.3 栈

1.3.1 栈概述

1.3.1.1 生活中的栈

存储货物或供旅客住宿的地方,可引申为仓库、中转站 。例如我们现在生活中的酒店，在古时候叫客栈，是供旅客 休息的地方，旅客可以进客栈休息，休息完毕后就离开客栈。

1.3.1.2 计算机中的栈

我们把生活中的栈的概念引入到计算机中，就是供数据休息的地方，它是一种数据结构，数据既可以进入到栈中，又可以从栈中出去。
栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出 的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据(最后一 个数据被第一个读出来)。
我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈。
image.png

1.3.2 栈的实现

1.3.2.1 栈API设计

  1.             |                     **类名**                                                                         | **Stack**                                                                                         |

| —- | —- | | 构造方法 | Stack:创建Stack对象 | | 成员方法 | 1.public boolean isEmpty():判断栈是否为空，是返回true，否返回false
2.public int size():获取栈中元素的个数
3.public T pop():弹出栈顶元素
4.public void push(T t):向栈中压入元素t | | 成员变量 | 1.private Node head:记录首结点
2.private int N:当前栈的元素个数 |

1.3.2.2 栈代码实现

  1. public class Stack<T> implements Iterable<T> {
  3.     private Node head;
  5.     //当前栈的元素个数
  6.     private int N;
  8.     public Stack() {
  9.         head = new Node(null, null);
  10.         N = 0;
  11.     }
  13.     public boolean isEmpty() {
  14.         return N == 0;
  15.     }
  17.     public int size() {
  18.         return N;
  19.     }
  21.     public T pop() {
  22.         Node first = head.next;
  23.         if(first == null) {
  24.             return null;
  25.         }
  27.         head.next = first.next;
  29.         N--;
  30.         return first.item;
  32.     }
  34.     public void push(T t) {
  35.         Node first = head.next;
  36.         Node newNode = new Node(t, first);
  37.         head.next = newNode;
  39.         N ++;
  40.     }
  44.     //结点类
  45.     private class Node {
  46.         //存储数据
  47.         T item;
  48.         //下一个结点
  49.         Node next;
  51.         public Node(T item, Node next) {
  52.             this.item = item;
  53.             this.next = next;
  54.         }
  55.     }
  57.     @Override
  58.     public Iterator<T> iterator() {
  59.         return new SIterator();
  60.     }
  62.     private class SIterator implements Iterator<T> {
  64.         private Node node;
  66.         public SIterator() {
  67.             this.node = head;
  68.         }
  70.         @Override
  71.         public boolean hasNext() {
  72.             return node.next != null;
  73.         }
  75.         @Override
  76.         public T next() {
  77.             node = node.next;
  78.             return node.item;
  79.         }
  80.     }
  81. }
  83. public class StackTest {
  85.     public static void main(String[] args) {
  86.         Stack<String> stack = new Stack<>();
  87.         stack.push("a");
  88.         stack.push("b");
  89.         stack.push("c");
  90.         stack.push("d");
  91.         for (String str : stack) {
  92.             System.out.print(str + " ");
  93.         }
  94.         System.out.println("-----------------------------");
  95.         String result = stack.pop();
  96.         System.out.println("弹出了元素:" + result);
  97.         System.out.println(stack.size());
  98.     }
  99. }

1.3.3 案例

1.3.3.1 括号匹配问题

问题描述:

  1. 给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。 
  2. 例如：
  3. "(上海)(长安)"：正确匹配 "上海((长安))"：正确匹配 
  4. "上海(长安(北京)(深圳)南京)":正确匹配 
  5. "上海(长安))"：错误匹配 
  6. "((上海)长安"：错误匹配

示例代码：

  1. public class BracketsMatch {
  2.     public static void main(String[] args) {
  3.         String str = "(上海(长安)())";
  4.         boolean match = isMatch(str);
  5.         System.out.println(str + "中的括号是否匹配：" + match);
  6.     }
  8.     /*** 判断str中的括号是否匹配 *
  9.      * @param str 括号组成的字符串
  10.      *
  11.      * @return 如果匹配，返回true，如果不匹配，返回false */
  12.     public static boolean isMatch(String str) {
  13.         return false;
  14.     }
  15. }

请完善 isMath方法。
分析：

  1. 1.创建一个栈用来存储左括号 
  2. 2.从左往右遍历字符串，拿到每一个字符 
  3. 3.判断该字符是不是左括号，如果是，放入栈中存储 
  4. 4.判断该字符是不是右括号，如果不是，继续下一次循环 
  5. 5.如果该字符是右括号，则从栈中弹出一个元素t； 
  6. 6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号 
  7. 7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配

代码实现：

  1. /*** 判断str中的括号是否匹配 *
  2.      * @param str 括号组成的字符串
  3.      *
  4.      * @return 如果匹配，返回true，如果不匹配，返回false */
  5.     public static boolean isMatch(String str) {
  6.         //1.创建一个栈用来存储左括号
  7.         Stack<String> chars = new Stack<>();
  8.         //2.遍历字符串
  9.         for(int i=0; i<str.length(); i++) {
  10.             String ch = str.charAt(i) + "";
  12.             //3. 如果匹配到左括号，入栈
  13.             if("(".equals(ch)) {
  14.                 chars.push(ch);
  15.             }
  16.             //4. 如果匹配到右括号，出栈
  17.             if(")".equals(ch)) {
  18.                 String pop = chars.pop();
  19.                 //5. 如果出栈内容为空，说明不匹配
  20.                 if(pop == null) {
  21.                     return false;
  22.                 }
  23.             }
  24.         }
  26.         //7. 如果栈为空，说明匹配正确
  27.         if(chars.isEmpty()) {
  28.             return true;
  29.         }
  30.         return false;
  31.     }

1.3.3.2 逆波兰表达式求值问题

逆波兰表达式求值问题是我们计算机中经常遇到的一类问题，要研究明白这个问题，首先我们得搞清楚什么是逆波兰表达式？要搞清楚逆波兰表达式，我们得从中缀表达式说起。
中缀表达式：
中缀表达式就是我们平常生活中使用的表达式，例如：1+32,2-(1+3)等等，中缀表达式的特点是：二元运算符总
是置于两个操作数中间。
中缀表达式是人们最喜欢的表达式方式，因为简单，易懂。但是对于计算机来说就不是这样了，因为中缀表达式的运算顺序不具有规律性。不同的运算符具有不同的优先级，如果计算机执行中缀表达式，需要解析表达式语义，做大量的优先级相关操作。
逆波兰表达式(后缀表达式)：
逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法，后缀表达式的特点：运算符总是放在跟它相关的操作数之后。
image.png
*需求：
给定一个只包含加减乘除四种运算的逆波兰表达式的数组表示方式，求出该逆波兰表达式的结果。

  1. public class ReversePolishNotation {
  3.     public static void main(String[] args) {
  4.         //中缀表达式3*（17-15）+18/6的逆波兰表达式如下
  5.         String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
  6.         int result = caculate(notation);
  7.         System.out.println("逆波兰表达式的结果为：" + result);
  8.     }
  10.     /**
  11.      *  @param notaion 逆波兰表达式的数组表示方式 
  12.      *  
  13.      *  @return 逆波兰表达式的计算结果 */
  14.     public static int caculate(String[] notaion) {
  15.         return -1;
  16.     }
  17. }

完善caculate方法，计算出逆波兰表达式的结果。
分析：

  1. 1.创建一个栈对象oprands存储操作数 
  2. 2.从左往右遍历逆波兰表达式，得到每一个字符串 
  3. 3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中 
  4. 4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2 
  5. 5.使用该运算符计算o1和o2，得到结果result
  6. 6.把该结果压入oprands栈中 
  7. 7.遍历结束后，拿出栈中最终的结果返回

代码实现：

  1. /**
  2.      * @param notaion 逆波兰表达式的数组表示方式
  3.      * @return 逆波兰表达式的计算结果
  4.      */
  5.     public static int caculate(String[] notaion) {
  6.         //1.创建一个栈对象oprands存储操作数
  7.         Stack<Integer> oprands = new Stack<>();
  8.         //2.从左往右遍历逆波兰表达式，得到每一个字符串
  9.         for (int i = 0; i < notaion.length; i++) {
  10.             String curr = notaion[i];
  11.             //3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中
  12.             Integer o1;
  13.             Integer o2;
  14.             Integer result;
  15.             switch (curr) {
  16.                 case "+":
  17.                     //4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
  18.                     o1 = oprands.pop();
  19.                     o2 = oprands.pop();
  20.                     //5.使用该运算符计算o1和o2，得到结果result
  21.                     result = o2 + o1; //6.把该结果压入oprands栈中
  22.                     oprands.push(result);
  23.                     break;
  24.                 case "-":
  25.                     //4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
  26.                     o1 = oprands.pop();
  27.                     o2 = oprands.pop();
  28.                     //5.使用该运算符计算o1和o2，得到结果result
  29.                     result = o2 - o1;
  30.                     //6.把该结果压入oprands栈中
  31.                     oprands.push(result);
  32.                     break;
  33.                 case "*":
  34.                     //4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
  35.                     o1 = oprands.pop();
  36.                     o2 = oprands.pop();
  37.                     //5.使用该运算符计算o1和o2，得到结果result
  38.                     result = o2 * o1; //6.把该结果压入oprands栈中
  39.                     oprands.push(result);
  40.                     break;
  41.                 case "/":
  42.                     //4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
  43.                     o1 = oprands.pop();
  44.                     o2 = oprands.pop();
  45.                     //5.使用该运算符计算o1和o2，得到结果result
  46.                     result = o2 / o1; //6.把该结果压入oprands栈中
  47.                     oprands.push(result);
  48.                     break;
  49.                 default:
  50.                     oprands.push(Integer.parseInt(curr));
  51.                     break;
  52.             }
  53.         }
  54.         //7.遍历结束后，拿出栈中最终的结果返回
  55.         Integer result = oprands.pop();
  56.         return result;
  57.     }

1.4 队列

队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。
image.png

1.4.1 队列的API设计

  1.             |                     **类名**                                                                         | **Queue**                                                                                         |

| —- | —- | | 构造方法 | Queue():创建Queue对象 | | 成员方法 | 1.public boolean isEmpty():判断队列是否为空，是返回true，否返回false
2.public int size():获取队列中元素的个数
3.public T dequeue():从队列中拿出一个元素
4.public void enqueue(T t):往队列中插入一个元素 | | 成员变量 | 1.private Node head:记录首结点
2.private int N:当前栈的元素个数
3.private Node last:记录最后一个结点 |

1.4.2 队列的实现

  1. public class Queue<T> implements Iterable<T> {
  2.     private Node head;
  4.     private Node last;
  6.     private int N;
  8.     public Queue() {
  9.         head = new Node(null, null);
  10.         last = null;
  12.         N = 0;
  13.     }
  15.     public boolean isEmpty() {
  16.         return N == 0;
  17.     }
  19.     public int size() {
  20.         return N;
  21.     }
  23.     //从队列中拿出一个元素
  24.     public T dequeue() {
  25.         if (isEmpty()) {
  26.             return null;
  27.         }
  28.         Node oldNode = head.next;
  29.         head.next = oldNode.next;
  30.         N--;
  31.         if (isEmpty()) {
  32.             last = null;
  33.         }
  34.         return oldNode.item;
  36.     }
  38.     public void enqueue(T t) {
  39.         Node newNode = new Node(t, null);
  41.         if (last == null) {
  42.             last = newNode;
  43.             head.next = last;
  44.         } else {
  45.             Node oldLast = last;
  46.             last = newNode;
  47.             oldLast.next = last;
  49.         }
  51.         N++;
  52.     }
  54.     @Override
  55.     public Iterator<T> iterator() {
  56.         return new QIterator();
  57.     }
  59.     private class QIterator implements Iterator<T> {
  61.         private Node node;
  63.         public QIterator() {
  64.             this.node = head;
  65.         }
  67.         @Override
  68.         public boolean hasNext() {
  69.             return node.next != null;
  70.         }
  72.         @Override
  73.         public T next() {
  74.             node = node.next;
  75.             return node.item;
  76.         }
  77.     }
  80.     //结点类
  81.     private class Node {
  82.         //存储数据
  83.         T item;
  84.         //下一个结点
  85.         Node next;
  87.         public Node(T item, Node next) {
  88.             this.item = item;
  89.             this.next = next;
  90.         }
  91.     }
  92. }
  95. public class QueueTest {
  97.     public static void main(String[] args) {
  98.         Queue<String> queue = new Queue<>();
  99.         queue.enqueue("a");
  100.         queue.enqueue("b");
  101.         queue.enqueue("c");
  102.         queue.enqueue("d");
  103.         for (String str : queue) {
  104.             System.out.print(str + " ");
  105.         }
  106.         System.out.println("-----------------------------");
  107.         String result = queue.dequeue();
  108.         System.out.println("出列了元素：" + result);
  109.         System.out.println(queue.size());
  110.     }
  111. }
  1.                                                             <br />                                                                                                                    <br />                                                                                                                                                                                    <br />                                                            <br />                                                            <br />                                                            <br />                                                                                                                        <br />                                                            <br />                                                            <br />                                        <br />                                                                                <br />                                        <br />                                        <br />                                        <br />                                                            <br />                                                            <br />                                                                                                                        <br />                                                            <br />                                                                                                                    **        **                                                    <br />                                                            
  3.                                                         <br />                                                            <br />                                                                                                                        <br />                                                            <br />                                                            <br />                                                            
  5.                                                         <br />                                                            <br />                                                                                                                                                                                                                                                        <br />                                                                                                                                                                                        <br />                                                            

  1.                                                         <br />                                                            <br />                                                            <br />