LinkedList存储节点的LinkedList

Question

I have written a LinkedList class that accepts Nodes that stores Integers .

I have then created a LinkedList stack = new LinkedList() , and have added Node s to it if the data of the Node s are less than the data of the Node s that already exist in this stack .

If not, I want to put this old stack into a new LinkedList called LinkedList pilesOfStacks , and create a newStack called LinkedList newStack = new LinkedList() , and add the larger Node into this newStack which will also go into the LinkedList pilesOfStacks .

My question is; since I already created my LinkedList class to accept Node s, how do I make it a new LinkedList to accept LinkedList s of these Nodes , essentially creating different piles of LinkedList s in a LinkedList ?

This is what I have so far:

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);
  }
}

Edit: If I could use an array, I would create a double array to something of the effect Node[][] array = new Node[20][20]; and then search it with Node[i][0] , but since I can only use LinkedList , I'm wondering how to do this?

Answer 1

Okay, I just gave it a shot - using the Java Collection Framework as mentioned by Kami and Roman C . To avoid confusion I always used the full qualified name of the interfaces/classes involved - even though that makes the code look big and ugly .

I used the java.util.LinkedList which implements the java.util.List as well as the java.util.Deque interface. The latter one gives you the methods to treat it as a stack.

I assume from the method name, that you actually want to sort the Nodes in your stack. For that I had to change some parts of your original example, since it seemed not to behave like you described.

I ended up with the following variation of your example:

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
}

But if you were really using the java.util.LinkedList instead of your own implementation, you could easily use this equivalent method:

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
}

Depending on your actual Node class and/or own LinkedList, you might have to apply further changes here.