4. 线性表

线性表是最基本、最简单、也是最常用的一种数据结构(逻辑结构)。一个线性表是n个具有相同特性的数据元素的有限序列。

前驱元素：

若A元素在B元素的前面，则称A为B的前驱元素

后继元素：

若B元素在A元素的后面，则称B为A的后继元素

**线性表的特征：数据元素之间具有一种“一对一”**的逻辑关系。

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

如果把线性表用数学语言来定义，则可以表示为(a1,…ai-1,ai,ai+1,…an)，ai-1领先于ai,ai领先于ai+1，称ai-1是ai的

前驱元素，ai+1是ai的后继元素。

线性表的分类：

线性表中数据存储的方式可以是顺序存储，也可以是链式存储，按照数据的存储方式不同，可以把线性表分为顺序

表和链表。

4.1 顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

4.1.1 顺序表的实现

顺序表API设计：

顺序表的代码实现：

package com.ynu.Java版算法.U4_线性表.T1_顺序表.S1_顺序表实现;

import org.omg.CORBA.Object;

//顺序表代码
public class SequenceList<T> {

    // 存储元素的数组
    private T[] eles;

    // 记录当前顺序表的元素个数
    private int N;

    // 构造方法
    public SequenceList(int capacity) {
        // 初始化这个内部数组
        eles = (T[])new Object[capacity];
        // 初始化大小
        N = 0;
    }

    // 判断当前线性表 是否为空
    public boolean isEmpty(){
        return N == 0;
    }

    //获取线性表的长度
    public int length(){
        return N;
    }

    // 获取指定位置的元素
    public T get(int i){
        if (i < 0 || i >= N){
            throw new RuntimeException("当前元素不存在");
        }
        return eles[i];
    }

    // 向线型表中添加元素t  末尾添加
    public void insert(T t){
        if (N == eles.length){
            throw new RuntimeException("当前表已满了");
        }
        eles[N++] = t;
    }

    //在i元素处插入元素t
    public void insert(int i,T t){
        if (i==eles.length){
            throw new RuntimeException("当前表已满");
        }
        if (i<0 || i>N){
            throw new RuntimeException("插入的位置不合法");
        }
        for (int index = N; index > i ; index--) {
            eles[index] = eles[index-1];    // i之后的元素后移
        }

        //把t放到i位置处
        eles[i]=t;
        //元素数量+1
        N++;
    }

    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }

        T result = eles[i];  //记录当前移除的元素

        for (int index = i; index < N-1  ; index++) {
            eles[index] = eles[index+1];
        }

        N--;

        return result;
    }

    //查找t元素第一次出现的位置
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

}

// 测试代码

4.1.2 顺序表的遍历

一般作为容器存储数据，都需要向外部提供遍历的方式，因此我们需要给顺序表提供遍历方式。

在java中，遍历集合的方式一般都是用的是foreach循环，如果想让我们的SequenceList也能支持foreach循环，则需要做如下操作：

1.让SequenceList实现Iterable接口，重写iterator方法；

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

代码：

package com.ynu.Java版算法.U4_线性表.T1_顺序表.S1_顺序表遍历;


import java.util.Iterator;

//顺序表代码
public class SequenceList<T> implements Iterable<T>{

    // 存储元素的数组
    private T[] eles;

    // 记录当前顺序表的元素个数
    private int N;

    // 构造方法
    public SequenceList(int capacity) {
        // 初始化这个内部数组
        eles = (T[])new Object[capacity];
        // 初始化大小
        N = 0;
    }

    // 判断当前线性表 是否为空
    public boolean isEmpty(){
        return N == 0;
    }

    //获取线性表的长度
    public int length(){
        return N;
    }

    // 获取指定位置的元素
    public T get(int i){
        if (i < 0 || i >= N){
            throw new RuntimeException("当前元素不存在");
        }
        return eles[i];
    }

    // 向线型表中添加元素t  末尾添加
    public void insert(T t){
        if (N == eles.length){
            throw new RuntimeException("当前表已满了");
        }
        eles[N++] = t;
    }

