【数据结构】链表

前言

问：为什么使用链表？
答：当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此又引入了LinkedList，即链表结构。

一：链表(LinkedList)

1.1 链表分类

链表可分为三类：单链表、双向链表、循环列表
单向或者双向：

带头或者不带头：

循环或者非循环：

1.2 介绍

链表是有序的列表，但是它在内存中是存储如下

1. 链表是以节点的方式来存储,是链式存储
2. 每个节点包含 data 域， next 域：指向下一个节点.
3. 如图：发现链表的各个节点不一定是连续存储.
4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

1.3 链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序来实现的。类似于一节又一节火车。

二：单链表

2.1 单链表结构示意图

2.2 单链表的应用实例

实例：使用带head头的单向链表实现 –人物排行榜管理
功能：完成对人物的增删改查操作

2.3 单链表的添加

2.3.1 直接添加到链表的尾部（不考虑顺序）

2.3.1.1 整体思路

1. 先创建一个head头节点，作用就是表示单链表的头
2. 后面我们没添加一个节点，就直接加入到链表的最后
3. 通过一个辅助变量遍历，帮助遍历整个链表

2.3.1.2 代码实现

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //创建节点
        HeroNode hero1 = new HeroNode(1, "蔡徐坤", "ikun");
        HeroNode hero2 = new HeroNode(2, "刀郎", "罗刹海市");
        HeroNode hero3 = new HeroNode(3, "那英", "哪有鸟");
        HeroNode hero4 = new HeroNode(4, "汪峰", "春天里");
        HeroNode hero5 = new HeroNode(5, "杨坤", "马户");
        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        singleLinkedList.add(hero5);
        //显示
        singleLinkedList.list();
    }
}

/**
 * 定义singleLinkedList来管理我们的人员
 */
class SingleLinkedList {
    //先初始化头节点,头节点不要动,不存放具体数据
    private final HeroNode head = new HeroNode(0, "", "");

    /**
     * 添加节点到单链表
     * 思路：当不考虑编号顺序时，
     * 1.找到当前列表的最后一个节点
     * 2.将最后这个节点的next指向新的节点
     *
     * @param heroNode
     */
    public void add(HeroNode heroNode) {
        //因为head节点不能动，因此我们需要设置一个辅助变量temp，并且遍历temp
        HeroNode temp = head;
        //遍历链表，找到最后一个节点
        while (temp.next != null) {
            //找到链表的最后一个节点
            //如果没有找到，就将temp临时变量后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        temp.next = heroNode;
    }

    /**
     * 显示链表
     */
    public void list() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要使用一个辅助变量来遍历
        HeroNode temp = head.next;
        while (temp != null) {
            //判断是否到链表的最后
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }

    }

}


/**
 * 定义HeroNode，每个HeroNode对象就是一个节点
 */
class HeroNode {
    //头节点
    public int no;
    public String name;
    public String nickname;
    //指向下一个节点
    public HeroNode next;

    /**
     * 构造器
     */
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    /**
     * 重写toString方法
     *
     * @return String
     */
    @Override
    public String toString() {
        return "HeroNode{" + "no=" + no + ", name='" + name + ", nickname='" + nickname + '}';
    }


}

2.3.2 按顺序插入到指定位置(如果有这个排名，则添加失败，并给出提示)

2.3.2.1 思路分析

需按照编号的书序添加：

1. 首先找到新添加的节点的位置，是通过辅助变量（指针），通过遍历来搞定
2. 新的节点.next = temp.next;
3. 将temp.next指向新的节点

2.3.2.2 代码实现

 	/**
     * 按照顺序插入到指定位置，如果有这个排名，则添加失败，并给出提示
     *
     * @param heroNode
     */
    public void addByOrder(HeroNode heroNode) {
        //因为head节点不能动，因此我们需要设置一个辅助变量temp，并且遍历temp
        //因为是单链表，所以我们找的temp是位于添加位置的前一个节点，否则无法插入
        HeroNode temp = head;
        //添加的编号是否存在，默认为false
        boolean flag = false;
        //说明temp已经在链表的最后
        while (true) {
            if (temp.next == null) {
                break;
            }
            //位置找到，就在temp的后面插入
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                //此时说明heroNode编号已经存在,将flag变为true
                flag = true;
            }
            //如果以上条件都不满足，则将temp后移
            temp = temp.next;
        }

        //判断flag的值，如果flag为true则不能添加
        if (flag) {
            System.out.printf("编号%d,已经存在,无法添加", heroNode.no);
        } else {
            //插入到链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

2.3.2.3 测试

		singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero5);

此时顺序添加功能就实现了！

2.4 单链表的修改

