向量中的向量。。。JAVA

我有向量在向量中向量在向量中。但我不知道有多少（深度是多少）。如何更改最后一个向量的内容？

您必须使用。。。等等。。。递归

下面是一个链接列表示例

public Node<E> go_deep(Node<E> nodeRef) {
  // base case
  if(nodeRef.next == NULL)
    return nodeRef;

  return go_deep(nodeRef.next);
}

public节点深入（Node nodeRef）{
//基本情况
if（nodeRef.next==NULL）
返回nodeRef；
返回go__deep（nodeRef.next）；
}

然后，您可以通过以下方式获得“最后一个”节点：

publicstaticvoidmain（字符串[]args）{
节点lastNode=深入（头部）；
}

其中head是您的第一项（本例中为向量）。对于下一个和上一个，您可能也有不同的方法

这是我从头开始写的，你必须定义一个节点，如果你真的想让它工作的话，这只是基本的想法

如果向量（我的示例中的节点）未通过引用传递：

// if you have two-way references
public static void main(String[] args) {
  Node<E> lastNode = go_deep(head); //returns the last Node
  Node<E> prevNode = lastNode.prev; //returns the Node before
  Node<E> newNode = new Node<E>();      

  // update newNode with lastNode's values
  newNode.foo = lastNode.foo;
  newNode.bar = lastNode.bar + 7;

  prevNode.next = newNode; //newNode is inserted into the structure - lastNode dies :(
}

//如果您有双向引用
公共静态void main（字符串[]args）{
Node lastNode=go_deep（head）；//返回最后一个节点
Node prevNode=lastNode.prev；//返回之前的节点
Node newNode=新节点（）；
//使用lastNode的值更新newNode
newNode.foo=lastNode.foo；
newNode.bar=lastNode.bar+7；
prevNode.next=newNode；//将newNode插入结构-lastNode死：(
}

如果您有单向引用，我们将修改go_deep以返回节点及其父节点的数组：

public Node<E>[] go_deep(Node<E> nodeRef) {
  // base case
  // THERE ARE EDGE CASES THAT I'M IGNORING BECAUSE I'M NOT PROGRAMMING FOR YOU!
  if(nodeRef.next.next == NULL) {
    Node<E>[] arr = new Node<E>[2];
    arr[0] = nodeRef; // the "prev" node
    arr[1] = nodeRef.next; // the "last" node
    return arr;
  }

  return go_deep(nodeRef.next);
}

public Node[]深入（Node nodeRef）{
//基本情况
//我忽略了一些边缘案例，因为我不是为您编程！
if（nodeRef.next.next==NULL）{
节点[]arr=新节点[2]；
arr[0]=nodeRef；//上一个节点
arr[1]=nodeRef.next；//最后一个节点
返回arr；
}
返回go__deep（nodeRef.next）；
}

然后大体上：

public static void main(String[] args) {
  Node<E>[] nodes = go_deep(head); //returns the array of nodes
  Node<E> lastNode = nodes[1]; // returns the last Node
  Node<E> prevNode = nodes[0]; //returns the Node before
  Node<E> newNode = new Node<E>();      

  // update newNode with lastNode's values
  newNode.foo = lastNode.foo;
  newNode.bar = lastNode.bar + 7;

  prevNode.next = newNode; //newNode is inserted into the structure - lastNode dies :(
}

publicstaticvoidmain（字符串[]args）{
Node[]nodes=go_deep（head）；//返回节点数组
Node lastNode=nodes[1]；//返回最后一个节点
Node prevNode=nodes[0]；//返回前面的节点
Node newNode=新节点（）；
//使用lastNode的值更新newNode
newNode.foo=lastNode.foo；
newNode.bar=lastNode.bar+7；
prevNode.next=newNode；//将newNode插入结构-lastNode死：(
}

作为对赛斯的回应，以下是你如何使用stac.伪代码来完成这一任务，伪代码可能充满了拼写错误，只是为了描述这个想法

注意：存在与递归解决方案完全相同的问题，反向链接可能会导致无限循环。如果内存不是问题，请保留一个曾经遵循的所有LIN的列表（或者每个项目中都有一个标志，指示是否遵循），或者如果内存有问题，使用incr&skip 1的交叉循环。或者只设置要遍历的深度的最大lomit

// breadth first search to find deepest element FIND_DEEPEST: GIVEN tree; // vector of vectors DECLARE current, previous // stacks for the current depth and one level up DECLARW node, children, child // temp vars current = COPY( tree); WHILE current != NIL previous = current; current = nil; WHILE previous IS NOT empty node = POP(previous); APPEND CHILDREN(node) TO current; // CHILDREN just pops all elements of node // APPEND operates on lists, like in Perl //广度优先搜索以找到最深的元素 找到你最深的地方： 给定树；//向量的向量 声明当前深度和一级以上的当前、先前//堆栈 DECLARW节点，子节点，子节点//临时变量 当前=复制（树）； 当前时！=零 先前=当前； 电流=零； 而“上一个”不是空的 node=POP（上一个）； 将子节点追加到当前；//子节点仅弹出节点的所有元素 //APPEND对列表进行操作，就像在Perl中一样

---

OP不必使用递归。如果他/她只是在寻找最深的向量，他/她可以使用while循环和堆栈。递归可能更容易，但说它是唯一的方法是错误的。但据我所知，在这种情况下，当你在main中更改lastNode的内容时，最深向量的内容不会更改。我说得对吗？@atk:我对这类问题的标准答案是“使用堆栈”。您可以在隐式（调用堆栈，带有递归）或显式之间进行选择。它比“递归是唯一的方法”更正确，并且它包括递归选项。@atk-您完全不正确。递归是必需的，除非它是单向链接。（如果一个向量有很多子元素，比如文件系统结构或二叉树），请写一个while循环，从文件系统的根开始，给我一个每个文件夹和文件的列表。如果你能…@Yanh Huan-不…就我所记得的，向量是通过引用传递的（比如数组）.如果你用一种方法修改它，你就改变了它。但是，如果我的答案不是这样的话，我会尝试更新我的答案-给我一分钟时间想想。。。 // breadth first search to find deepest element FIND_DEEPEST: GIVEN tree; // vector of vectors DECLARE current, previous // stacks for the current depth and one level up DECLARW node, children, child // temp vars current = COPY( tree); WHILE current != NIL previous = current; current = nil; WHILE previous IS NOT empty node = POP(previous); APPEND CHILDREN(node) TO current; // CHILDREN just pops all elements of node // APPEND operates on lists, like in Perl