数据结构与算法之双向链表(增删改查、有序增、正向遍历、反向遍历)

最新推荐文章于 2023-06-29 17:39:02 发布

qq_35671159

最新推荐文章于 2023-06-29 17:39:02 发布

阅读量598

点赞数 1

分类专栏：数据结构与算法文章标签：数据结构双向链表

本文链接：https://blog.csdn.net/qq_35671159/article/details/106525250

版权

数据结构与算法专栏收录该内容

19 篇文章 0 订阅

订阅专栏

双向链表
1.什么是双向链表: 每个节点都有前一个节点的位置和后一个节点的位置
2.为什么要用双向链表: 和单向链表比, 双向链表可以正反向的遍历, 而且可以自我删除节点. 单链表只能单向遍历, 并且在删除节点时需要找到待删除节点的前一个节点.
3.怎么用双向链表:

public class DoublyLinkedList {
    // 头节点
    private final Node headNode = new Node(0, "", "");

    /**
     * 添加节点
     *
     * @param newNode 新节点
     */
    public void add(Node newNode) {
        Node temp = headNode;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = newNode;
        newNode.pre = temp;
    }

    /**
     * 删除节点
     *
     * @param no 节点编号
     */
    public void remove(int no) { // 1 5 2 4 3
        boolean removeFlag = false;
        Node currentNode = headNode.next;
        while (true) {
            if (currentNode == null) {
                break;
            }
            if (currentNode.no == no) {
                removeFlag = true;
                break;
            }
            currentNode = currentNode.next;
        }
        if (removeFlag) {
            currentNode.pre.next = currentNode.next;
            // 这里需要判断是否是最后一个节点, 如果不是最后一个节点则需要将当前节点的下一个节点的pre指针指向当前节点的前一个节点
            if (currentNode.next != null) {
                currentNode.next.pre = currentNode.pre;
            }
        } else {
            System.out.printf("%d Node does not exists...\n", no);
        }
    }

    /**
     * 修改链表节点
     *
     * @param node 需要修改的节点
     */
    public void update(Node node) {
        Node currentNode = headNode.next;
        boolean isExists = false;
        while (true) {
            if (currentNode == null) {
                break;
            }
            if (currentNode.no == node.no) {
                isExists = true;
                break;
            }
            currentNode = currentNode.next;
        }
        if (isExists) {
            currentNode.name = node.name;
            currentNode.nickname = node.nickname;
        } else {
            System.out.printf("%d node does not exists\n", node.no);
        }
    }

    /**
     * 获取节点信息
     *
     * @param no 节点编号
     */
    public Node get(int no) {
        Node currentNode = headNode.next;
        boolean isExists = false;
        while (true) {
            if (currentNode == null) {
                break;
            }
            if (currentNode.no == no) {
                isExists = true;
                break;
            }
            currentNode = currentNode.next;
        }
        if (isExists) {
            return currentNode;
        }
        return null;
    }

    /**
     * 按照节点编号自然序插入节点
     *
     * @param newNode 新节点
     */
    public void OrderInsert(Node newNode) {
        Node temp = headNode;
        boolean isExists = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == newNode.no) {
                isExists = true;
                break;
            }
            if (temp.next.no > newNode.no) {
                break;
            }
            temp = temp.next;
        }
        if (isExists) {
            System.out.printf("%d number node is exists, does not add\n", newNode.no);
        } else {
            if (temp.next != null) {
                newNode.next = temp.next;
                temp.next.pre = newNode;
            }
            temp.next = newNode;
            newNode.pre = temp;
        }
    }

    /**
     * 正向遍历
     */
    public void foreachLinkedList() {
        Node temp = headNode;
        if (temp.next == null) {
            System.out.println("链表为空...");
        }
        while (temp.next != null) {
            System.out.println(temp.next);
            temp = temp.next;
        }
    }

    /**
     * 反向遍历链表
     */
    public void reverseForeachLinkedList() {
        Node temp = headNode;
        while (temp.next != null) {
            temp = temp.next;
        }
        while (temp.pre != null) { // 因为最后一个是头节点, 所以此处可以这样写
            System.out.println(temp);
            temp = temp.pre;
        }
    }

    public static class Node {
        private final int no;
        private String name;
        private String nickname;
        private Node next;
        private Node pre;

        public Node(int no, String name, String nickname) {
            this.no = no;
            this.name = name;
            this.nickname = nickname;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "no=" + no +
                    ", name='" + name + '\'' +
                    ", nickname='" + nickname + '\'' +
                    ", next=" + next +
                    '}';
        }
    }

}

