Question

我的老师分配了一个程序，我要在其中创建一些随机数的链接列表。我将从列表中创建它，然后分配的第二部分是将其反转。实际报价是

编写一个称为reverseLinkedList（）的Java方法，该方法将生成一个从您在问题中创建的链接列表反向链接的列表 1.您的方法应接受一个链表作为输入，并返回另一个链表，该链表具有反向的节点引用订购。请不要反向打印原始列表。这个想法是操作节点引用，以便将节点保留在与最初创建时的顺序相同。

我到目前为止生成的代码看起来像

import java.util.*;

public class progassignment2 
{ 
    public static void main(String args[]) 
    { 
        List<Integer> myList = new ArrayList<Integer>();
        Random ran = new Random();
        int ranNum;
        for(int x = 0;x<5;x++)
        {
            ranNum =  ran.nextInt(500);
            myList.add(x,ranNum);
        }
        LinkedList<Integer> mylinklist = createLinkedList(myList);
        System.out.println(mylinklist);
        LinkedList<Integer> mylinklistrev = reverseLinkedList(mylinklist);
    } 

    public static LinkedList createLinkedList(List<Integer> integerList)
    {
        LinkedList<Integer> linkedlist = new LinkedList<Integer>();
        linkedlist.addAll(integerList);
        return linkedlist;
    }

    public static LinkedList reverseLinkedList(LinkedList inputList)
    {
        for(int y = 0;y < inputList.size();y++)
        {
            inputList.addLast(inputList.pollFirst());
        }
        return inputList;
    }
 }

但是，我认为我做的作业不正确，或者我理解他在问我什么，但不幸的是，我不会回答任何问题，只是引用“阅读作业”。任何帮助将不胜感激

Answer 1

那又怎么样：

public static LinkedList reverseLinkedList(List<Integer> inputList) {
    LinkedList<Integer> reversedLinkedlist = new LinkedList<Integer>(inputList);
    Collections.reverse(reversedLinkedlist);
    return reversedLinkedlist;
}

Answer 2

通常，对链表的练习不使用任何内置的Java集合（例如ArrayList，LinkedList等），而是用来构建自己的集合类型。

您的老师可能希望您构建一个非常基本的元素，然后该元素将成为您自己的集合类型的构建块：想象一个对象，您可以在其中存储值以及对列表中以下值的引用。在代码中：

class Node {
    private int value;
    private Node next;

    public Node(int value){
        this.value = value;
    }

    public int getValue(){
        return value;
    }

    public Node getNext(){
        return next;
    }

    public void setNext(Node next){
        this.next = next;
    }
}

每个元素都指向下一个元素，列表的末尾由最后一个节点的下一个元素null标记。

通过使用这样的对象，您将能够定义自己的链接列表，而无需使用Java提供的任何预定义集合。

您肯定已经听说过stack数据结构：通过读取链接列表中的所有元素并将它们放入堆栈中，一旦列表结束，您将在其中获取元素堆栈；按照从堆栈中拉出的元素的顺序创建链接列表，将解决您反转链接列表的问题。

Answer 3

这个想法是操纵节点引用，以便节点按照与最初创建时相同的顺序进行保存。

您应该创建自己的LinkedList。不允许使用通用的反转方式，例如使用递归，堆栈，修改或任何collections接口方法。

这是link包括LinkedList的反转方式和解决方案：

class LinkedList {
    Node head; // head of list
    /* Linked list Node */

    class Node {
        int data;
        Node next;

        Node(int d) {
            data = d;
            next = null;
        }
    }

    /* Function to print reverse of linked list */
    void printReverse(Node head) {
        if (head == null)
            return;
        // print list of head node
        printReverse(head.next);

        // After everything else is printed
        System.out.print(head.data + " ");
    }

    /* Inserts a new Node at front of the list. */
    public void push(int new_data) {
        Node new_node = new Node(new_data);

        new_node.next = head;

        head = new_node;
    }

    public static void main(String args[]) {
        LinkedList llist = new LinkedList();
        llist.push(4);
        llist.push(3);
        llist.push(2);
        llist.push(1);

        llist.printReverse(llist.head);
    }
}

反向链接列表，同时保留原始节点

3 个答案: