第十天算法设计

下面是使用Java编写的双向链表（Doubly Linked List）实现，结构上类似你提供的冒泡排序算法。我们会设计两个类：

Node类：表示链表节点，每个节点包含一个数据元素，指向前一个节点和下一个节点的引用。
DoublyLinkedList类：表示双向链表，提供插入节点、删除节点、遍历链表等功能。
DoublyLinkedListTest类：测试类，用于创建双向链表并展示其内容。
Node类
java
package suanfa;

public class Node {
// 数据元素
public Comparable data;
// 指向下一个节点的引用
public Node next;
// 指向前一个节点的引用
public Node prev;

// 构造函数
public Node(Comparable data) {
    this.data = data;
    this.next = null;
    this.prev = null;
}

}
DoublyLinkedList类
java
package suanfa;

public class DoublyLinkedList {
// 链表的头节点
private Node head;
// 链表的尾节点
private Node tail;

// 构造函数
public DoublyLinkedList() {
    this.head = null;
    this.tail = null;
}

// 向链表末尾添加节点
public void add(Comparable data) {
    Node newNode = new Node(data);
    if (head == null) {
        head = newNode; // 如果链表为空，将新节点作为头节点
        tail = newNode; // 如果链表为空，将新节点作为尾节点
    } else {
        tail.next = newNode; // 将新节点链接到尾节点的next
        newNode.prev = tail; // 将尾节点作为新节点的prev
        tail = newNode; // 更新尾节点为新节点
    }
}

// 删除链表中的指定节点
public void remove(Comparable data) {
    Node current = head;
    while (current != null) {
        if (current.data.equals(data)) {
            if (current.prev != null) {
                current.prev.next = current.next; // 如果有前节点，更新前节点的next
            } else {
                head = current.next; // 如果是头节点，更新头节点
            }
            if (current.next != null) {
                current.next.prev = current.prev; // 如果有后节点，更新后节点的prev
            } else {
                tail = current.prev; // 如果是尾节点，更新尾节点
            }
            break;
        }
        current = current.next;
    }
}

// 遍历链表并打印每个节点的数据
public void printList() {
    Node current = head;
    while (current != null) {
        System.out.print(current.data + " ");
        current = current.next;
    }
    System.out.println();
}

// 从尾部遍历链表并打印每个节点的数据
public void printReverse() {
    Node current = tail;
    while (current != null) {
        System.out.print(current.data + " ");
        current = current.prev;
    }
    System.out.println();
}

}
DoublyLinkedListTest类
java
package suanfa;

public class DoublyLinkedListTest {
public static void main(String[] args) {
// 创建一个新的双向链表
DoublyLinkedList list = new DoublyLinkedList();

    // 向链表添加元素
    list.add(4);
    list.add(5);
    list.add(6);
    list.add(3);
    list.add(2);
    list.add(1);
    
    // 打印链表内容
    System.out.println("Linked list in forward order:");
    list.printList();
    
    // 打印链表内容（从尾部遍历）
    System.out.println("Linked list in reverse order:");
    list.printReverse();
    
    // 删除一个节点
    list.remove(3);
    System.out.println("After removing 3:");
    list.printList();
    
    // 删除头节点
    list.remove(4);
    System.out.println("After removing head (4):");
    list.printList();
    
    // 删除尾节点
    list.remove(1);
    System.out.println("After removing tail (1):");
    list.printList();
}