java带头节点的双向循环链表

原创

mob64ca12dba5b0 2024-10-05 03:35:05 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12dba5b0的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java带头节点的双向循环链表实现教程

在这篇文章中，我将教你如何在Java中实现一个带有头节点的双向循环链表。我们将一步一步地搭建这个数据结构，并讨论每一步中需要注意的细节。

1. 流程概述

在实现双向循环链表之前，我们需要明确整个实现的流程。下面是我们将要执行的步骤：

步骤	描述
1	定义节点类
2	定义双向循环链表类
3	实现链表的基本操作
4	测试链表的功能

2. 详细步骤

步骤1：定义节点类

首先，我们需要定义一个基本的节点类，每个节点都包含一个值和指向前后节点的引用。

class Node {
    int data;        // 数据域
    Node prev;      // 指向前一个节点的引用
    Node next;      // 指向下一个节点的引用

    // 构造函数
    public Node(int data) {
        this.data = data;
        this.prev = null; // 初始化前节点为null
        this.next = null; // 初始化后节点为null
    }
}

步骤2：定义双向循环链表类

接下来，我们需要定义一个包含头节点的双向循环链表类。这个类将包含链表的操作方法。

class DoublyCircularLinkedList {
    private Node head; // 头节点

    // 构造函数
    public DoublyCircularLinkedList() {
        head = new Node(0); // 创建头节点
        head.prev = head;   // 头节点指向自己
        head.next = head;   // 头节点指向自己
    }
}

步骤3：实现链表的基本操作

在这一部分，我们将实现双向循环链表的一些基本操作，如插入节点、删除节点和遍历链表。

3.1 插入节点

我们需要在链表的末尾插入一个节点。

// 在链表末尾插入节点
public void insert(int data) {
    Node newNode = new Node(data); // 创建新节点
    Node tail = head.prev;         // 获取当前尾节点

    // 更新指针
    tail.next = newNode;           // 当前尾节点的next指向新节点
    newNode.prev = tail;           // 新节点的prev指向当前尾节点
    newNode.next = head;           // 新节点的next指向头节点
    head.prev = newNode;           // 头节点的prev指向新节点
}

3.2 删除节点

我们也需要实现删除节点的操作。

// 删除节点
public void delete(Node node) {
    // 如果链表为空或节点无效，直接返回
    if (head.next == head || node == null) {
        return;
    }

    // 更新指针
    node.prev.next = node.next;   // 前一个节点的next指向要删除节点的next
    node.next.prev = node.prev;   // 后一个节点的prev指向要删除节点的prev
}

3.3 遍历链表

最后，我们需要一个方法来遍历链表并打印每个节点的数据。

// 遍历链表并打印节点数据
public void display() {
    Node current = head.next; // 从头节点的下一个节点开始
    while (current != head) {  // 如果当前节点不是头节点
        System.out.print(current.data + " "); // 打印节点数据
        current = current.next; // 移动到下一个节点
    }
    System.out.println(); // 换行
}

步骤4：测试链表的功能

最后，我们需要在主方法中测试以上实现的链表功能。

public class Main {
    public static void main(String[] args) {
        DoublyCircularLinkedList list = new DoublyCircularLinkedList(); // 创建链表对象

        list.insert(1); // 插入数据1
        list.insert(2); // 插入数据2
        list.insert(3); // 插入数据3

        System.out.print("当前链表: ");
        list.display(); // 显示链表

        // 删除数据2
        Node nodeToDelete = list.head.next.next; // 获取要删除的节点
        list.delete(nodeToDelete); // 删除节点

        System.out.print("删除节点2后的链表: ");
        list.display(); // 再次显示链表
    }
}

3. 旅行图示意

在实现的过程中，你可以使用旅行图来帮助你理解每一步：

journey
    title 双向循环链表实现流程
    section 定义节点
      创建Node类: 5: 我
      包含data, prev, next: 4: 我
      编写构造函数: 5: 我
    section 定义链表
      创建DoublyCircularLinkedList类: 5: 我
      添加头节点: 5: 我
    section 实现操作
      插入节点: 4: 我
      删除节点: 4: 我
      遍历链表: 4: 我
    section 测试功能
      创建链表对象: 5: 我
      插入节点: 4: 我
      打印链表: 4: 我
      删除节点: 5: 我
      再次打印链表: 5: 我