Question

我在这里查看了关于双链表的大多数帖子，但仍然不清楚以下内容。

我正在用Java学习Goodrich和Tamassia的书。关于双重链接列表，如果我错了，请纠正我，它与单链表不同，节点可以插入任何地方，而不是在头部之后或尾部之后使用可用的next和prev节点，而在单链表，这个插入列表中的任何位置是不可能的？

如果想要在双向链表中插入节点，那么默认参数应该是待插入节点之后的节点还是待插入节点之前的节点？但如果是这样，那么我不明白如何在之前或之后传递节点。我们是否应该显示到目前为止插入的所有节点，并要求用户选择在插入新节点之前或之后的节点？我怀疑的是如何传递这个默认节点。因为我认为这也需要这些节点的next节点和prev节点。

例如，Head<->A<->B<->C<->D<->E<->tail

如果Z是在D之后插入的新节点，那么节点D应该如何通过呢？我对此感到困惑，尽管对大多数人来说似乎很简单。

但是pl确实解释了。

谢谢，桑杰

Answer 1

假设这样的Node类：

public class Node {
    public Node next = null;
    public Node previous = null;
    public Object value;
}

然后你可以定义：

public void insertBefore(Node node, Node insert)
{
    Node previousNode = node.previous;

    insert.next = node;
    insert.previous = previousNode;

    if(previousNode != null)
        previousNode.next = insert;

    node.previous = insert;
}

和

public void insertAfter(Node node, Node insert)
{
    Node nextNode = node.next;

    insert.previous = node;
    insert.next = nextNode;

    if(nextNode!= null)
        nextNode.previous = insert;

    node.next = insert;
}

希望有所帮助

Answer 2

它与单独链接不同列表，可以插入一个节点在任何地方，而不仅仅是在头或后尾巴使用后下两个 prev节点可用，而在单独链表，这个插入任何地方在列表中是不可能的？

这是错误的。您可以在单个链接列表的中间插入节点就好了。唯一的区别是双链表更容易导航，因为您可以从任何给定节点向前和向后移动它。

如果想在一个节点中插入一个节点双向链表，然后默认参数应该是节点在待插入节点或节点之后在待插入节点之前？

这完全取决于您使用列表的内容。链接列表由于其随机访问性能差而不是真正的通用数据结构。因此，它们通常仅用于迭代遍历列表的算法，并在它们执行时插入或删除节点。

但是如果是这样，那么我不明白如何在之前或之后传递节点。我们应该显示所有节点吗？直到现在插入并询问用户在或之前选择节点之后会有一些新节点插入

您正在以错误的方式接近此问题，尝试围绕某个数据结构编写应用程序。通常，您从应用程序的最终用户要求开始，然后确定最适合使用哪种数据结构来满足这些要求。用户永远不必理解链接列表等程序的低级内部。

Answer 3

您也可以插入单个链接列表。 A-> B变为A-> C-> B，您所要做的就是改变A的下一个节点参考并将C设置为B.
默认情况下，在所选节点之后插入更有意义。
您将D的下一个节点设置为Z，将E的前一个节点设置为Z，将Z的下一个节点设置为E，将Z的前一个节点设置为D.

我希望我能正确理解你的问题，但它们有点令人困惑。

Answer 4

使用JAVA的双链表实现。已实施的运营是：

在DLL中插入节点。
从DLL中删除第n个位置元素。
在DLL中查找元素的位置。
从DLL中检索所有节点。
从DLL中反向检索所有节点。

获取DLL的长度。