/**
     * 通过no编号进行修改，no编号不可以修改
     *
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode) {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //根据no编号找到需要修改的节点
        //定义一个辅助变量
        HeroNode temp = head.next;
        //表示是否找到该节点
        boolean flag = false;
        while (true) {
            if (temp == null) {
                //链表已经遍历结束
                break;
            }
            if (temp.no == newHeroNode.no) {
                //此时说明已经找到了
                flag = true;
                break;
            }
            //将temp后移
            temp = temp.next;

        }
        //根据flag判断是否找到该节点
        if(flag){
            //找到了，则将temp重新赋值
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            //没找到该节点
            System.out.printf("没有找到编号为%d的节点，无法修改\n", newHeroNode.no);

        }

    }

2.5 单链表的删除

2.5.1 思路分析

从单链表中删除一个节点的思路：

1. 我们需要先找到删除节点的前一个节点temp
2. temp.next = temp.next.next
3. 被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收

2.5.2 代码实现

    /**
     * 思路
     * 1.因为头节点不能动，所以我们需要一个temp临时变量来找到删除节点的前一个节点
     * 2.在比较时，我们需要将temp.next.no和需要删除节点的no进行比较
     *
     * @param no 需要删除节点的编号
     */
    public void delete(int no) {
        //因为head节点不能动，因此我们需要设置一个辅助变量temp，并且遍历temp
        //因为是单链表，所以我们找的temp是位于添加位置的前一个节点
        HeroNode temp = head;
        //表示是否找到该节点
        boolean flag = false;
        while (true) {
            //说明temp已经在链表的最后
            if (temp.next == null) {
                break;
            }
            //找到待删除节点的前一个节点
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            //如果以上条件都不满足，则将temp后移
            temp = temp.next;
        }

        //判断flag的值，如果flag为true则找到
        if (flag) {
            //可以删除
            temp.next = temp.next.next;
        } else {
            System.out.printf("编号%d,不存在,无法删除", no);
        }
    }

2.5.3 测试

删除节点信息为3的信息

//删除一个节点信息
singleLinkedList.delete(3);

三：常见的单链表面试题

3.1 求单链表中有效节点的个数

/**
     * 获取单链表的节点个数
     * 注:如果是带头结点的，需求不统计头节点
     *
     * @param head
     * @return
     */
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            //空链表
            return 0;
        }
        int length = 0;
        //定义一个辅助变量
        HeroNode temp = head.next;
        //遍历
        while (temp != null) {
            length++;
            temp = temp.next;
        }
        return length;
    }

3.2 查找单链表中的倒数第k个结点

3.2.1 思路

 1.编写一个方法，接收head节点，同时接收一个index（index表示倒数的第index个节点）
 2.先把链表从头到尾遍历，得到链表的总长度size
 3.得到size后，我们从链表的第一个开始遍历（size - index）个，就可以得到
 4.如果找到了则返回该节点，否则返回null

3.2.2 代码实现

	/**
     * 查找单链表中的倒数第k个结点
     * 思路：
     * 1.编写一个方法，接收head节点，同时接收一个index（index表示倒数的第index个节点）
     * 2.先把链表从头到尾遍历，得到链表的总长度size
     * 3.得到size后，我们从链表的第一个开始遍历（size - index）个，就可以得到
     * 4.如果找到了则返回该节点，否则返回null
     *
     * @param head
     * @param index
     * @return
     */
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        //如果链表为空，则返回null
        if (head.next == null) {
            return null;
        }
        //获取链表节点得个数
        int size = getLength(head);
        //遍历size - index，就是我们需要的倒数第k个节点
        //先做index校验
        if (index <= 0 || index > size) {
            return null;
        }
        //定义辅助变量，for循环定位到倒数的index
        //假设数组长度为8，我们需要找到倒数第3个数据，则就是正数第8 - 3 = 5个数据
        HeroNode temp = head.next;
        for (int i = 0; i < size - index; i++) {
            temp = temp.next;
        }
        return temp;
    }

3.3 单链表的反转

3.3.1 思路分析

思路：

1.先定义一个节点，reverseHead = new HeroHead();
2.从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并且放在新的链表reverseHead的最前端
3.原来的链表的head.next = reverseHead.next;

3.3.2 代码实现

/**
     * 单链表的反转
     * 思路
     * 1.先定义一个节点，reverseHead = new HeroHead();
     * 2.从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并且放在新的链表reverseHead的最前端
     * 3.原来的链表的head.next = reverseHead.next;
     *
     * @param head
     */
    public static void reverseList(HeroNode head) {
        //如果只有一个节点或者链表是空的，则不需要反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        //定义一个辅助变量，来帮助我们循环遍历链表,cur表示当前节点
        HeroNode cur = head.next;
        //指向当前节点cur的下一个节点
        HeroNode next = null;
        //定义一个空的链表
        HeroNode reverseNode = new HeroNode(0, "", "");
        //遍历原来的链表，每遍历一个节点，就将其取出，放到新链表reverseNode的最前端
        //当cur为null时，说明已经遍历结束
        while (cur != null) {
            //先暂时保存当前节点的下一个节点
            next = cur.next;
            //将当前节点的下一个节点赋值给反转链表的最前端
            cur.next = reverseNode.next;
            //将cur连接到新的链表上
            reverseNode.next = cur;
            //将cur后移，继续向下遍历
            cur = next;
        }
        //将head.next指向reverseNode.next,实现单链表的反转
        head.next = reverseNode.next;
    }

