fork download 
  1.     class DoublyLinkedStringList {
  2.  
  3.     private Node head, tail;
  4.     boolean forward;
  5.  
  6.     /**
  7.      * Diese Klasse repraesentiert einen Knoten in der Doubly Linked List der
  8.      * Klasse
  9.      * <code>DoublyLinkedStringList</code>
  10.      *
  11.      */
  12.     private class Node {
  13.         private String content;
  14.         private Node next;
  15.         private Node prev;
  16.  
  17.         public Node(String content) {
  18.             this.content = content;
  19.         }
  20.  
  21.         public Node(String content, Node next) {
  22.             this.content = content;
  23.             this.next = next;
  24.         }
  25.  
  26.         public Node getNext() { 
  27.             return (forward) ? next : prev;   //EDITED
  28.         }
  29.  
  30.         public void setNext(Node next) {
  31.             if(forward) { this.next = next; } //EDITED
  32.             else        { this.prev = next; } //EDITED
  33.         }
  34.  
  35.         public Node getPrev() {
  36.             return (forward) ? prev : next;   //EDITED
  37.         }
  38.  
  39.         public void setPrev(Node prev) {
  40.             if(forward) { this.prev = prev; } //EDITED
  41.             else        { this.next = prev; } //EDITED
  42.         }
  43.     }
  44.  
  45.     public DoublyLinkedStringList() {
  46.         this.head = null;
  47.         this.tail = null;
  48.     }
  49.  
  50.     public Node prepend(String info) {
  51.         Node newNode = new Node(info);
  52.         newNode.setPrev(null);
  53.         newNode.setNext(getHead());
  54.         if(newNode.getNext()!=null) { 
  55.           newNode.getNext().setPrev(newNode); //EDITED
  56.         } 
  57.         if(forward) { head = newNode; }       //EDITED
  58.         else        { tail = newNode; }       //EDITED
  59.         if(getTail() == null) {               //EDITED
  60.           if(forward) { tail = newNode; }     //EDITED
  61.           else        { head = newNode; }     //EDITED
  62.         }
  63.         return head;
  64.     }
  65.  
  66.     public Node delete(int index) {
  67.         Node currNode = getHead();
  68.         int count = 0;
  69.  
  70.         if (index == 0) {
  71.             if(forward) { head = head.next; } //EDITED
  72.             else        { tail = tail.prev; } //EDITED
  73.             return head;
  74.         }
  75.  
  76.         while (currNode != null) {
  77.             if (count + 1 == index) {
  78.                 currNode.next.prev = currNode.prev; 
  79.                 currNode.prev.next = currNode.next; //EDITED
  80.                 break;
  81.             }
  82.             currNode = currNode.getNext(); //EDITED
  83.             count++;
  84.         }
  85.         return currNode;
  86.     }
  87.  
  88.     private Node next() {
  89.         Node currNode = head;
  90.  
  91.         if (forward) {
  92.             return currNode.getNext();
  93.         } else {
  94.             return currNode.getPrev();
  95.         }
  96.     }
  97.  
  98.     public Node getHead() { return (forward) ? head : tail; } //EDITED
  99.     public Node getTail() { return (forward) ? tail : head; } //EDITED
  100.  
  101.     public DoublyLinkedStringList reverse() { forward = !forward; return this; }
  102.  
  103.     @Override
  104.     public String toString() {
  105.         StringBuilder sb = new StringBuilder();
  106.         //EDITED LOOP STRUCTURE
  107.         for (Node currNode = getHead(); currNode != null; currNode = currNode.getNext()) {
  108.             sb.append(currNode.content);
  109.             if (currNode.getNext() != null) {
  110.                 sb.append(", ");
  111.             }
  112.         }
  113.         return sb.toString();
  114.     }
  115.  
  116.     public static void main(String argv[]) {
  117.         DoublyLinkedStringList list = new DoublyLinkedStringList();
  118.         list.prepend("6");
  119.         list.prepend("5");
  120.         list.prepend("4");
  121.         list.prepend("3");
  122.         list.prepend("2");
  123.         list.prepend("1");
  124.         list.prepend("0");
  125.         list.delete(3);
  126.         System.out.println(list);
  127.         System.out.println(list.reverse());
  128.     }
  129.     }
Success #stdin #stdout 0.02s 245632KB
comments (?)
stdin 
Standard input is empty
stdout 
0, 1, 3, 4, 5, 6
6, 5, 4, 3, 1, 0
https://ideone.com/W2hMD8
language:
Java (HotSpot 12)
created:
11 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!