LinkedList存储节点的LinkedList

Question

我编写了一个LinkedList类，该类接受存储Integers Nodes 。

我已经然后，创建一个LinkedList stack = new LinkedList()并增加了Node s到它，如果数据Node s为小于所述的数据Node s表示已经在此存在stack 。

如果没有，我想把这个老stack到一个新LinkedList称为LinkedList pilesOfStacks ，并创建一个newStack称为LinkedList newStack = new LinkedList()并添加较大的Node进入这个newStack这也将进入LinkedList pilesOfStacks 。

我的问题是； 因为我已经创造了我LinkedList类接受Node S，我怎么做一个新LinkedList接受LinkedList这帮的Nodes ，基本上是建立不同桩LinkedList在A S LinkedList ？

这是我到目前为止的内容：

public void sort(LinkedList listOfInts)
{

  LinkedList<LinkedList> piles = new LinkedList<LinkedList>();

  LinkedList stack = new LinkedList();

  for(int i = 0; i < listOfInts.getSize(); i++)
  {
    Node x = listOfInts.pop();
    for(int j = 0; j < piles.getSize(); j++)
    {
      Node y = piles.peek(); //check first element of each pile

      if( ( ((Comparable)y.getData()).compareTo(x.getData()) ) <= 0)
      {
        stack.push(x);
        break;
      }
    }
    stack.push(x); //put value in stack
    piles.add(stack);
  }
}

编辑：如果我可以使用数组，我会创建一个双精度数组来影响Node[][] array = new Node[20][20]; 然后使用Node[i][0]搜索它，但是由于我只能使用LinkedList ，所以我想知道如何执行此操作？

Answer 1

好的，我只是试一试-使用Kami和Roman C提到的Java Collection Framework。 为避免混淆，我始终使用所涉及的接口/类的全限定名- 即使这会使代码看起来笨拙 。

我用的是java.util.LinkedList它实现了java.util.List还有java.util.Deque接口。 后者为您提供了将其视为堆栈的方法。

我从方法名称假设，您实际上要对堆栈中的节点进行排序。 为此，我不得不更改您原始示例的某些部分，因为它似乎不像您描述的那样运行。

我得到了您的示例的以下变体：

public void sort(java.util.Deque<Node> stackOfIntNodes) {
    java.util.List<java.util.Deque<Node>> piles =
            new java.util.LinkedList<java.util.Deque<Node>>();
    java.util.Deque<Node> currentStack = new java.util.LinkedList<Node>();
    inputLoop : while (!stackOfIntNodes.isEmpty()) {
        Node currentNode = stackOfIntNodes.pop();
        for (java.util.Deque<Node> singlePile : piles) {
            // check first element of each pile
            Node smallestNodeInSinglePile = singlePile.peek();
            Object valueOfSmallestNodeInSinglePile =
                    smallestNodeInSinglePile.getData();
            if ((((java.lang.Comparable) valueOfSmallestNodeInSinglePile)
                    .compareTo(currentNode.getData())) <= 0) {
                singlePile.push(currentNode);
                continue inputLoop;
            }
        }
        piles.add(currentStack);
        currentStack = new java.util.LinkedList<Node>();
        currentStack.push(currentNode); // put value in stack
    }
    piles.add(currentStack);
    java.util.Deque<Node> sortedStackOfIntNodes = new java.util.LinkedList<Node>();
    for (java.util.Deque<Node> singlePile : piles) {
        while (!singlePile.isEmpty()) {
            sortedStackOfIntNodes.push(singlePile.pop());
        }
    }
    // RESULT: you got all your Node elements in sorted order
}

但是，如果您确实使用java.util.LinkedList而不是自己的实现，则可以轻松使用此等效方法：

public void sort(java.util.Deque<Node> stackOfIntNodes) {
    java.util.LinkedList<Node> sortedListOfIntNodes =
            new java.util.LinkedList<Node>(stackOfIntNodes);
    java.util.Collections.sort(sortedListOfIntNodes,
            new Comparator<Node>() {
                @Override
                public int compare(Node nodeOne, Node nodeTwo) {
                    return ((java.lang.Comparable) nodeOne.getData())
                            .compareTo(nodeTwo.getData());
        }
    });
    // RESULT: you got all your Node elements in sorted order
}

根据您实际的Node类和/或自己的LinkedList，您可能必须在此处应用进一步的更改。