四：双向环形链表

4.1 单链表的不足

1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
2. 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一个节点。

4.2 介绍

有两个指针域，一个指向后一个结点，一个指向前一个结点。它存储了前一个结点的地址与后一个结点的地址，所以可以很方便的进行向前遍历或者向后遍历。同时它还是一个循环链表，可以通过第一个结点直接找到最后一个结点。

next：指向下一个节点
pre：指向上一个节点

4.3 定义双向循环链表节点类

public class LinkedList<E> {
    /**
     * head用于存放头节点信息
     */
    private Node head;
    /**
     * 链表的长度
     */
    private Integer size = 0;

    /**
     *  Node用于描述表中的一个节点
     *  其中，data用于存放于元素
     *  next是存放前继节点
     *  prev用于存放指向其后继节点
     */
    class Node {
        //存放数据
        E data;
        //前继节点
        Node next;
        //后继节点
        Node prev;
        //构造器
        public Node(E e){
            data = e;
        }
    }

/**
     * 获得链表的长度
     *
     * @return
     */
    public int size() {
        return size;
    }
}

4.4 将元素追加到链表的末尾

/**
     * 将元素追加到链表的末尾
     * @param e 被添加的元素
     * @return 添加成功，返回true
     */
    public boolean add(E e){
        //将元素封装成一个节点
        Node node = new Node(e);
        //如果链表为空，则新节点就是头节点
        if(head == null){
            head = node;
            head.next = node;
            head.prev = node;
            //链表的长度加1
            size ++;
            return true;
        }
        //找到末尾节点地址
        Node last = head.prev;
        //将新节点添加到未节点后面
        last.next = node;
        node.next = head;
        head.prev = node;
        node.prev = last;
        //链表的长度加1
        size ++;
        return true;
    }

4.5 将元素插入到指定下标处

    /**
     * 将元素插入到指定下标处
     * @param index
     * @param e
     */
    public void add(int index,E e){
        if( index < 0 || index > size ){
            throw new IndexOutOfBoundsException("数组下标越界异常");
        }
        if(index == size){
           add(e);
        }
        //将元素封装成一个节点
        Node node = new Node(e);
        Node next = getNode(index);
        Node prev = next.prev;
        next.prev = node;
        node.prev = prev;
        prev.next = node;
        node.next = next;
        if(index == 0){
            head = node;
        }
        size ++;
    }

4.6 返回指定下标处的元素

/**
     * 返回指定下标处的元素
     * @param index 下标，从0开始
     * @return 对应位置处的元素
     */
    public E get(Integer index){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("数组下标越界异常");
        }
        Node node = getNode(index);
        //返回该节点存放的数据
        return node.data;
    }

4.7 移除指定位置处的元素

    /**
     * 移除指定位置处的元素
     *
     * @return
     */
    public E remove(Integer index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("数组下标越界异常");
        }
        //如果链表只有一个元素,则删除该节点以后，需要将head设置为null,并返回删除的元素
        if (size == 1) {
            E data = head.data;
            head = null;
            size--;
            return data;
        }
        //找到要删除的节点
        Node node = this.getNode(index);
        //找到该节点的前驱节点和后继节点
        Node next = node.next;
        Node prev = node.prev;
        //将该节点删除(其实就是在prev和next之间建立引用关系)
        prev.next = next;
        next.prev = prev;
        //如果被删除的元素为头节点,则其下一个节点为头节点
        if (index == 0) {
            head = next;
        }
        //链表长度减1
        size--;
        return node.data;
    }

4.8 返回指定位置的节点

    /**
     * 返回指定位置的节点
     *
     * @param index
     * @return
     */
    private Node getNode(Integer index) {
        //从头结点开始遍历
        Node node = this.head;
        //此时可以用移位运算
        //为了提升性能，可以通过比较index与链表的长度的一半来决定是向前遍历还是向后遍历
        if (index < size >> 1) {
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
        } else {
            for (int i = size; i > index; i--) {
                node = node.prev;
            }
        }
        return node;
    }

4.9 重写toString方法

 @Override
    public String toString() {
        if (head == null) {
            return "[]";
        }
        StringBuilder stringBuilder = new StringBuilder("[");
        stringBuilder.append(head.data);
        Node node = head.next;
        while (node.next != head) {
            stringBuilder.append(",").append(node.data);
            //继续查找下个节点
            node = node.next;
        }
        return stringBuilder.append("]").toString();
    }

4.10 测试

public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        List<Integer> arrayList = new ArrayList<>();
        list.add("Curry");
        list.add("Green");
        list.add("Thompson");
        list.add("Durant");
        list.add("James");
        System.out.println("size():" + list.size());
        System.out.println("get(2):" + list.get(2));
        System.out.println("list:" + list.toString());
    }
}