// 测试类
public class DoublyLinkedListTest {
    public static void main(String[] args) {
        DoublyLinkedList.Node node1 = new DoublyLinkedList.Node(1, "宋江", "及时雨");
        DoublyLinkedList.Node node2 = new DoublyLinkedList.Node(2, "卢俊义", "玉麒麟");
        DoublyLinkedList.Node node3 = new DoublyLinkedList.Node(3, "吴用", "智多星");
        DoublyLinkedList.Node node4 = new DoublyLinkedList.Node(4, "林冲", "豹子头");
        DoublyLinkedList.Node node5 = new DoublyLinkedList.Node(5, "武松", "行者");
        // 按照插入顺序添加节点
        DoublyLinkedList dll = new DoublyLinkedList();
        dll.add(node1);
        dll.add(node5);
        dll.add(node2);
        dll.add(node4);
        dll.add(node3);
        // 遍历节点
        System.out.println(">>> 顺序添加节点以后, 正向遍历链表: ");
        dll.foreachLinkedList();
        // 根据节点编号删除节点
        dll.remove(1);
        dll.remove(3);
        dll.remove(5);
        dll.remove(4);
        dll.remove(2);
        // 遍历删除后的链表
        System.out.println(">>> 删除完链表以后, 正向遍历链表: ");
        dll.foreachLinkedList(); // 会提示链表为空的警告
        System.out.println(">>> 删除链表中不存在的编号: ");
        dll.remove(2); // 此时链表为空, 如果再删会提示2编号不存在的警告
        // 使用排序方法添加节点
        DoublyLinkedList.Node node6 = new DoublyLinkedList.Node(6, "宋江", "及时雨");
        DoublyLinkedList.Node node7 = new DoublyLinkedList.Node(7, "卢俊义", "玉麒麟");
        DoublyLinkedList.Node node8 = new DoublyLinkedList.Node(8, "吴用", "智多星");
        DoublyLinkedList.Node node9 = new DoublyLinkedList.Node(9, "林冲", "豹子头");
        DoublyLinkedList.Node node10 = new DoublyLinkedList.Node(10, "武松", "行者");
        dll.OrderInsert(node6);
        dll.OrderInsert(node8);
        dll.OrderInsert(node10);
        dll.OrderInsert(node9);
        dll.OrderInsert(node7);
        System.out.println(">>> 使用排序方法插入链表以后, 正向遍历链表: ");
        dll.foreachLinkedList();
        System.out.println(">>> 使用排序方法插入链表已存在的编号: ");
        dll.OrderInsert(node7); // 提示3号编号节点已存在的警告
        // 修改节点, 将吴用改为浪子燕青(编号不变)
        DoublyLinkedList.Node node7$ = new DoublyLinkedList.Node(7, "燕青", "浪子");
        dll.update(node7$);
        System.out.println(">>> 更新节点之后, 遍历链表: ");
        dll.foreachLinkedList();
        // 查询节点
        System.out.println(">>> 查询链表中的7号节点: ");
        System.out.println(dll.get(7));
        // 反向遍历链表
        System.out.println(">>> 反向遍历链表: ");
        dll.reverseForeachLinkedList();
    }
}