    //在i元素处插入元素t
    public void insert(int i,T t){
        if (i==eles.length){
            throw new RuntimeException("当前表已满");
        }
        if (i<0 || i>N){
            throw new RuntimeException("插入的位置不合法");
        }
        for (int index = N; index > i ; index--) {
            eles[index] = eles[index-1];    // i之后的元素后移
        }

        //把t放到i位置处
        eles[i]=t;
        //元素数量+1
        N++;
    }

    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }

        T result = eles[i];  //记录当前移除的元素

        for (int index = i; index < N-1  ; index++) {
            eles[index] = eles[index+1];
        }

        N--;

        return result;
    }

    //查找t元素第一次出现的位置
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

    //将一个线性表置为空表
    public void clear(){
        N=0;
    }


    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    class MyIterator implements Iterator<T>{

        // 当前遍历的位置
        private int position;

        public MyIterator() {
            this.position = 0;
        }

        @Override
        public boolean hasNext() {
            return position < N;
        }

        @Override
        public T next() {
            return eles[position++];
        }
    }

}


package com.ynu.Java版算法.U4_线性表.T1_顺序表.S1_顺序表遍历;

public class Main {
    public static void main(String[] args) {

        SequenceList<String> list = new SequenceList(10);
        list.insert("ybh");
        list.insert("lmj");
        list.insert("czx");
        list.insert("lh");

        for (String s : list) {
            System.out.println(s);
        }

    }
}

4.1.3 顺序表的容量可变

在之前的实现中，当我们使用SequenceList时，先new SequenceList(5)创建一个对象，创建对象时就需要指定容

器的大小，初始化指定大小的数组来存储元素，当我们插入元素时，如果已经插入了5个元素，还要继续插入数

据，则会报错，就不能插入了。这种设计不符合容器的设计理念，因此我们在设计顺序表时，应该考虑它的容量的

伸缩性。

考虑容器的容量伸缩性，其实就是改变存储数据元素的数组的大小，那我们需要考虑什么时候需要改变数组的大

小？

1.添加元素时：

添加元素时，应该检查当前数组的大小是否能容纳新的元素，如果不能容纳，则需要创建新的容量更大的数组，我

们这里创建一个是原数组两倍容量的新数组存储元素。

2.移除元素时：

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

package com.ynu.Java版算法.U4_线性表.T1_顺序表.S2_顺序表的容量可变;


import java.util.Arrays;
import java.util.Iterator;

//顺序表代码
public class SequenceList<T> implements Iterable<T>{

    // 存储元素的数组
    private T[] eles;

    // 记录当前顺序表的元素个数
    private int N;

    // 构造方法
    public SequenceList(int capacity) {
        // 初始化这个内部数组
        eles = (T[])new Object[capacity];
        // 初始化大小
        N = 0;
    }

    // 判断当前线性表 是否为空
    public boolean isEmpty(){
        return N == 0;
    }

    //获取线性表的长度
    public int length(){
        return N;
    }

    // 获取指定位置的元素
    public T get(int i){
        if (i < 0 || i >= N){
            throw new RuntimeException("当前元素不存在");
        }
        return eles[i];
    }

    // 向线型表中添加元素t  末尾添加
    public void insert(T t){
        //元素已经放满了数组，需要扩容
        if (N == eles.length){
            revise(eles.length*2);
        }
        eles[N++] = t;
    }

    //在i元素处插入元素t
    public void insert(int i,T t){

        if (i<0 || i>N){
            throw new RuntimeException("插入的位置不合法");
        }

        if (N==eles.length){
            revise(eles.length*2);
        }

        for (int index = N; index > i ; index--) {
            eles[index] = eles[index-1];    // i之后的元素后移
        }

        //把t放到i位置处
        eles[i]=t;
        //元素数量+1
        N++;
    }

    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }

        T result = eles[i];  //记录当前移除的元素

        for (int index = i; index < N-1  ; index++) {
            eles[index] = eles[index+1];
        }
        N--;

        if (N>0 && N < eles.length / 4){
            revise(eles.length/2);
        }

        return result;
    }

    //查找t元素第一次出现的位置
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

    //将一个线性表置为空表
    public void clear(){
        N=0;
    }


    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    class MyIterator implements Iterator<T>{

        // 当前遍历的位置
        private int position;

        public MyIterator() {
            this.position = 0;
        }

        @Override
        public boolean hasNext() {
            return position < N;
        }

        @Override
        public T next() {
            return eles[position++];
        }
    }


    // 改变容量
    public void revise(int newSize){
        // 记录旧数组
        T[] temp = eles;
        // 创建新数组
        eles = (T[])new Object[newSize];

        //把旧数组中的元素拷贝到新数组
        for (int i = 0; i < N; i++) {
            eles[i] = temp[i];
        }

    }

    // 返回线性表表的容量
    public int capacity(){
        return eles.length;
    }


    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < N; i++) {
            sb.append(eles[i]+" ");
        }
        return sb.toString();
    }
}

package com.ynu.Java版算法.U4_线性表.T1_顺序表.S2_顺序表的容量可变;

public class Main {
    public static void main(String[] args) {
        SequenceList<String> list = new SequenceList(2);
        System.out.println("当前集合的容量为："+list.capacity());

        list.insert("ybh");
        list.insert("lmj");
        list.insert("czx");
        list.insert("lh");
        System.out.println("现在集合的容量为："+list.capacity());


        list.insert(4,"aa");
        list.insert(4,"aa");
        list.insert(4,"aa");
        list.insert(4,"aa");
        list.insert(4,"aa");
        System.out.println(list);
        System.out.println("现在集合的容量为："+list.capacity());

        list.remove(1);
        list.remove(1);
        list.remove(1);
        list.remove(1);
        list.remove(1);
        list.remove(1);
        list.remove(1);

        System.out.println(list);
        System.out.println("现在集合的容量为："+list.capacity());

    }
}

4.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);

由于顺序表的底层由数组实现，数组的长度是固定的，所以在操作的过程中涉及到了容器扩容操作。这样会导致顺序表在使用过程中的时间复杂度不是线性的，在某些需要扩容的结点处，耗时会突增，尤其是元素越多，这个问题越明显。

4.1.5 java中ArrayList实现

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

1.是否用数组实现；是

2.有没有扩容操作；有

3.有没有提供遍历方式；有

4.2 链表

之前我们已经使用顺序存储结构实现了线性表，我们会发现虽然顺序表的查询很快，时间复杂度为O(1),但是增删的效率是比较低的，因为每一次增删操作都伴随着大量的数据元素移动。这个问题有没有解决方案呢？有，我们可以使用另外一种存储结构实现线性表，链式存储结构。

链表是一种物理存储单元上非连续、非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑顺序，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点（链表中的每一个元素称为结点）组成，结点可以在运行时动态生成。

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

结点API设计：

结点类实现：

package com.ynu.Java版算法.U4_线性表.T2_链表.S1_节点类实现;

public class Node<T> {

    // 数据域
    public T elem;
    // 指针域
    public Node next;

    public Node(T elem, Node next) {
        this.elem = elem;
        this.next = next;
    }
}


package com.ynu.Java版算法.U4_线性表.T2_链表.S1_节点类实现;

public class Main {
    public static void main(String[] args) {
        // 构建节点
        Node<Integer> first = new Node<Integer>(11, null);
        Node<Integer> second = new Node<Integer>(13, null);
        Node<Integer> third = new Node<Integer>(12, null);
        Node<Integer> fourth = new Node<Integer>(8, null);
        Node<Integer> fifth = new Node<Integer>(9, null);

        //生成链表
        first.next = second;
        second.next = third;
        third.next = fourth;
        fourth.next = fifth;

        // 遍历链表
        Node curr = first;
        while (curr!=null){
            System.out.println(curr.elem);
            curr = curr.next;
        }

    }
}

4.2.1 单向链表

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

4.2.1.1 单向链表API设计

4.2.1.2 单向链表代码实现

package com.ynu.Java版算法.U4_线性表.T2_链表.S2_单向链表;

import java.util.Iterator;

public class LinkList<T> implements Iterable<T>{
    // 头结点
    private Node head;

    // 记录链表长度
    private int N;

    public LinkList() {
        head = new Node(null, null);
        N = 0;
    }

    // 清空链表
    public void clear() {
        head.item = null;
        head.next = null;
    }

    // 判断链表是否为空
    public boolean isEmpty() {
        return N == 0;
    }

    // 获取线性表中元素的个数
    public int length() {
        return N;
    }

    // 获取链表中第i个元素的值  头结点不是索引为0的节点
    public T get(int i) {
        if (i < 0 || i >= N) {
            throw new RuntimeException("参数非法");
        }
        Node curr = head;
        for (int j = 0; j <= i; j++) {
            curr = curr.next;
        }
        return curr.item;
    }

