学习笔记——链表

链表的定义

链表（Linked List）是一种线性数据结构，其中的元素（节点）在内存中不是连续存储的，而是通过指针（引用）相互连接。每个节点包含数据部分和指向下一个节点的引用（指针）。

• 节点（Node）：链表中的基本单元，包含数据和指向下一个节点的引用。
• 头节点（Head）：链表的第一个节点，用于访问整个链表。
• 尾节点（Tail）：链表的最后一个节点，其下一个节点引用为null。

链表的类型

• 单链表（Singly Linked List）：每个节点只有一个指向下一个节点的引用。
• 双链表（Doubly Linked List）：每个节点有两个引用，一个指向前一个节点，一个指向下一个节点。
• 循环链表（Circular Linked List）：链表的最后一个节点指向第一个节点，形成一个环。

单链表的实现

节点类

首先定义一个节点类，包含数据和指向下一个节点的引用。

class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

链表类

定义链表类，包含头节点和一些基本操作，如插入、删除和遍历。

class LinkedList {
    Node head;

    // 插入节点到链表尾部
    public void append(int data) {
        if (head == null) {
            head = new Node(data);
            return;
        }
        Node current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = new Node(data);
    }

    // 插入节点到链表头部
    public void prepend(int data) {
        Node newHead = new Node(data);
        newHead.next = head;
        head = newHead;
    }

    // 删除第一个值为data的节点
    public void delete(int data) {
        if (head == null) return;
        if (head.data == data) {
            head = head.next;
            return;
        }
        Node current = head;
        while (current.next != null) {
            if (current.next.data == data) {
                current.next = current.next.next;
                return;
            }
            current = current.next;
        }
    }

    // 打印链表
    public void printList() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}

双链表的实现

节点类

定义一个双链表节点类，包含数据和指向前一个节点和后一个节点的引用。

class DoublyNode {
    int data;
    DoublyNode prev;
    DoublyNode next;

    public DoublyNode(int data) {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
}

链表类

定义双链表类，包含头节点和一些基本操作，如插入、删除和遍历。

class DoublyLinkedList {
    DoublyNode head;

    // 插入节点到链表尾部
    public void append(int data) {
        if (head == null) {
            head = new DoublyNode(data);
            return;
        }
        DoublyNode current = head;
        while (current.next != null) {
            current = current.next;
        }
        DoublyNode newNode = new DoublyNode(data);
        current.next = newNode;
        newNode.prev = current;
    }

    // 插入节点到链表头部
    public void prepend(int data) {
        DoublyNode newHead = new DoublyNode(data);
        newHead.next = head;
        if (head != null) {
            head.prev = newHead;
        }
        head = newHead;
    }

    // 删除第一个值为data的节点
    public void delete(int data) {
        if (head == null) return;
        if (head.data == data) {
            head = head.next;
            if (head != null) {
                head.prev = null;
            }
            return;
        }
        DoublyNode current = head;
        while (current != null) {
            if (current.data == data) {
                if (current.prev != null) {
                    current.prev.next = current.next;
                }
                if (current.next != null) {
                    current.next.prev = current.prev;
                }
                return;
            }
            current = current.next;
        }
    }

    // 打印链表
    public void printList() {
        DoublyNode current = head;
        while (current != null) {
            System.out.print(current.data + " <-> ");
            current = current.next;
        }
        System.out.println("null");
    }
}

总结

链表是一种灵活的数据结构，适用于需要频繁插入和删除操作的场景。单链表和双链表是两种常见的链表类型，分别适用于不同的需求。掌握链表的基本操作和实现方法，对于理解和解决实际问题中的数据结构问题至关重要。