标签：Node 链表 结点 null 线性表 next ---- 数据结构 public

三、 线性表

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

前驱元素：

若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的后继元素

线性表的分类：

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

表和链表。

1.1 顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存

储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元

素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

1.1.1 顺序表的实现

顺序表的代码实现：

public class SequenceList<T> implements Iterable {

    // 存储元素的数组
    private T[] eles;
    // 当前线性表的长度
    private int N;

    /*
        创建容量为capacity的SequenceList对象
     */
    public SequenceList(int capacity) {
        // 初始化数组
        this.eles = (T[]) new Object[capacity];
        // 初始化长度
        this.N = 0;
    }

    /*
        空置线性表
     */
    public void clear() {
        this.N = 0;
    }

    /*
        判断线性表是否为空，是返回true，否返回false
     */
    public boolean isEmpty() {
        return N == 0;
    }


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

    /*
       读取并返回线性表中的第i个元素的值
     */
    public T get(int i) {
        return eles[i];
    }

    /*
        向线性表中添加一个元素t
     */
    public void insert(T t) {
        if (N == eles.length) {
            resize(2 * eles.length);
        }
        eles[N++] = t;
    }

    /*
       在线性表的第i个元素之前插入一个值为t的数据元素。
     */
    public void insertBefore(int i, T t) {
        if (N == eles.length) {
            resize(2 * eles.length);
        }

        // 先把索引的元素及其后面的元素依向后移动一位
        for (int index = N; index > i; index--) {
            eles[index] = eles[index - 1];
        }
        // 再把t元素放到i索引处即可
        eles[i] = t;
        // 元素个数加1
        N++;
    }


    /*
        删除并返回线性表中第i个数据元素。
     */
    public T remove(int i) {
        // 记录索引i处的值
        T current = eles[i];
        // 索引i后面元素依次向前移动一位
        for (int index = i; index < N - 1; index++) {
            eles[index] = eles[index + 1];
        }
        N--;
        if (N < eles.length / 4) {
            resize(eles.length / 2);
        }

        return current;
    }

    /*
        返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。
     */
    public int indexOf(T t) {
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)) {
                return i;
            }
        }
        return -1;
    }

    // 根据参数newSize，重置eles的大小
    public void resize(int newSize) {
        // 定义一个临时数组，指向原数组
        T[] temp = eles;
        // 创建新数组
        eles = (T[]) new Object[newSize];
        // 把原数组的数据拷贝到新数组即可
        for (int i = 0; i < N; i++) {
            eles[i] = temp[i];
        }
    }


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

    private class SIterator implements Iterator {

        private int cusor;

        public SIterator() {
            this.cusor = 0;
        }

        public boolean hasNext() {
            return cusor < N;
        }

        public Object next() {
            return eles[cusor++];
        }

        public void remove() {

        }
    }
}

1.1.2 顺序表的遍历

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

在java中，遍历集合的方式一般都是用的是foreach循环，如果想让我们的SequenceList也能支持foreach循环，

则需要做如下操作：

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

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

代码参考上面的

1.1.3 顺序表的容量可变

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

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

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

伸缩性。

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

小？

1. 添加元素时：

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

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

2. 移除元素时：

移除元素时，应该检查当前数组的大小是否太大，比如正在用100个容量的数组存储10个元素，这样就会造成内存

空间的浪费，应该创建一个容量更小的数组存储元素。如果我们发现数据元素的数量不足数组容量的1/4，则创建

一个是原数组容量的1/2的新数组存储元素。

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 链表

之前我们已经使用顺序存储结构实现了线性表，我们会发现虽然顺序表的查询很快，时间复杂度为O(1),但是增删

的效率是比较低的，因为每一次增删操作都伴随着大量的数据元素移动。这个问题有没有解决方案呢？有，我们可

以使用另外一种存储结构实现线性表，链式存储结构。

链表是一种物理存储单元上非连续、非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑顺序，数据元

素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点（链表中的每一个元素称为结点）组成，