    // 向链表末尾添加元素
    public void insert(T t) {
        Node n = head;
        while (n.next != null) {
            n = n.next;
        }
        Node newNode = new Node(t, null);
        n.next = newNode;
        N++;

    }

    //向指定位置i处，添加元素t
    public void insert(int i, T t) {
        if (i < 0 || i >= N) {
            throw new RuntimeException("参数非法");
        }

        Node pre = head;
        for (int j = 0; j < i; j++) {
            pre = pre.next;
        }
        Node newNode = new Node(t, pre.next);
        pre.next = newNode;
        N++;

    }

    //删除指定位置i处的元素，并返回被删除的元素
    public T remove(int i) {
        if (i < 0 || i >= N) {
            throw new RuntimeException("位置不合法");
        }
        //寻找i之前的元素
        Node pre = head;
        for (int index = 0; index <= i - 1; index++) {
            pre = pre.next;
        }
        //当前i位置的结点
        Node curr = pre.next;
        //前一个结点指向下一个结点，删除当前结点
        pre.next = curr.next;
        //长度-1
        N--;
        return curr.item;
    }

    //查找元素t在链表中第一次出现的位置
    public int indexOf(T t){
        Node n = head;
        for (int i = 0;n.next!=null;i++){
            n = n.next;
            if (n.item.equals(t)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public Iterator<T> iterator() {
        return new LIterator();
    }

    private class LIterator implements Iterator<T>{
        private Node n;
        public LIterator() {
            this.n = head;
        }
        @Override
        public boolean hasNext() {
            return n.next!=null;
        }
        @Override
        public T next() {
            n = n.next;
            return n.item;
        }
    }

    private class Node {
        // 数据域
        T item;
        // 指针域
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
}

package com.ynu.Java版算法.U4_线性表.T2_链表.S2_单向链表;

public class Main {
    public static void main(String[] args) {
        LinkList<String> list = new LinkList<>();
        list.insert("张三");
        list.insert("李四");
        list.insert("王五");
        list.insert("赵六");

        // 增强for遍历
        for (String s : list) {
            System.out.println(s);
        }

        //测试length方法
        System.out.println(list.length());
        System.out.println("-------------------");
        //测试get方法
        System.out.println(list.get(2));
        System.out.println("------------------------");
        //测试remove方法
        String remove = list.remove(1);
        System.out.println(remove);
        System.out.println(list.length());
        System.out.println("----------------");;
        for (String s : list) {
            System.out.println(s);
        }

    }
}

4.2.2 双向链表

双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。

按照面向对象的思想，我们需要设计一个类，来描述结点这个事物。由于结点是属于链表的，所以我们把结点类作

为链表类的一个内部类来实现

4.2.2.1 结点API设计

4.2.2.2 双向链表API设计

4.2.2.3 双向链表代码实现

package com.ynu.Java版算法.U4_线性表.T2_链表.S3_双向链表;

import java.util.Iterator;

public class TowWayLinkList<T> implements Iterable<T>{
    // 首节点  首节点不放数据
    private Node head;

    // 尾结点  尾结点是要放数据的
    private Node last;

    // 链表的长度
    private int N;

    public TowWayLinkList() {
        last = null;   // 尾结点初始化
        head = new Node(null,null,null); // 首节点初始化
        N=0;
    }

    // 空置线性表
    public void clear(){
        last = null;
        head.next = last;
        head.pre = null;
        head.item = null;
        N = 0;
    }

    //获取链表长度
    public int length(){
        return N;
    }

    //判断链表是否为空
    public boolean isEmpty(){
        return N==0;
    }

    //从尾部插入元素t
    public void insertLast(T t){
        // 如果此时链表为空
        if (last==null){
            last = new Node(t,head,null);
            head.next = last;
        }else {
            Node newNode = new Node(t,last,null);
            last.next = newNode;
            last = newNode;
        }
        //长度加1
        N++;

    }

    //从头部插入元素t
    public void insertFirst(T t){
        // 如果此时链表为空
        if (last==null){
            last = new Node(t,head,null);
            head.next = last;
        }else {
            Node newNode = new Node(t,head,head.next);
            head.next = newNode;
            head.next.pre = newNode;
        }
        //长度加1
        N++;

    }

    //向指定位置i处插入元素t
    public void insert(int i ,T item){
        if (i<0 || i>= N){
            throw new RuntimeException("插入位置不合法");
        }

        Node pre = head;
        for (int index = 0; index < i; index++) {
            pre = pre.next;
        }
        //当前结点
        Node curr = pre.next;
        //构建新结点
        Node newNode = new Node(item,pre,curr);
        curr.pre = newNode;
        pre.next = newNode;
        N++;
    }

    //获取指定位置i处的元素
    public T get(int i){
        if (i<0 || i>=N){
            throw new RuntimeException("位置不合法");
        }

        Node n = head;
        for (int index = 0; index <= i; index++) {
            n = n.next;
        }
        return n.item;
    }

    //找到元素t在链表中第一次出现的位置
    public int indexOf(T t){
        Node n= head;
        for (int i=0;n.next!=null;i++){
            n = n.next;
            if (n.next.equals(t)){
                return i;
            }
        }
        return -1;
    }

    //删除位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>=N){
            throw new RuntimeException("位置不合法");
        }
        //寻找i位置的前一个元素
        Node pre = head;
        for (int index = 0; index <i ; index++) {
            pre = pre.next;
        }
        //i位置的元素
        Node curr = pre.next;
        //i位置的下一个元素
        Node curr_next = curr.next;
        pre.next = curr_next;
        curr_next.pre = pre;
        //长度-1；
        N--;
        return curr.item;
    }

    //获取第一个元素
    public T getFirst(){
        if (isEmpty()){
            return null;
        }
        return head.next.item;
    }

    //获取最后一个元素
    public T getLast(){
        if (isEmpty()){
            return null;
        }
        return last.item;
    }

    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    class MyIterator implements Iterator<T>{

        private Node n = head;

        @Override
        public boolean hasNext() {
            return n.next!=null;
        }

        @Override
        public T next() {
            n = n.next;
            return n.item;
        }
    }

    class Node{
        // 数据域
        public T item;
        // 上一个指针
        public Node pre;
        // 指针域 下一个指针
        public Node next;


        public Node(T item, Node pre, Node next) {
            this.item = item;
            this.next = next;
            this.pre = pre;
        }
    }
}




package com.ynu.Java版算法.U4_线性表.T2_链表.S3_双向链表;

public class Main {

    public static void main(String[] args) {
        TowWayLinkList<String> list  =new TowWayLinkList<>();
        list.insertLast("杨炳辉");
        list.insertLast("路梦娟");
        list.insertLast("陈志鑫");
        list.insertLast("刘辉");
        list.insertFirst("哈哈");

        for (String s : list) {
            System.out.println(s);
        }

        System.out.println("======================");

        list.insert(2,"不知道");
        for (String s : list) {
            System.out.println(s);
        }

    }
}

4.3 栈

4.3.1 栈的概述

4.3.1.1 生活中的栈

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

4.3.1.2 计算机中的栈

我们把生活中的栈的概念引入到计算机中，就是供数据休息的地方，它是一种数据结构，数据既可以进入到栈中，又可以从栈中出去。

栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。

我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈。

4.3.2 栈的实现

4.3.2.1 栈的数组实现

package com.ynu.Java版算法.U4_线性表.T3_栈.S1_栈的数组实现;

import java.util.Iterator;

public class ArrayStack<T> implements Iterable<T>{
    // 用数组存放数据
    private T[] datas;
    // 栈的大小
    private int maxSize;
    //栈顶
    private int top;

    // 构造方法  指定大小的栈
    public ArrayStack(int maxSize) {
        this.top = -1;
        this.maxSize = maxSize;
        datas = (T[])new Object[this.maxSize];
    }

    // 返回栈的大小
    public int length(){
        return top+1;
    }

    //判断栈是否满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //p判断栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈
    public void push(T data) {
        //先判断栈是否满
        if (!isFull()) {
            datas[++top] = data;
        } else {
            System.out.println("栈满");
        }
    }

    //出栈
    public T pop() {
        //先判断栈是否为空
        if (isEmpty()) {
            //抛出异常
            throw new RuntimeException("栈空");
        }
        T val = datas[top--];

        return val;
    }


    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    class MyIterator implements Iterator<T>{

        private int n = top;

        @Override
        public boolean hasNext() {
            return n!=-1;
        }

        @Override
        public T next() {
            return datas[n--];
        }
    }
}


package com.ynu.Java版算法.U4_线性表.T3_栈.S1_栈的数组实现;

public class Main {
    public static void main(String[] args) {
        ArrayStack<String> stack = new ArrayStack<>(10);
        // 栈是先进后出的
        stack.push("abc");
        stack.push("def");
        stack.push("ghi");
        stack.push("jkl");
        // 遍历栈
        for (String s : stack) {
            System.out.println(s);
        }
        // 出栈元素
        String pop = stack.pop();
        System.out.println(pop);
        // 栈的大小
        System.out.println(stack.length());

    }
}

4.3.2.1 栈的链表实现

1. API设计

2. 栈代码实现

package com.ynu.Java版算法.U4_线性表.T3_栈.S2_栈的链表实现;

import java.util.Iterator;

public class LinkStack<T> implements Iterable<T> {

    //记录首结点
    private Node head;
    //栈中元素的个数
    private int N;

    public LinkStack() {
        head = new Node(null, null);
        N = 0;
    }

    //判断当前栈中元素个数是否为0
    public boolean isEmpty() {
        return N == 0;
    }

    //把t元素压入栈
    public void push(T t) {
        Node oldNext = head.next;
        Node node = new Node(t, oldNext);
        head.next = node;
        //个数+1
        N++;
    }

    //弹出栈顶元素
    public T pop() {
        Node oldNext = head.next;
        if (oldNext == null) {

            return null;
        }
        //删除首个元素
        head.next = head.next.next;
        //个数-1
        N--;
        return oldNext.item;
    }

    //获取栈中元素的个数
    public int length(){
        return N;
    }


    @Override
    public Iterator<T> iterator() {
        return new SIterator();
    }

    private class SIterator implements Iterator<T> {
        private Node n = head;

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public T next() {
            Node node = n.next;
            n = n.next;
            return node.item;
        }
    }

    private class Node {
        public T item;
        public Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }


}

4.3.3 案例

4.3.3.1 括号匹配问题

问题描述:

给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。

例如：

“(上海)(长安)”：正确匹配

“上海((长安))”：正确匹配

“上海(长安(北京)(深圳)南京)”:正确匹配

“上海(长安))”：错误匹配

“((上海)长安”：错误匹配

示例代码：

package com.ynu.Java版数据结构.U4_线性表.T3_栈.S3_括号匹配问题;

/**
 * @author ybh
 * @date 2023.04.23 15:33
 */
public class Main {

    public static void main(String[] args) {
        String str = "(上海(长安)())";
        boolean match = isMatch(str);
        System.out.println(str+"中的括号是否匹配："+match);
    }

    /**
     * 判断str中的括号是否匹配
     * @param str 括号组成的字符串
     * @return 如果匹配，返回true，如果不匹配，返回false
     */
    public static boolean isMatch(String str){
        return false;
    }

    

}

请完善 isMath方法。

分析：

1.创建一个栈用来存储左括号

2.从左往右遍历字符串，拿到每一个字符

3.判断该字符是不是左括号，如果是，放入栈中存储

4.判断该字符是不是右括号，如果不是，继续下一次循环

5.如果该字符是右括号，则从栈中弹出一个元素t；

6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号

7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配

package com.ynu.Java版数据结构.U4_线性表.T3_栈.S3_括号匹配问题;

import java.util.Stack;

/**
 * @author ybh
 * @date 2023.04.23 15:33
 */
public class Main {

    public static void main(String[] args) {
        String str = "(上海(长安)())";
        boolean match = isMatch(str);
        System.out.println(str + "中的括号是否匹配：" + match);
    }

    /**
     * 判断str中的括号是否匹配
     *
     * @param str 括号组成的字符串
     * @return 如果匹配，返回true，如果不匹配，返回false
     */
    public static boolean isMatch(String str) {
        //1.创建一个栈用来存储左括号
        Stack<String> chars = new Stack<>();
        //2.从左往右遍历字符串，拿到每一个字符
        for (int i = 0; i < str.length(); i++) {
            String currChar = str.charAt(i) + "";
            //3.判断该字符是不是左括号，如果是，放入栈中存储
            if (currChar.equals("(")) {
                chars.push(currChar);
            } else if (currChar.equals(")")) {//4.判断该字符是不是右括号，如果不是，继续下一次循环
                //5.如果该字符是右括号，则从栈中弹出一个元素t；
                String t = chars.pop();
                //6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号
                if (t == null) {
                    return false;
                }
            }
        }
        //7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配
        if (chars.size() == 0) {
            return true;
        } else {
            return false;
        }

    }


}

4.3.3.2 逆波兰表达式求值问题

逆波兰表达式求值问题是我们计算机中经常遇到的一类问题，要研究明白这个问题，首先我们得搞清楚什么是逆波兰表达式？要搞清楚逆波兰表达式，我们得从中缀表达式说起。

中缀表达式：

中缀表达式就是我们平常生活中使用的表达式，例如：1+3*2,2-(1+3)等等，中缀表达式的特点是：二元运算符总是置于两个操作数中间。

中缀表达式是人们最喜欢的表达式方式，因为简单，易懂。但是对于计算机来说就不是这样了，因为中缀表达式的运算顺序不具有规律性。不同的运算符具有不同的优先级，如果计算机执行中缀表达式，需要解析表达式语义，做大量的优先级相关操作。

逆波兰表达式(后缀表达式)：

逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法，后缀表达式的特点：运算符总是放在跟它相关的操作数之后。

需求：

给定一个只包含加减乘除四种运算的逆波兰表达式的数组表示方式，求出该逆波兰表达式的结果。

package com.ynu.Java版数据结构.U4_线性表.T3_栈.S4_逆波兰表达式求值;

/**
 * @author ybh
 * @date 2023.04.23 15:43
 */
public class Main {

    public static void main(String[] args) {
        //中缀表达式3*（17-15）+18/6的逆波兰表达式如下
        String[] notation = {"3", "17", "15", "-", "*","18", "6","/","+"};
        int result = caculate(notation);
        System.out.println("逆波兰表达式的结果为："+result);
    }

    /**
     * @param notaion 逆波兰表达式的数组表示方式
     * @return 逆波兰表达式的计算结果
     */
    public static int caculate(String[] notaion){
        return -1;
    }

}

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

分析：

1.创建一个栈对象oprands存储操作数

2.从左往右遍历逆波兰表达式，得到每一个字符串

3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中

4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2

5.使用该运算符计算o1和o2，得到结果result

6.把该结果压入oprands栈中

7.遍历结束后，拿出栈中最终的结果返回

代码实现：

package com.ynu.Java版数据结构.U4_线性表.T3_栈.S4_逆波兰表达式求值;

import java.util.Stack;

/**
 * @author ybh
 * @date 2023.04.23 15:43
 */
public class Main {

    public static void main(String[] args) {
        //中缀表达式3*（17-15）+18/6的逆波兰表达式如下
        String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
        int result = caculate(notation);
        System.out.println("逆波兰表达式的结果为：" + result);
    }

    /**
     * @param notaion 逆波兰表达式的数组表示方式
     * @return 逆波兰表达式的计算结果
     */
    public static int caculate(String[] notaion) {
        //1.创建一个栈对象oprands存储操作数
        Stack<Integer> oprands = new Stack<>();
        //2.从左往右遍历逆波兰表达式，得到每一个字符串
        for (int i = 0; i < notaion.length; i++) {
            String curr = notaion[i];
            //3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中
            Integer o1;
            Integer o2;
            Integer result;
            switch (curr) {
                case "+":
                    //4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    //5.使用该运算符计算o1和o2，得到结果result
                    result = o2 + o1;
                    //6.把该结果压入oprands栈中
                    oprands.push(result);
                    break;
                case "-":
                    //4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    //5.使用该运算符计算o1和o2，得到结果result
                    result = o2 - o1;
                    //6.把该结果压入oprands栈中
                    oprands.push(result);
                    break;
                case "*":
                    //4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    //5.使用该运算符计算o1和o2，得到结果result
                    result = o2 * o1;
                    //6.把该结果压入oprands栈中
                    oprands.push(result);
                    break;
                case "/":
                    //4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    //5.使用该运算符计算o1和o2，得到结果result
                    result = o2 / o1;
                    //6.把该结果压入oprands栈中
                    oprands.push(result);
                    break;
                default:
                    oprands.push(Integer.parseInt(curr));
                    break;
            }
        }
        //7.遍历结束后，拿出栈中最终的结果返回
        Integer result = oprands.pop();
        return result;
    }

}

4.4 队列

队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它

按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。

4.4.1 数组实现队列

package com.ynu.Java版算法.U4_线性表.T4_队列.S1数组实现队列;

import java.util.Iterator;

public class ArrayQueue<T> implements Iterable<T> {

    private int maxSize;
    private int front;//头
    private int rear;//尾
    private T[] arr;

    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = (T[]) new Object[maxSize];
        front = -1;
        rear = -1;
    }

    //判断队列满
    public boolean isFull() {
        return (rear+1) == maxSize;
    }

    //判断队列kong
    public boolean isEmpty() {
        return rear == front;
    }


    //添加数据
    public void enqueue(T n) {
        if(isFull()) {//判满
            System.out.println("队列满");
            return;
        }
        arr[++rear] = n;
    }

    //出队列
    public T dequeue() {
        if(isEmpty()) {//判空
            throw new RuntimeException("队列空");
        }
        return arr[++front];
    }

    public void showQueue() {
        if(isEmpty()) {
            System.out.println("队列空");
            return;
        }
        for(int i = front; i < rear; i++) {
            System.out.printf("arr[%d] = %d\n",i,arr[i]);
        }
    }

    //显示队列头 但不移出队列
    public T headQueue() {
        if(isEmpty()) {
            throw new RuntimeException("队列空");
        }
        return arr[front+1];
    }

    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }


    class MyIterator implements Iterator<T>{

        private int f = front;

        private int r = rear;

        @Override
        public boolean hasNext() {
            return f!=r;
        }

        @Override
        public T next() {
            return arr[++f];
        }
    }

}


package com.ynu.Java版算法.U4_线性表.T4_队列.S1数组实现队列;

public class Main {
    public static void main(String[] args) {
        ArrayQueue<String> queue = new ArrayQueue<>(20);
        queue.enqueue("杨炳辉");
        queue.enqueue("路梦娟");
        queue.enqueue("哈哈哈");
        for (String s : queue) {
            System.out.println(s);
        }
    }
}

4.4.2 链表实现队列

(1) 队列的API设计

(2) 队列的实现

package com.ynu.Java版算法.U4_线性表.T4_队列.S2_链表实现队列;

import java.util.Iterator;

public class LinkQueue<T> implements Iterable<T>{

    //记录首结点
    private Node head;
    //记录最后一个结点
    private Node last;
    //记录队列中元素的个数
    private int N;

    public LinkQueue() {
        head = new Node(null,null);
        last=null;
        N=0;
    }

    //判断队列是否为空
    public boolean isEmpty(){
        return N==0;
    }
    //返回队列中元素的个数
    public int size(){
        return N;
    }

    //向队列中插入元素t
    public void enqueue(T t){
        if (last==null){
            last = new Node(t,null);
            head.next=last;
        }else{
            Node oldLast = last;
            last = new Node(t,null);
            oldLast.next=last;
        }
        //个数+1
        N++;
    }

    //从队列中拿出一个元素
    public T dequeue(){
        if (isEmpty()){
            return null;
        }
        Node oldFirst = head.next;
        head.next = oldFirst.next;
        N--;
        if (isEmpty()){
            last=null;
        }
        return oldFirst.item;
    }


    private class Node{
        public T item;
        public Node next;
        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    @Override
    public Iterator<T> iterator() {
        return new QIterator();
    }

    private class QIterator implements Iterator<T>{
        private Node n = head;
        @Override
        public boolean hasNext() {
            return n.next!=null;
        }
        @Override
        public T next() {
            Node node = n.next;
            n = n.next;
            return node.item;
        }
    }
}


package com.ynu.Java版算法.U4_线性表.T4_队列.S2_链表实现队列;

public class Main {
    public static void main(String[] args) {
        LinkQueue<String> queue = new LinkQueue<>();
        queue.enqueue("a");
        queue.enqueue("b");
        queue.enqueue("c");
        queue.enqueue("d");
        for (String str : queue) {
            System.out.print(str+" ");
        }
        System.out.println("-----------------------------");
        String result = queue.dequeue();
        System.out.println("出列了元素："+result);
        System.out.println(queue.size());
    }
}