package com.config;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class DLL {

public static void main(String args[]) throws NumberFormatException, IOException{

    int choice = 0;
    Node temp = null;
    Node head = null;
    boolean flage = true;
    int nodeCounter = 0;

    BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
    do{
        Node node = new Node();
        System.out.println("Enter Node data");
        node.data = Integer.parseInt(read.readLine());
        if(flage){
            flage = false;
            head = node;
        }
        if(temp!=null){
            temp.next = node;
            node.prev = temp;
        }
        temp = node;
        nodeCounter++;
        System.out.println("Press 0 to quite for more node entry.");
        choice = Integer.parseInt(read.readLine());
    }while(choice != 0);

    temp.next = head;
    head.prev = temp;
    System.out.println("You have created "+nodeCounter+" nodes in doubly linked list");

    System.out.println("Retriving and Manipulation Operation perform : ");
    Node node = head;
    do{
        System.out.println("Press 1 for get all nodes from doubly linked list.");
        System.out.println("Press 2 for get all nodes in reverse from doubly linked list.");
        System.out.println("Press 3 for get length of doubly linked list.");
        System.out.println("Press 4 for remove nth node from doubly linked list.");
        System.out.println("Press 5 for find node in doubly linked list.");
        System.out.println("Press 0 for quite.");
        choice = Integer.parseInt(read.readLine());

        switch (choice) {
        case 1: Node.getAllNodes(node);
            break;
        case 2: Node.getAllNodesReverse(node);  
            break;

        case 3 : System.out.println("Length : "+Node.getDoublyLinkedListLength(node));
            break;
        case 4 : System.out.println("Enter Position to remove from DLL");
                choice = Integer.parseInt(read.readLine());     
                node = Node.removeNthNode(node, choice);    
                break;
        case 5 :System.out.println("Enter Node data to find in DLL");
                choice = Integer.parseInt(read.readLine());     
                choice = Node.findNode(node, choice);
                if(choice == 0){
                    System.out.println("Node Not Found in DLL");
                    choice = 1;
                }else
                    System.out.println("Node Position : "+choice);  
        break;
        default:
            break;
        }

    }while(choice != 0);


}


}

class Node{
int data = 0;
Node next = null;
Node prev = null;


public static void getAllNodes(Node head){
int nodeCounter = 0;
if(head!=null){
    Node tail = head.prev;
    while(head.next != tail.next ){
        nodeCounter++;
        System.out.println(nodeCounter+". Node : "+head.data);
        head = head.next;
    }
    nodeCounter++;
    System.out.println(nodeCounter+". Node : "+head.data);
}
}

public static int getDoublyLinkedListLength(Node head){
int nodeCounter = 0;
if(head!=null){
    Node tail = head.prev;
    while(head.next != tail.next ){
        nodeCounter++;
        head = head.next;
    }
    nodeCounter++;
}
return nodeCounter;
}

public static int findNode(Node head,int data){
int nodeCounter = 0;
boolean flage = false;
if(head!=null){
    Node tail = head.prev;
    while(head.next != tail.next ){
        nodeCounter++;
        if(head.data == data){
            flage = true;
            break;
        }
        head = head.next;
    }
}

return flage ? nodeCounter : 0;
}

public static void getAllNodesReverse(Node head){
if(head!= null){
    int nodeCounter = 0;
    Node tail = head.prev;
    while(tail.prev!= head.prev){
        nodeCounter++;
        System.out.println(nodeCounter+". Node : "+tail.data);
        tail = tail.prev;
    }
    nodeCounter++;
    System.out.println(nodeCounter+". Node : "+tail.data);
}
}

public static Node removeNthNode(Node head, int removePosition){
int length = getDoublyLinkedListLength(head);
if(head!=null){
    int counter = 1;

    if(length >2){
        if(length+1 > removePosition && removePosition > 0){
            while(counter != removePosition){
                counter++;
                head = head.next;
            }
            head.prev.next = head.next;
            head.next.prev = head.prev;
        }else{
            System.out.println("Given Position not exist");
        }
    }else{
        System.out.println("At least two nodes must be in doubly linked list.");
    }
}
if(removePosition==1 || removePosition==length)
    return head.next;
else
    return head;
}
}

双重链接列表实施

4 个答案: