数据结构与算法之双向链表

曾经终败给现在 2021-12-11 09:49 350阅读 0赞

### 前言 ###

在上篇文章中，我们有介绍单向链表及如何实现，本次我们将来介绍如何实现双向链表。

### 双向链表介绍 ###

> 双向链表是链表中的一种。和单链表一样，双链表也是由节点组成，但与单向链表不同的是，单向链表中的节点只有一个指针指向下一个节点，而双向链表的节点有两个指针，分别指向前一个节点和后一个节点。所以，从双向链表中的任意一个结点开始，都可以很方便地获取到前一个节点和后一个节点

### 双向链表结构图 ###

![20190708205324156.png][]

### 双向链表实现 ###

和上篇单向链表一样，我们将实现双向链表，并实现以下功能：

*  增加
 *  删除
 *  修改
 *  获取链表长度
 *  查找
 *  链表反转
 *  显示链表数据

### 添加 ###

新增节点默认添加到链表最后，实现思路与单向链表大部分一致，不太一样的地方就是**将新增节点指向最后一个节点的下一个节点之后，还要将最后一个节点指向新增节点的前一个节点**

public boolean add(T item){
        Node<T> newNode = new Node<>(item);
    
        Node<T> tempNode = head; // 将头节点赋值给临时节点
        while(tempNode.next != null){ // 遍历找到最后一个节点
            tempNode = tempNode.next;
        }
    
        tempNode.next = newNode; // 将最后一个节点的next指向新的节点
        newNode.prev = tempNode; // 将最后一个节点指向新添加节点的prev
        return true;
    }

### 删除 ###

因为是双向链表，所以可以实现自我删除某个节点，直接找到要删除的这个节点，**第一步是将需要删除的节点的前一个节点的下一个节点指向删除节点的下一个节点，第二步将删除节点的下一个节点的前一个节点指向删除节点的前一个节点**，**此处需要注意，如果是已经是最后一个节点了，就无需执行第二步操作**。

public boolean remove(T item) {
        if (this.isEmpty()) {
            System.out.println("linkedList is empty");
            return false;
        }
    
        Node<T> tempNode = head; // 将头节点赋值给临时节点
        while (true) {
            if (item.equals(tempNode.next.item)) {
                tempNode.prev.next = tempNode.next;
                // 如果当前节点为最后一个节点，就无需执行下一个节点的前一个节点
                if(tempNode.next != null){
                    tempNode.next.prev = tempNode.prev;
                }
                return true;
            }
            tempNode = tempNode.next;
        }
        System.out.println("not find node item");
        return false;
    }

### 修改 ###

修改思路与单向链表一致

public boolean update(T sourceItem, T tragetItem) {
        if (this.isEmpty()) {
            System.out.println("linkedList is empty");
            return false;
        }
    
        Node<T> tempNode = head; // 将第一个节点赋值给临时节点
        while (true) {
            if (tempNode == null) {
                System.out.println("node is empty");
                break;
            }
            if (sourceItem.equals(tempNode.item)) {
                tempNode.item = tragetItem;
                return true;
            }
            tempNode = tempNode.next;
        }
    
        return false;
    }

### 获取链表长度 ###

获取链表长度思路与单向链表一致

public int size() {
        if (this.isEmpty()) {
            return 0;
        }
    
        int size = 0;
        Node<T> tempNode = head; // 将头节点赋值给临时节点
        while (tempNode.next != null) { // 遍历找到最后一个节点
            size++;
            tempNode = tempNode.next;
        }
    
        return size;
    }

### 查找（查找单链表中的倒数第k个结点） ###

查找实现思路与单向链表一致

public Node<T> findLastIndexNode(int index){
        if(this.isEmpty()){
            return null;
        }
    
        int size = this.size(); // 获取链表长度
        if(index <= 0 || index > size){
            return null;
        }
    
        Node<T> tempNode = head.next; // 将第一个有效节点赋值给临时变量
        for (int i = 0; i < size - index; i++) {
            tempNode = tempNode.next;
        }
    
        return tempNode;
    }

### 链表反转 ###

实现思路

链表反转有两种实现方式，一种是递归反转，一种是非递归反转，两种方式的操作顺序不太一样。

非递归反转：

非递归反转，是从链表头部第一个有效节点开始，依次遍历，替换当前节点的下一节点为前一个节点

