Question

任何人都知道如何以相反的顺序打印单链表（一次通过固定且独立于元素RAM的数量）。

Answer 1

我的回答。根据您的规格，没有答案可以解决这个问题。它不能是多遍的，它不能递归（我认为它被认为是单一的），它必须是恒定的记忆......

我不认为你会发现一个解决方案，那些说你可以做到的人显然对这个问题有某种形式的技巧方面。他们显然没有使用该社区正在使用的同一组定义。

Answer 2

我认为你可以在O（n）时间和O（1）空间中做到这一点，但从技术上讲，它不是“一次通过”。

反转链表：O（n）
print：O（n）
将链接列表反转：O（n）

Answer 3

此选项假设您知道计数（如果不是已经消失的那一个），或者如果必须使用一次通过，则失败，然后将计数设置为某个合理的大的最大上限值。

long count = 10000; // set this to whatever the count is, or calcualte it
string filename = @"c:\foo.out";
using (StreamWriter writer = new StreamWriter(filename))
{
    int index = 0;
    long maxLength = 12; // set this to the max length of an item + 2 (for /r/n)
    while(values.Next())
    {
        writer.BaseStream.Seek(maxLength * (count - index - 1), SeekOrigin.Begin);
        writer.WriteLine(values[index].ToString().PadLeft(maxLength));
        writer.Flush();
        index++;
    }
}

输出将在c:\foo.out文件中，用空格填充。由于问题没有说明您需要输出的位置，或者输出应该采用何种格式（例如事先不包括空白行）。鉴于它是一个链表，长度可能非常大（>int.MaxValue），因此将输出写入文件是一种非常合理的传输格式。

此答案符合O(n)写入性能（实际上一次传递），同时也不使用额外的内存，而输出流总是必须 em>是O(n)，因为你还能在屏幕上看到它们的其他方式......

对这个答案的回答是你不能seek在输出流中倒退，然后只打印一个\r返回字符并向后搜索，没有回复面试官询问如果确定或满足不可能的要求是工作描述的一部分。

Answer 4

String s ="";
for(each element el in list)
     s=el.data+", "+s;
 println(s);

这是一次通过。

Answer 5

这是java.util.LinkedList的解决方案由于您删除元素并将其添加到同一列表，因此内存保持不变。我认为合理地假设单链表的任何体面实现都会跟踪它的大小，头尾。

import java.util.Arrays;
import java.util.LinkedList;

class PrintReverse {
    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4};
        LinkedList<Integer> list = new LinkedList<Integer>(Arrays.asList(array));
        System.out.println(list);
        printListBackward(list);
    }

    public static void printListBackward(LinkedList<Integer> list) {
        int size = list.size();

        for (int i = 0; i < size; i++) {
            Integer n = list.removeLast();
            list.push(n);
            System.out.println(n.toString());
        }
        System.out.println(list);

    }
}

产生以下输出......

[1, 2, 3, 4]
4
3
2
1
[1, 2, 3, 4]

您怎么看？

Answer 6

嗯，你没有说它必须是高效的。（另外，可能没有一个更有效的常量内存实现。）另外，正如评论者所指出的那样，只有在length(list) == 1时这是一次通过。

void printReversedLinkedList(listptr root) {
    listptr lastPrinted = null;
    while (lastPrinted != root) {
        listptr ptr = root;  // start from the beginning of the list
        // follow until next is EoL or already printed
        while (ptr->next != null && ptr->next != lastPrinted)
            ptr = ptr->next;
        // print current node & update last printed
        printf("%s", ptr->data);
        lastPrinted = ptr;
    }

恒定内存，效率为O（n ^ 2）。

Answer 7

void printList(listItem node) {
    if (node.next != null) {
        printList(node.next);
    }

    echoOrSystemOutPrintlnOrPrintfOrWhatever(node.data);
}

printList(rootNode);

Answer 8

导入数组，以相反的顺序打印数组。

Answer 9

浏览单链表并将每个项目推入堆栈。弹出堆栈直到它为空，同时打印出弹出的每个元素。

node  = head of node list
stack = new Stack()

while ( node is not NULL )
{
    stack.push( node.data )
    node = node.next
}

while ( !stack.empty() )
{
    print( stack.pop() )
}

Answer 10

我真的很想知道单个链接列表是如何反向移动的。

反向打印单链表

10 个答案: