1. PingCode智库首页
  2. 百科

java双相链表 如何理解

Edit1 • • 百科

java双相链表 如何理解

Java中的双向链表（Doubly Linked List）是一种链表数据结构，其中每个节点包含三个部分：一个数据字段、一个指向前一个节点的指针（prev）以及一个指向下一个节点的指针（next）。双向链表与单向链表的主要区别在于，双向链表允许在任意方向遍历链表，而单向链表只能从头节点遍历到尾节点。双向链表的这种特性使得插入和删除操作更加高效，因为无需遍历整个链表即可访问前一个节点。双向链表的主要优点包括：双向遍历、删除操作更高效、插入操作更方便。其中，双向遍历是最显著的优点，允许我们在任意方向上进行链表的操作。

详细来说，双向链表的双向遍历特性极大地增强了数据操作的灵活性。例如，在某些算法中，需要频繁地在链表前后移动节点，双向链表则能显著提高效率。相比于单向链表，双向链表不需要从头开始查找前一个节点，直接通过prev指针即可访问。

一、双向链表的基本概念

1、节点结构

在双向链表中，每个节点包含三个部分：数据字段、前指针（prev）和后指针（next）。这些指针分别指向前一个节点和后一个节点。下面是一个简单的节点类的定义：

class Node {


    int data;


    Node prev;


    Node next;


    Node(int data) {


        this.data = data;


    }


}

2、链表结构

双向链表通常有一个头节点（head）和一个尾节点（tail）。头节点指向链表的第一个节点，尾节点指向链表的最后一个节点。链表的头节点和尾节点的prev和next指针分别为null。

class DoublyLinkedList {


    Node head;


    Node tail;


    // 初始化链表为空


    DoublyLinkedList() {


        this.head = null;


        this.tail = null;


    }


}

二、双向链表的基本操作

1、插入操作

插入操作包括在头部插入、在尾部插入和在指定位置插入。

在头部插入

在头部插入新的节点时，需要更新新节点的next指针指向当前的头节点，并且更新当前头节点的prev指针指向新节点。最后，将新节点设置为新的头节点。

public void insertAtHead(int data) {


    Node newNode = new Node(data);


    if (head == null) {


        head = newNode;


        tail = newNode;


    } else {


        newNode.next = head;


        head.prev = newNode;


        head = newNode;


    }


}

在尾部插入

在尾部插入新的节点时，需要更新新节点的prev指针指向当前的尾节点，并且更新当前尾节点的next指针指向新节点。最后，将新节点设置为新的尾节点。

public void insertAtTail(int data) {


    Node newNode = new Node(data);


    if (tail == null) {


        head = newNode;


        tail = newNode;


    } else {


        newNode.prev = tail;


        tail.next = newNode;


        tail = newNode;


    }


}

在指定位置插入

在指定位置插入新的节点时，需要遍历链表找到指定位置的节点，然后更新新节点的prev和next指针，以及前后节点的指针。

public void insertAtPosition(int data, int position) {


    Node newNode = new Node(data);


    if (position == 0) {


        insertAtHead(data);


        return;


    }


    Node current = head;


    for (int i = 0; i < position - 1 && current != null; i++) {


        current = current.next;


    }


    if (current == null) {


        throw new IndexOutOfBoundsException("Position out of bounds");


    }


    newNode.next = current.next;


    newNode.prev = current;


    if (current.next != null) {


        current.next.prev = newNode;


    } else {


        tail = newNode;


    }


    current.next = newNode;


}

2、删除操作

删除操作包括删除头节点、删除尾节点和删除指定位置的节点。

删除头节点

删除头节点时，需要将当前头节点的next节点设置为新的头节点，并且将新头节点的prev指针设置为null。

public void deleteHead() {


    if (head == null) {


        return;


    }


    if (head.next == null) {


        head = null;


        tail = null;


    } else {


        head = head.next;


        head.prev = null;


    }


}

删除尾节点

删除尾节点时，需要将当前尾节点的prev节点设置为新的尾节点，并且将新尾节点的next指针设置为null。

public void deleteTail() {


    if (tail == null) {


        return;


    }


    if (tail.prev == null) {


        head = null;


        tail = null;


    } else {


        tail = tail.prev;


        tail.next = null;


    }


}

删除指定位置的节点

删除指定位置的节点时，需要遍历链表找到该位置的节点，然后更新前后节点的指针。

public void deleteAtPosition(int position) {


    if (position == 0) {


        deleteHead();


        return;


    }


    Node current = head;


    for (int i = 0; i < position && current != null; i++) {


        current = current.next;


    }


    if (current == null) {


        throw new IndexOutOfBoundsException("Position out of bounds");


    }


    if (current.next != null) {


        current.next.prev = current.prev;


    } else {


        tail = current.prev;


    }


    if (current.prev != null) {


        current.prev.next = current.next;


    }


}

三、双向链表的遍历

1、从头到尾遍历

从头到尾遍历链表时，从头节点开始，逐步访问每个节点的next指针，直到尾节点。

public void traverseForward() {


    Node current = head;


    while (current != null) {


        System.out.print(current.data + " ");


        current = current.next;


    }


    System.out.println();


}

2、从尾到头遍历

从尾到头遍历链表时，从尾节点开始，逐步访问每个节点的prev指针，直到头节点。

public void traverseBackward() {


    Node current = tail;


    while (current != null) {


        System.out.print(current.data + " ");


        current = current.prev;


    }


    System.out.println();


}

四、双向链表的优缺点

1、优点

  • 双向遍历：双向链表允许从任意方向遍历链表，这在某些算法中非常有用。
  • 删除操作更高效：删除操作不需要遍历整个链表即可找到前一个节点，直接通过prev指针即可访问。
  • 插入操作更方便：在指定位置插入新节点时，可以直接更新前后节点的指针，而不需要遍历整个链表。

2、缺点

  • 占用更多内存：双向链表的每个节点需要存储两个指针（prev和next），因此占用的内存比单向链表更多。
  • 操作更复杂：需要维护两个指针，插入和删除操作相对复杂。

五、应用场景

双向链表在许多应用中非常有用，特别是在需要频繁插入和删除操作的场景中。例如：

  • 浏览器的前进和后退功能：浏览器的前进和后退功能可以使用双向链表来实现，每个网页作为一个节点，前进和后退操作通过prev和next指针来导航。
  • 文本编辑器的撤销和重做功能：文本编辑器的撤销和重做功能也可以使用双向链表来实现，每个编辑操作作为一个节点，撤销和重做通过prev和next指针来导航。
  • 内存管理：操作系统的内存管理可以使用双向链表来维护空闲内存块和已分配内存块。

六、双向链表的实现示例

下面是一个完整的双向链表实现示例，包含插入、删除和遍历操作：

public class DoublyLinkedList {


    class Node {


        int data;


        Node prev;


        Node next;


        Node(int data) {


            this.data = data;


        }


    }


    private Node head;


    private Node tail;


    public DoublyLinkedList() {


        this.head = null;


        this.tail = null;


    }


    public void insertAtHead(int data) {


        Node newNode = new Node(data);


        if (head == null) {


            head = newNode;


            tail = newNode;


        } else {


            newNode.next = head;


            head.prev = newNode;


            head = newNode;


        }


    }


    public void insertAtTail(int data) {


        Node newNode = new Node(data);


        if (tail == null) {


            head = newNode;


            tail = newNode;


        } else {


            newNode.prev = tail;


            tail.next = newNode;


            tail = newNode;


        }


    }


    public void insertAtPosition(int data, int position) {


        Node newNode = new Node(data);


        if (position == 0) {


            insertAtHead(data);


            return;


        }


        Node current = head;


        for (int i = 0; i < position - 1 && current != null; i++) {


            current = current.next;


        }


        if (current == null) {


            throw new IndexOutOfBoundsException("Position out of bounds");


        }


        newNode.next = current.next;


        newNode.prev = current;


        if (current.next != null) {


            current.next.prev = newNode;


        } else {


            tail = newNode;


        }


        current.next = newNode;


    }


    public void deleteHead() {


        if (head == null) {


            return;


        }


        if (head.next == null) {


            head = null;


            tail = null;


        } else {


            head = head.next;


            head.prev = null;


        }


    }


    public void deleteTail() {


        if (tail == null) {


            return;


        }


        if (tail.prev == null) {


            head = null;


            tail = null;


        } else {


            tail = tail.prev;


            tail.next = null;


        }


    }


    public void deleteAtPosition(int position) {


        if (position == 0) {


            deleteHead();


            return;


        }


        Node current = head;


        for (int i = 0; i < position && current != null; i++) {


            current = current.next;


        }


        if (current == null) {


            throw new IndexOutOfBoundsException("Position out of bounds");


        }


        if (current.next != null) {


            current.next.prev = current.prev;


        } else {


            tail = current.prev;


        }


        if (current.prev != null) {


            current.prev.next = current.next;


        }


    }


    public void traverseForward() {


        Node current = head;


        while (current != null) {


            System.out.print(current.data + " ");


            current = current.next;


        }


        System.out.println();


    }


    public void traverseBackward() {


        Node current = tail;


        while (current != null) {


            System.out.print(current.data + " ");


            current = current.prev;


        }


        System.out.println();


    }


    public static void main(String[] args) {


        DoublyLinkedList list = new DoublyLinkedList();


        list.insertAtHead(1);


        list.insertAtTail(2);


        list.insertAtTail(3);


        list.insertAtPosition(4, 2);


        System.out.println("Forward traversal:");


        list.traverseForward();


        System.out.println("Backward traversal:");


        list.traverseBackward();


        list.deleteAtPosition(2);


        System.out.println("After deletion at position 2:");


        list.traverseForward();


        list.deleteHead();


        System.out.println("After deleting head:");


        list.traverseForward();


        list.deleteTail();


        System.out.println("After deleting tail:");


        list.traverseForward();


    }


}

通过以上的实现示例，我们可以更好地理解双向链表的结构和操作。双向链表的实现虽然相对复杂，但在某些应用场景中具有不可替代的优势。理解并掌握双向链表的实现，对于深入学习数据结构和算法具有重要意义。

相关问答FAQs：

什么是Java双向链表？

Java双向链表是一种数据结构，它由一系列节点组成，每个节点都包含了指向前一个节点和后一个节点的引用。这样的设计使得在链表中的任意节点都可以从前向后或从后向前遍历。

如何理解Java双向链表的操作？

Java双向链表的操作包括插入、删除和查找等。插入操作可以在链表的任意位置插入一个新节点，删除操作可以删除链表中的指定节点，而查找操作可以根据节点的值在链表中查找对应的节点。

Java双向链表与单向链表有何区别？

与单向链表相比，Java双向链表的一个显著特点是可以从任意节点开始向前或向后遍历。这使得在某些情况下，双向链表更加方便和高效。然而，由于每个节点需要额外的指向前一个节点的引用，双向链表相对于单向链表会占用更多的内存空间。

原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/391405

赞 (0)
Edit1Edit1
上一篇 2024年8月16日
下一篇 2024年8月16日
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部