结点可以在运行时动态生成。

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

结点存储的元素，用来另外一个属性描述这个结点的下一个结点。

结点API设计：

结点类实现：

   public class Node {
        //存储元素
        public T item;
        // 指向下一个结点
        public Node next;

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

生成链表：

   public static void main(String[] args) throws Exception {
        //构建结点
        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;
    }

1.2.1 单向链表

单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，

指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点。

1.2.1.1 单向链表API设计

1.2.1.2 单向链表代码实现

public class LinkList<T> implements Iterable {

    // 记录首结点
    private Node head;
    // 当前链表的长度
    private int N;

    /*
        创建容量为capacity的SequenceList对象
     */
    public LinkList() {
        // 初始化头结点
        this.head = new Node(null, null);
        // 初始化元素个数
        this.N = 0;
    }

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

    /*
        判断线性表是否为空，是返回true，否返回false
     */
    public boolean isEmpty() {
        return this.N == 0;
    }


    /*
      线性表的长度
    */
    public int length() {
        return this.N;
    }

    /*
       读取并返回线性表中的第i个元素的值
     */
    public T get(int i) {
        // 通过循环，从头结点开始往后找
        Node n = this.head.next;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }
        return n.item;
    }

    /*
        向线性表中添加一个元素t
     */
    public void insert(T t) {
        // 找到当前最后一个结点
        Node n = head;
        while (n.next != null) {
            n = n.next;
        }
        // 创建新结点，保存元素t
        Node newNode = new Node(t, null);
        // 让当前最后一个结点指向新结点
        n.next = newNode;
        // 元素的个数+1
        N++;
    }

    /*
       在线性表的第i个元素之前插入一个值为t的数据元素。
     */
    public void insertBefore(int i, T t) {
        // 找到i位置前一个结点
        Node pre = head;
        for (int index = 0; index < i; index++) {
            pre = pre.next;
        }
        // 找到i位置的结点
        Node curr = pre.next;
        // 创建新结点，斌给钱新结点需要指向原来i位置的结点
        Node newNode = new Node(t, curr);
        // 原来i位置的前一个结点指向新结点即可
        pre.next = newNode;
        // 元素的个数+1
        N++;
    }

    /*
        删除并返回线性表中第i个数据元素。
     */
    public T remove(int i) {
        // 找到i位置的前一个结点
        Node pre = head;
        for (int index = 0; index < i; index++) {
            pre = pre.next;
        }
        // 找到i位置的结点
        Node curr = pre.next;
        // 找到i位置的下一个结点
        Node nextNode = curr.next;
        // 前一个结点指向下一个结点
        pre.next = nextNode;
        //元素个数-1
        N--;
        return curr.item;
    }

    /*
        返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。
     */
    public int indexOf(T t) {
        // 从头结点开始·然找到每一个结点,取出item和t比较:如果相同,就找到了
        Node n = head;
        for (int i = 0; n.next != null; i++) {
            n = n.next;
            if (n.item.equals("t")) {
                return i;
            }
        }
        return -1;
    }

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

    private class SIterator implements Iterator {

        private Node n;

        public SIterator() {
            this.n = head;
        }

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

        public Object next() {
            n = n.next;
            return n.item;
        }

        public void remove() {

        }
    }

    public class Node {
        //存储元素
        public T item;
        // 指向下一个结点
        public Node next;

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

public class LinkListTest {
    public static void main(String[] args) {
        // 创建单向链表对象
        LinkList<String> sl = new LinkList<String>();
        // 测试插入
        sl.insert("姚明");
        sl.insert("科比");
        sl.insert("麦迪");
        sl.insertBefore(2, "詹姆斯");
        for (Object s : sl) {
            System.out.println((String) s);
        }
        System.out.println("-----------------------");


        // 测试获取
        String getResult = sl.get(0);
        System.out.println("获取索引0处的值为：" + getResult);
        String getResult2 = sl.get(sl.length()-1);
        System.out.println("获取索引的值为：" + getResult2);
        // 测试删除
        String removeResult = sl.remove(0);
        System.out.println("获取索引0被删处的值为：" + removeResult);
        // 测试清空
        sl.clear();
        System.out.println("清空后的线性表中的元素个数为：" + sl.length());
    }
输出：
姚明
科比
詹姆斯
麦迪
-----------------------
获取索引0处的值为：姚明
获取索引的值为：麦迪
获取索引0被删处的值为：姚明
清空后的线性表中的元素个数为：0

1.2.2 双向链表

双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用

来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存

储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。

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

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

1.2.2.1 结点API设计

1.2.2.2 双向链表API设计

1.2.2.3 双向链表代码实现

public class TowWayLinkList<T> implements Iterable {

    // 记录首结点
    private Node head;
    // 记录尾结点
    private Node last;
    // 当前链表的长度
    private int N;

    /*
        创建容量为capacity的SequenceList对象
     */
    public TowWayLinkList() {
        // 初始化头结点
        this.head = new Node(null, null, null);
        // 初始化尾结点
        this.last = null;
        // 初始化元素个数
        this.N = 0;
    }

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

    /*
        判断线性表是否为空，是返回true，否返回false
     */
    public boolean isEmpty() {
        return N == 0;
    }


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

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

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

    /*
       读取并返回线性表中的第i个元素的值
     */
    public T get(int i) {
        Node n = head.next;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }

        return n.item;
    }

    /*
        向线性表中添加一个元素t
     */
    public void insert(T t) {
        // 如果链表为空
        if (isEmpty()) {
            // 创建新结点
            Node newNode = new Node(t, head, null);
            // 让新结点称为尾结点
            last = newNode;
            // 让头结点指向尾结点
            head.next = last;
        } else {
            // 链表不为空
            Node oldLast = last;
            // 创建新结点
            Node newNode = new Node(t, oldLast, null);
            // 当前尾结点指向新结点
            oldLast.next = newNode;
            // 让新结点称为尾结点
            last = newNode;
        }
        N++;
    }

    /*
       在线性表的第i个元素之前插入一个值为t的数据元素。
     */
    public void insertBefore(int i, T t) {
        // 找到i位置得前一个结点
        Node pre = head;
        for (int idnex = 0; idnex < i; idnex++) {
            pre = pre.next;
        }
        // 找到i位置得结点
        Node INode = pre.next;
        // 创建新结点
        Node newNode = new Node(t, pre, INode);
        //让i位置的前一个结点的下一个结点变为新结点
        pre.next = newNode;
        // 让i位置的前一个结点变为新结点
        INode.pre = newNode;
        // 元素个数+1
        N++;

    }

    /*
        删除并返回线性表中第i个数据元素。
     */
    public T remove(int i) {
        // 找i位置的前一个结点
        Node pre = head;
        for (int index = 0; index < i; index++) {
            pre = pre.next;
        }
        // 找i位置的结点
        Node curr = pre.next;
        // 找到i位置的下一个结点
        Node nextNode = curr.next;
        // 让i位置的前一个结点的下一个结点变为i位置的下一个结点
        pre.next = nextNode;
        // 让i位置的下一个结点的上一个结点变为i位置的前一个结点
        nextNode.pre = pre;
        // 元素个数-1
        N--;
        return curr.item;
    }

    /*
        返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。
     */
    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;
    }


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

    private class SIterator implements Iterator {

        private Node n;

        public SIterator() {
            this.n = head;
        }

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

        public Object next() {
            n = n.next;
            return n.item;
        }

        public void remove() {

        }
    }

    public class Node {
        //存储元素
        public T item;
        // 指向下一个结点
        public Node next;
        // 指向上一个结点
        public Node pre;

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

public class TowWayLinkListTest {
    public static void main(String[] args) {
        // 创建双向链表对象
        TowWayLinkList<String> sl = new TowWayLinkList<String>();
        // 测试插入
        sl.insert("姚明");
        sl.insert("科比");
        sl.insert("麦迪");
        sl.insertBefore(2, "詹姆斯");
        for (Object s : sl) {
            System.out.println((String) s);
        }
        System.out.println("-----------------------");


        // 测试获取
        String getResult = sl.get(0);
        System.out.println("获取索引0处的值为：" + getResult);
        String getResult2 = sl.get(sl.length()-1);
        System.out.println("获取索引的值为：" + getResult2);
        // 测试删除
        String removeResult = sl.remove(0);
        System.out.println("获取索引0被删处的值为：" + removeResult);
        // 测试清空
//        sl.clear();
//        System.out.println("清空后的线性表中的元素个数为：" + sl.length());

        System.out.println("----------------------------");
        System.out.println("第一个元素"+sl.getFirst());
        System.out.println("最后一个元素"+sl.getLast());

    }
}
输出：
姚明
科比
詹姆斯
麦迪
-----------------------
获取索引0处的值为：姚明
获取索引的值为：麦迪
获取索引0被删处的值为：姚明
----------------------------
第一个元素科比
最后一个元素麦迪

1.2.2.4 java中LinkedList实现

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

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结点返回

使用递归可以完成反转，递归反转其实就是从原链表的第一个存数据的结点开始，依次递归调用反转每一个结点，

直到把最后一个结点反转完毕，整个链表就反转完毕。

    /*
     对整个链表反转
     */
    public void reverse() {
        // 判断当前链表是否为空链表,如果是空链表，则结束运行，如果不是，则调用重载reverse方法，完成反转
        if (isEmpty()) {
            return;
        }
        reverse(head.next);
    }

    /*
        反转链表中的指定的结点curr,并把反转后的curr结点返回
        原本的顺序
        姚明
        科比
        詹姆斯
        麦迪
     */
    public Node reverse(Node curr) {
        if (curr.next == null) {
            // 将姚明换成麦迪
            head.next = curr;
            // 返回麦迪
            return curr;
        }
        // 递归反转当前结点curr的下一个结点，返回值就是链表反转后当前结点的上一个结点
        Node pre = reverse(curr.next);
        // pre 为麦迪
        // curr为詹姆斯
        // 让返回的结点的下一个结点变为当前结点curr
        pre.next = curr;
        // 把当前结点的下一个结点变为null
        curr.next = null;
        return curr;
    }

    public static void main(String[] args) {
        // 创建单向链表对象
        LinkList<String> sl = new LinkList<String>();
        // 测试插入
        sl.insert("姚明");
        sl.insert("科比");
        sl.insert("麦迪");
        sl.insertBefore(2, "詹姆斯");
        for (Object s : sl) {
            System.out.println((String) s);
        }
        System.out.println("--------------------------------");
        sl.reverse();
        for (Object s : sl) {
            System.out.println((String) s);
        }
    }
输出：
姚明
科比
詹姆斯
麦迪
--------------------------------
麦迪
詹姆斯
科比
姚明

1.2.5 快慢指针

快慢指针指的是定义两个指针，这两个指针的移动速度一块一慢，以此来制造出自己想要的差值，这个差值可以然

我们找到链表上相应的结点。一般情况下，快指针的移动步长为慢指针的两倍

1.2.5.1 中间值问题

  public static void main(String[] args) throws Exception {
        //创建结点
        Node<String> first = new Node<String>("aa", null);
        Node<String> second = new Node<String>("bb", null);
        Node<String> third = new Node<String>("cc", null);
        Node<String> fourth = new Node<String>("dd", null);
        Node<String> fifth = new Node<String>("ee", null);
        Node<String> six = new Node<String>("ff", null);
        Node<String> seven = new Node<String>("gg", null);

        //完成结点之间的指向
        first.next = second;
        second.next = third;
        third.next = fourth;
        fourth.next = fifth;
        fifth.next = six;
        six.next = seven;

        //查找中间值
        String mid = getMid(first);
        System.out.println("中间值为："+mid);
    }

    /**
     * @param first 链表的首结点
     * @return 链表的中间结点的值
     */
    public static String getMid(Node<String> first) {
        //定义两个指针
        Node<String> slow = first;
        Node<String> fast = first;
        //使用两个指针遍历链表，当快指针指向的结点没有下一个结点了，就可以结束了，结束之后，慢指针指向的结点就是中间值
        while (fast!=null && fast.next!=null){
            // 快指针
            fast = fast.next.next;
            // 慢指针
            slow = slow.next;
        }
        return slow.item;
    }

    //结点类
    private static class Node<T> {
        //存储数据
        T item;
        //下一个结点
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
输出：中间值为：dd

1.2.5.2 单向链表是否有环问题

需求：

请完善测试类Test中的isCircle方法，返回链表中是否有环。

使用快慢指针的思想，还是把链表比作一条跑道，链表中有环，那么这条跑道就是一条圆环跑道，在一条圆环跑道

中，两个人有速度差，那么迟早两个人会相遇，只要相遇那么就说明有环。

    public static void main(String[] args) throws Exception {
        //创建结点
        Node<String> first = new Node<String>("aa", null);
        Node<String> second = new Node<String>("bb", null);
        Node<String> third = new Node<String>("cc", null);
        Node<String> fourth = new Node<String>("dd", null);
        Node<String> fifth = new Node<String>("ee", null);
        Node<String> six = new Node<String>("ff", null);
        Node<String> seven = new Node<String>("gg", null);

        //完成结点之间的指向
        first.next = second;
        second.next = third;
        third.next = fourth;
        fourth.next = fifth;
        fifth.next = six;
        six.next = seven;
//        //产生环
//        seven.next = third;

        //判断链表是否有环
        boolean circle = isCircle(first);
        System.out.println("first链表中是否有环："+circle);
    }

    /**
     * 判断链表中是否有环
     * @param first 链表首结点
     * @return ture为有环，false为无环
     */
    public static boolean isCircle(Node<String> first) {
        //定义快慢指针
        Node<String> fast = first;
        Node<String> slow = first;

        //遍历链表，如果快慢指针指向了同一个结点，那么证明有环
        while(fast!=null && fast.next!=null){
            //变换fast和slow
            fast = fast.next.next;
            slow = slow.next;
            if (fast.equals(slow)){
                return true;
            }
        }

        return false;
    }

    //结点类
    private static class Node<T> {
        //存储数据
        T item;
        //下一个结点
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
输出：first链表中是否有环：false

1.2.5.3 有环链表入口问题

需求：

请完善Test类中的getEntrance方法，查找有环链表中环的入口结点。

当快慢指针相遇时，我们可以判断到链表中有环，这时重新设定一个新指针指向链表的起点，且步长与慢指针一样

为1，则慢指针与“新”指针相遇的地方就是环的入口。证明这一结论牵涉到数论的知识，这里略，只讲实现。

  public static void main(String[] args) throws Exception {
        Node<String> first = new Node<String>("aa", null);
        Node<String> second = new Node<String>("bb", null);
        Node<String> third = new Node<String>("cc", null);
        Node<String> fourth = new Node<String>("dd", null);
        Node<String> fifth = new Node<String>("ee", null);
        Node<String> six = new Node<String>("ff", null);
        Node<String> seven = new Node<String>("gg", null);

        //完成结点之间的指向
        first.next = second;
        second.next = third;
        third.next = fourth;
        fourth.next = fifth;
        fifth.next = six;
        six.next = seven;
        //产生环
        seven.next = third;

        //查找环的入口结点
        Node<String> entrance = getEntrance(first);
        System.out.println("first链表中环的入口结点元素为："+entrance.item);
    }

    /**
     * 查找有环链表中环的入口结点
     * @param first 链表首结点
     * @return 环的入口结点
     */
    public static Node getEntrance(Node<String> first) {
        //定义快慢指针
        Node<String> fast = first;
        Node<String> slow = first;
        Node<String> temp = null;
        //遍历链表，先找到环(快慢指针相遇),准备一个临时指针，指向链表的首结点，继续遍历，直到慢指针和临时指针相遇，那么相遇时所指向的结点就是环的入口
        while(fast!=null && fast.next!=null){
            //变换快慢指针
            fast = fast.next.next;
            slow = slow.next;
            if (fast.equals(slow)){
                temp = first;
                continue;
            }

            // 让临时结点变换
            if (temp!=null){
                temp = temp.next;
                // 判断临时指针是否和慢指针相遇
                if (temp.equals(slow)){
                    break;
                }
            }
        }
        return temp;
    }
    //结点类
    private static class Node<T> {
        //存储数据
        T item;
        //下一个结点
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
输出：first链表中环的入口结点元素为：cc

1.2.6 循环链表

循环链表，顾名思义，链表整体要形成一个圆环状。在单向链表中，最后一个节点的指针为null，不指向任何结

点，因为没有下一个元素了。要实现循环链表，我们只需要让单向链表的最后一个节点的指针指向头结点即可.

1.2.7 约瑟夫问题

问题描述：

传说有这样一个故事，在罗马人占领乔塔帕特后，39 个犹太人与约瑟夫及他的朋友躲到一个洞中，39个犹太人决

定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，第一个人从1开始报数，依次往

后，如果有人报数到3，那么这个人就必须自杀，然后再由他的下一个人重新从1开始报数，直到所有人都自杀身

亡为止。然而约瑟夫和他的朋友并不想遵从。于是，约瑟夫要他的朋友先假装遵从，他将朋友与自己安排在第16

个与第31个位置，从而逃过了这场死亡游戏 。

问题转换：

41个人坐一圈，第一个人编号为1，第二个人编号为2，第n个人编号为n。

1.编号为1的人开始从1报数，依次向后，报数为3的那个人退出圈；

2.自退出那个人开始的下一个人再次从1开始报数，以此类推；

3.求出最后退出的那个人的编号。

图示：

解题思路：

1.构建含有41个结点的单向循环链表，分别存储1~41的值，分别代表这41个人；

2.使用计数器count，记录当前报数的值；

3.遍历链表，每循环一次，count++；

4.判断count的值，如果是3，则从链表中删除这个结点并打印结点的值，把count重置为0；

 public static void main(String[] args) {
        // 解决约瑟夫问题

        //1.构建循环链表，包含41个结点，分别存储1~41的值
        // first ：首结点
        // pre : 用来记录前一个结点
        Node<Integer> first = null;
        Node<Integer> pre = null;
        for (int i = 1; i <= 41; i++) {
            //  如果是第一个结点
            if (i == 1) {
                first = new Node<Integer>(i, null);
                pre = first;
                continue;
            }
            // 如果不是第一个结点
            Node<Integer> newNode = new Node(i, null);
            pre.next = newNode;
            pre = newNode;
            // 如果是最后一个结点，那么下一个结点为first
            if (i == 41) {
                pre.next = first;
            }
        }
        // 2. 需要count计数器
        int count = 0;
        // 3.遍历循环链表
        // 记录每次遍历拿到的结点，默认从首结点开始
        Node<Integer> n = first;
        // 记录当前结点的上一个节点
        Node<Integer> before = null;
        while (n != n.next) {
            // 模拟报数
            count++;
            // 判断当前报数是不是为3
            if (count == 3) {
                // 如果是3，则把当前结点删除掉，打印当前结点，重置count=0，让当前结点n后移
                before.next = n.next;
                System.out.print(n.item+",");
                count=0;
                n = n.next;
            } else {
                // 如果不是3，让before变为当前结点，让当前结点后移
                before = n;
                n = n.next;
            }
        }
        // 打印最后一个元素
        System.out.println(n.item);
    }


    private static class Node<T> {
        //存储数据
        T item;
        //下一个结点
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
输出：
3,6,9,12,15,18,21,24,27,30,33,36,39,1,5,10,14,19,23,28,32,37,41,7,13,20,26,34,40,8,17,29,38,11,25,2,22,4,35,16,31

1.3 栈

1.3.1.1 生活中的栈

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

休息的地方，旅客可以进客栈休息，休息完毕后就离开客栈。

1.3.1.2 计算机中的栈

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

又可以从栈中出去。

栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出

的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一

个数据被第一个读出来）。

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

1.3.2 栈的实现

1.3.2.1 栈API设计

1.3.2.2 栈代码实现

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

    // 记录首结点
    private Node head;

    // 当前栈的元素个数
    private int N;

    public StackList() {
        this.head = new Node(null, null);
        this.N = 0;
    }

    /**
     * 判断栈是否为空，是返回true，否返回false
     *
     * @return
     */
    public boolean isEmpty() {
        return N == 0;
    }

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

    /**
     * 向栈中压入元素t
     *
     * @return
     */
    public void push(T t) {
        // 找到首结点指向的第一个结点
        Node<T> oldFirst = head.next;
        // 创建新结点
        Node<T> newNode = new Node(t, null);
        // 让首结点指向新结点
        head.next = newNode;
        // 让新结点指向原来的第一个结点
        newNode.next = oldFirst;
        // 元素个数+1
        N++;
    }

    /**
     * 弹出栈顶元素
     *
     * @return
     */
    public T pop() {
        // 找到首结点指向的第一个结点
        Node<T> oldFirst = head.next;
        if (oldFirst == null) {
            return null;
        }
        // 让首结点指向原来第一个结点的下一个结点
        head.next = oldFirst.next;
        // 元素个数-1
        N--;
        return oldFirst.item;
    }

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

    private class SIterator implements Iterator<T>{

        private Node<T> curr;

        public SIterator() {
            this.curr = head;
        }

        public boolean hasNext() {
            return curr.next!=null;
        }

        public T next() {
            curr = curr.next;
            return curr.item;
        }

        public void remove() {

        }

    }


    private static class Node<T> {
        //存储数据
        T item;
        //下一个结点
        Node next;

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


}

    public static void main(String[] args) {
        //创建栈对象
        StackList<String> stack = new StackList();

        //测试压栈
        stack.push("a");
        stack.push("b");
        stack.push("c");
        stack.push("d");

        for (String item : stack) {
            System.out.println(item);
        }
        System.out.println("------------------------------");
        //测试弹栈
        String result = stack.pop();
        System.out.println("弹出的元素是："+result);
        System.out.println("剩余的元素个数："+stack.size());

    }
输出：
d
c
b
a
------------------------------
弹出的元素是：d
剩余的元素个数：3
  

1.3.3 案例

1.3.3.1 括号匹配问题

问题描述:

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

示例代码：

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

    /**
     * 判断str中的括号是否匹配
     *
     * @param str 括号组成的字符串
     * @return 如果匹配，返回true，如果不匹配，返回false
     */
    public static boolean isMatch(String str) {
        //1.创建栈对象，用来存储左括号
        StackList<String> chars = new StackList();
        //2.从左往右遍历字符串
        for (int i = 0; i < str.length(); i++) {
            String currChar = String.valueOf(str.charAt(i));
            //3.判断当前字符是否为左括号，如果是，则把字符放入到栈中
            if (currChar.equals("(")) {
                chars.push(currChar);
            } else if (currChar.equals(")")) {
                //4.继续判断当前字符是否是有括号，如果是，则从栈中弹出一个左括号，
                // 并判断弹出的结果是否为null,如果为null证明没有匹配的左括号，
                // 如果不为null，则证明有匹配的左括号
                String pop = chars.pop();
                if (pop == null) {
                    return false;
                }
            }
        }
        //5.判断栈中还有没有剩余的左括号，如果有，则证明括号不匹配
        if (chars.size() == 0) {
            return true;
        } else {
            return false;
        }
    }
}
输出：
上海(长安)(())中的括号是否匹配：true

1.3.3.2 逆波兰表达式求值问题

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

兰表达式？要搞清楚逆波兰表达式，我们得从中缀表达式说起。

中缀表达式：

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

是置于两个操作数中间。

中缀表达式是人们最喜欢的表达式方式，因为简单，易懂。但是对于计算机来说就不是这样了，因为中缀表达式的

运算顺序不具有规律性。不同的运算符具有不同的优先级，如果计算机执行中缀表达式，需要解析表达式语义，做

大量的优先级相关操作。

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

逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法，后缀表

达式的特点：运算符总是放在跟它相关的操作数之后。

public class ReversePolishNotationTest {

    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);
        System.out.println(3 * (17 - 15) + 18 / 6);
    }

    /**
     * @param notaion 逆波兰表达式的数组表示方式
     * @return 逆波兰表达式的计算结果
     */
    public static int caculate(String[] notaion) {
        //1.定义一个栈，用来存储操作数
        StackList<Integer> oprands = new StackList();
        //2.从左往右遍历逆波兰表达式，得到每一个元素
        for (int i = 0; i < notaion.length; i++) {
            String curr = notaion[i];
            Integer o1;
            Integer o2;
            Integer result;
            //3.判断当前元素是运算符还是操作数
            switch (curr) {
                //4.运算符，从栈中弹出两个操作数，完成运算，运算完的结果再压入栈中
                case "+":
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 + o1;
                    oprands.push(result);
                    break;
                case "-":
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 - o1;
                    oprands.push(result);
                    break;
                case "*":
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 * o1;
                    oprands.push(result);
                    break;
                case "/":
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 / o1;
                    oprands.push(result);
                    break;
                default:
                    oprands.push(Integer.parseInt(curr));
                    //5.操作数，把该操作数放入到栈中；
                    break;
            }
        }
        //6.得到栈中最后一个元素，就是逆波兰表达式的结果
        int result = oprands.pop();
        return result;
    }

}
输出：
逆波兰表达式的结果为：9
9

1.4 队列

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

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

1.4.1 队列的API设计

1.4.2 队列的实现

public class Queue<T> implements Iterable<T> {
    //记录首结点
    private Node head;
    //记录最后一个结点
    private Node last;
    //记录队列中元素的个数
    private int N;

    public Queue() {
        this.head = new Node(null, null);
        this.last = null;
        N = 0;
    }

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

    //返回队列中元素的个数
    public int size() {
        return N;
    }

    //向队列中插入元素t
    public void enqueue(T t) {
        // 当前尾结点last = null
        if (last == null) {
            last = new Node(t, null);
            head.next = last;
        } else {
            // 当前尾结点last != null
            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--;
        //因为出队列其实是在删除元素，因此如果队列中的元素被删除完了，需要重置last=null;
        if (isEmpty()) {
            last = null;
        }

        return oldFirst.item;
    }


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

    private class QIterator implements Iterator {
        private Node n;

        public QIterator() {
            this.n = head;
        }

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

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

        @Override
        public void remove() {

        }
    }

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

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

}

    public static void main(String[] args) {
        //创建队列对象
        Queue<String> q = new Queue<>();

        //测试队列的enqueue方法
        q.enqueue("a");
        q.enqueue("b");
        q.enqueue("c");
        q.enqueue("d");

        for (String str : q) {
            System.out.println(str);
        }

        System.out.println("-------------------------------");
        //测试队列的dequeue方法
        String result = q.dequeue();
        System.out.println("出队列的元素是："+result);
        System.out.println("剩余的元素个数："+q.size());

    }
输出：
a
b
c
d
-------------------------------
出队列的元素是：a
剩余的元素个数：3

标签：Node,链表,结点,null,线性表,next,----,数据结构,public
来源： https://blog.csdn.net/weixin_44744094/article/details/122729959

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。