// 测试结果
>>> 顺序添加节点以后, 正向遍历链表:
    Node{no=1, name='宋江', nickname='及时雨', next=Node{no=5, name='武松', nickname='行者', next=Node{no=2, name='卢俊义', nickname='玉麒麟', next=Node{no=4, name='林冲', nickname='豹子头', next=Node{no=3, name='吴用', nickname='智多星', next=null}}}}}
    Node{no=5, name='武松', nickname='行者', next=Node{no=2, name='卢俊义', nickname='玉麒麟', next=Node{no=4, name='林冲', nickname='豹子头', next=Node{no=3, name='吴用', nickname='智多星', next=null}}}}
    Node{no=2, name='卢俊义', nickname='玉麒麟', next=Node{no=4, name='林冲', nickname='豹子头', next=Node{no=3, name='吴用', nickname='智多星', next=null}}}
    Node{no=4, name='林冲', nickname='豹子头', next=Node{no=3, name='吴用', nickname='智多星', next=null}}
    Node{no=3, name='吴用', nickname='智多星', next=null}
>>> 删除完链表以后, 正向遍历链表:
    链表为空...
>>> 删除链表中不存在的编号:
    2 Node does not exists...
>>> 使用排序方法插入链表以后, 正向遍历链表:
    Node{no=6, name='宋江', nickname='及时雨', next=Node{no=7, name='卢俊义', nickname='玉麒麟', next=Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}}}
    Node{no=7, name='卢俊义', nickname='玉麒麟', next=Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}}
    Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}
    Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}
    Node{no=10, name='武松', nickname='行者', next=null}
>>> 使用排序方法插入链表已存在的编号:
    7 number node is exists, does not add
>>> 更新节点之后, 遍历链表:
    Node{no=6, name='宋江', nickname='及时雨', next=Node{no=7, name='燕青', nickname='浪子', next=Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}}}
    Node{no=7, name='燕青', nickname='浪子', next=Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}}
    Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}
    Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}
    Node{no=10, name='武松', nickname='行者', next=null}
>>> 查询链表中的7号节点:
    Node{no=7, name='燕青', nickname='浪子', next=Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}}
>>> 反向遍历链表:
    Node{no=10, name='武松', nickname='行者', next=null}
    Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}
    Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}
    Node{no=7, name='燕青', nickname='浪子', next=Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}}
    Node{no=6, name='宋江', nickname='及时雨', next=Node{no=7, name='燕青', nickname='浪子', next=Node{no=8, name='吴用', nickname='智多星', next=Node{no=9, name='林冲', nickname='豹子头', next=Node{no=10, name='武松', nickname='行者', next=null}}}}}

一、总结：

1. 增加节点时需要将新节点的pre指针指向当前链表的最后一个节点(newNode.pre = temp 这个动作)

2. 移除节点时需要考虑待移除的节点是否是链表最后一个节点的情况，避免出现NPE异常

二、探究一个有趣的事情：

我们把编号为1，2，3，4，5的节点按照1，3，5，4，2的顺序移除之后，这些节点的依赖情况：

从上图可以看出来：

1）0 即编号为0的头节点的next和pre指针指向都变为空，也就意味着链表为空了；

2）1，5，2节点还分别持有头节点的引用；

3）1节点持有5节点的引用；

4）5节点持有2节点的引用；

5）4节点持有2节点的引用；

6）3节点持有4节点的引用；

所以，这也是什么我在代码中清空完列表以后，没有复用1~5节点，而是重新创建了6~10节点的原因

qq_35671159

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构与算法之双向链表(增删改查、有序增、正向遍历、反向遍历)

双向链表1.什么是双向链表: 每个节点都有前一个节点的位置和后一个节点的位置2.为什么要用双向链表: 和单向链表比, 双向链表可以正反向的遍历, 而且可以自我删除节点. 单链表只能单向遍历, 并且在删除节点时需要找到待删除节点的前一个节点.3.怎么用双向链表:public class DoublyLinkedList { // 头节点 private final Node headNode = new Node(0, "", ""); /** * 添加节点.
复制链接

扫一扫

专栏目录