public Node<T> reverseLinkList() {
        // 如果当前链表为空或者只有一个节点，则无需反转，直接返回
        if (this.isEmpty() || head.next.next == null) {
            return head;
        }
    
        Node<T> tempNode = head.next; // 将第一个有效节点赋值给临时变量
        Node<T> prev = null; // 临时变量前一个节点
        while (tempNode != null) {
            Node<T> next = tempNode.next; // 当前节点的下一个节点
            Node<T> currentNode = tempNode; // 当前遍历的节点
            // 将前一个节点赋值给当前节点的下一个节点(此处是进行节点反转)
            // 比如有a、b、c、d、e等5个几点，那第一个节点为a
            // 进行反转的话，a就成了最后一个节点，所以a的next = prev（当遍历第一个节点的时候，prev就等于null）
            // 遍历第二个节点b的时候，b的next就是prev，前一个节点为a，所以b就到了a的前面
            // 后面依次遍历
            currentNode.next = prev;
            // 将当前节点赋值给临时变量 -> 前一个节点
            prev = currentNode;
            tempNode = next; // 往后移动一个节点（a -> b）
        }
        return prev;
    }

递归反转：  
递归反转是从链表尾部节点开始

public Node<T> recursionReverseLinkList() {
        // 如果当前链表为空或者只有一个节点，则无需反转，直接返回
        if (this.isEmpty() || head.next.next == null) {
            return head;
        }
        return recursionReverse(head);
    }
    
    public Node<T> recursionReverse(Node<T> node){
        Node<T> prev = null;
        if (node == null || node.next == null) {
            return node;
        } else {
            // 递归找到最后一个节点
            prev = recursionReverse(node.next);
            // 设置当前节点的下一个下一个节点为前一个节点
            node.next.next = node;
            // 设置当前节点的下一个节点为null
            node.next = null;
        }
        return prev;
    }

### 遍历显示链表数据 ###

实现思路：

1.  判断链表是否为空
2.  定义一个临时变量，用于遍历的时候，节点向后移动
3.  遍历整个链表，依次打印输出

public void showLinkedList(Node<T> node){
        if (node == null || node.next == null) {
            System.out.println("linkedList is empty");
            return;
        }
    
        Node<T> tempNode = node; // 将头节点赋值给临时节点
        while (true){
            System.out.println(tempNode); // 输出节点信息
            if(tempNode.next == null){ // 判断是不是最后一个节点
                break;
            }
            tempNode = tempNode.next; // 节点向后移动
        }
    }

### 完整示例代码 ###

public class DoubleLikedList<T> {
    
        private Node<T> head = new Node<>(); // 头节点
    
        /**
         * 判断链表是否为空
         *
         * @return
         */
        public boolean isEmpty(){
            return head == null || head.next == null;
        }
    
        /**
         * 添加节点到单向链表
         *
         * @param item
         * @return
         */
        public boolean add(T item){
            Node<T> newNode = new Node<>(item);
    
            Node<T> tempNode = head; // 将头节点赋值给临时节点
            while(tempNode.next != null){ // 遍历找到最后一个节点
                tempNode = tempNode.next;
            }
    
            tempNode.next = newNode; // 将最后一个节点的next指向新的节点
            newNode.prev = tempNode; // 将最后一个节点指向新添加节点的prev
            return true;
        }
    
        /**
         * 修改节点数据
         *
         * @param sourceItem 节点原数据
         * @param tragetItem 节点新数据
         * @return
         */
        public boolean update(T sourceItem, T tragetItem) {
            if (this.isEmpty()) {
                System.out.println("linkedList is empty");
                return false;
            }
    
            Node<T> tempNode = head; // 将第一个节点赋值给临时节点
            while (true) {
                if (tempNode == null) {
                    System.out.println("node is empty");
                    break;
                }
                if (sourceItem.equals(tempNode.item)) {
                    tempNode.item = tragetItem;
                    return true;
                }
                tempNode = tempNode.next;
            }
    
            return false;
        }
    
        /**
         * 删除节点
         *
         * @param item 节点数据
         * @return
         */
        public boolean remove(T item) {
            if (this.isEmpty()) {
                System.out.println("linkedList is empty");
                return false;
            }
    
            Node<T> tempNode = head; // 将头节点赋值给临时节点
            while (true) {
                if (tempNode.next == null) {
                    System.out.println("node next is empty");
                    break;
                }
                if (item.equals(tempNode.next.item)) {
                    tempNode.prev.next = tempNode.next;
                    // 如果当前节点为最后一个节点，就无需执行下一个节点的前一个节点
                    if(tempNode.next != null){
                        tempNode.next.prev = tempNode.prev;
                    }
                    return true;
                }
                tempNode = tempNode.next;
            }
            System.out.println("not find node item");
            return false;
        }
    
        /**
         * 获取队列长度
         *
         * @return
         */
        public int size() {
            if (this.isEmpty()) {
                return 0;
            }
    
            int size = 0;
            Node<T> tempNode = head; // 将头节点赋值给临时节点
            while (tempNode.next != null) { // 遍历找到最后一个节点
                size++;
                tempNode = tempNode.next;
            }
    
            return size;
        }
    
        /**
         * 查找（查找单链表中的倒数第k个结点）
         *
         * @param index
         * @return
         */
        public Node<T> findLastIndexNode(int index){
            if(this.isEmpty()){
                return null;
            }
    
            int size = this.size(); // 获取链表长度
            if(index <= 0 || index > size){
                return null;
            }
    
            Node<T> tempNode = head.next; // 将第一个有效节点赋值给临时变量
            for (int i = 0; i < size - index; i++) {
                tempNode = tempNode.next;
            }
    
            return tempNode;
        }
    
        /**
         * 非递归反转链表：从头部开始处理，依次替换位置
         *
         * @return
         */
        public Node<T> reverseLinkList() {
            // 如果当前链表为空或者只有一个节点，则无需反转，直接返回
            if (this.isEmpty() || head.next.next == null) {
                return head;
            }
    
            Node<T> tempNode = head.next; // 将第一个有效节点赋值给临时变量
            Node<T> prev = null; // 临时变量前一个节点
            while (tempNode != null) {
                Node<T> next = tempNode.next; // 当前节点的下一个节点
                Node<T> currentNode = tempNode; // 当前遍历的节点
                // 将前一个节点赋值给当前节点的下一个节点(此处是进行节点反转)
                // 比如有a、b、c、d、e等5个几点，那第一个节点为a
                // 进行反转的话，a就成了最后一个节点，所以a的next = prev（当遍历第一个节点的时候，prev就等于null）
                // 遍历第二个节点b的时候，b的next就是prev，前一个节点为a，所以b就到了a的前面
                // 后面依次遍历
                currentNode.next = prev;
                // 将当前节点赋值给临时变量 -> 前一个节点
                prev = currentNode;
                tempNode = next; // 往后移动一个节点（a -> b）
            }
            return prev;
        }
    
        /**
         * 递归反转node节点：从尾部开始处理
         *
         * @return
         */
        public Node<T> recursionReverseLinkList() {
            // 如果当前链表为空或者只有一个节点，则无需反转，直接返回
            if (this.isEmpty() || head.next.next == null) {
                return head;
            }
            return recursionReverse(head);
        }
    
        /**
         * 递归反转
         *
         * @param node
         * @return
         */
        public Node<T> recursionReverse(Node<T> node){
            Node<T> prev = null;
            if (node == null || node.next == null) {
                return node;
            } else {
                // 递归找到最后一个节点
                prev = recursionReverse(node.next);
                // 设置当前节点的下一个下一个节点为前一个节点
                node.next.next = node;
                // 设置当前节点的下一个节点为null
                node.next = null;
            }
            return prev;
        }
    
        /**
         * 显示链表数据
         *
         */
        public void showLinkedList(){
            if (this.isEmpty()) {
                System.out.println("linkedList is empty");
                return;
            }
    
            Node<T> tempNode = head; // 将头节点赋值给临时节点
            while (true){
                System.out.println(tempNode); // 输出节点信息
                if(tempNode.next == null){ // 判断是不是最后一个节点
                    break;
                }
                tempNode = tempNode.next; // 节点向后移动
            }
        }
    
        /**
         * 根据指定节点显示链表数据
         *
         * @param node
         */
        public void showLinkedList(Node<T> node){
            if (node == null || node.next == null) {
                System.out.println("linkedList is empty");
                return;
            }
    
            Node<T> tempNode = node; // 将头节点赋值给临时节点
            while (true){
                System.out.println(tempNode); // 输出节点信息
                if(tempNode.next == null){ // 判断是不是最后一个节点
                    break;
                }
                tempNode = tempNode.next; // 节点向后移动
            }
        }
    
        /**
         * 链表节点类
         *
         * @param <T>
         */
        private class Node<T>{
            private T item; // 节点数据
            private Node<T> prev; // 前一个节点
            private Node<T> next; // 下一个节点
    
            public Node(){
            }
    
            public Node(T item){
                this.item = item;
            }
    
            public Node(T item,Node<T> next){
                this.item = item;
                this.next = next;
            }
    
            @Override
            public String toString() {
                return "Node{" + "item=" + item + '}';
            }
        }
    }

[20190708205324156.png]: /images/20211211/b394582b6b3545e5be8a5faa746637c5.png