title: Rotate a singly linked list in Java
body: <p>My functions:</p>
  
  <pre><code>import java.util.Collection;
  import java.util.Collections;
  
  
  public class LinkedList {
      private Node head;
      private int listCount;
  
      // konstruktor na povrzanata lista
      public LinkedList()
      {
          // ova e prazna lista, pa zatoa 'head' pokazuva kon nov jazok bez elementi (null)
          head = new Node(null);
          listCount = 0;
      }
  
      // dodavame element (data) na krajot od listata
      public void add(Object data)
      {
          Node temp = new Node(data);
          Node current = head;
          head.setData(temp.getData());
  
          // pocnuvajki od 'head' (pocetniot element) pominuvame niz site lemenenti
          while(current.getNext() != null)
          {
              current = current.getNext();
          }
  
          current.setNext(temp);
  
          // go zgolemuvame brojot na elementi vo listata
          listCount++;
      }
  
      // dodavame element (data) na posebno opredelena pozicija (index)
      public void add(Object data, int index)
      {
          Node temp = new Node(data);
          Node current = head;
          head.setData(temp.getData());
  
          // odime do baraniot index, ili do posledniot element od listata (do koj stigneme prvo)
          for (int i = 1; i &lt; index &amp;&amp; current.getNext() != null; i++)
          {
              current = current.getNext();
          }
  
          // go postavuvame sledniot element na novata jazla 
          // da pokazuva kon sledniot element na ovaa jazla
          temp.setNext(current.getNext());
  
          // a sega go postavuvame sledniot element na ovaa jazla
          // da pokazuva kon novata jazla
          current.setNext(temp);
  
          // go nakacuvame vkupniot broj na elementi vo listata
          listCount++;
      }
  
      // vraka element na opredelena pozicija vo listata
      public Object get(int index)
      {
          if(index &lt;= 0)
          {
              return null;
          }
  
          Node current = head.getNext();
  
          for(int i = 1; i &lt; index; i++)
          {
              if(current.getNext() == null)
              {
                  return null;
              }
  
              current = current.getNext();
          }
  
          return current.getData();
      }
  
      // go vrakame brojot na elementi vo listata
      public int size()
      {
          return listCount;
      }
  
      // go brisime elementot na opredelenata pozicija vo listata
      public boolean remove(int index)
      {
          if(index &lt; 1 || index &gt; size())
          {
              return false;
          }
  
          Node current = head;
  
          for(int i = 1; i &lt; index; i++)
          {
              if(current.getNext() == null)
              {
                  return false;
              }
              current = current.getNext();
          }
  
          current.setNext(current.getNext().getNext());
  
          // go namaluvame brojot na elementi vo listata
          listCount--;
  
          return true;
      }
  
      public boolean contains(Object data)
      {
          Node temp = new Node(data);
          Node current = head;
  
          for(int i = 0; i &lt; size(); i++)
          {
              if(temp.getData().equals(current.getData()))
              {
                  return true;
              }
              else
              {
                  current = current.getNext();
              }
          }
          return false;
      }
  
      public Node inserAfter(Object data, Node n)
      {
          Node temp = new Node(data);
          Node current = n.getNext();
  
          temp.setNext(current);
          n.setNext(temp);
  
          return temp;
      }
  
      public void rotateLeft()
      {
          Node temp = head;
          //head = head.getNext();
  
          //Node tail = head.getNext();
  
          if (head != null) {                       //otherwise it is empty list
              //Node temp = head;
              if (head.getNext() != null) {           //otherwise it is single item list
                  head = head.getNext();
              }
          }
  
          Node tail;
          if (head.getNext() != null) {
              //more than 2 items in the list
              tail = head.getNext();
          } else {
              //only 2 items in the list
              tail = head;
          }
  
          while(tail.getNext() != null)
          {
              if (tail.getNext() != null) {
                  tail = tail.getNext();
              }
              //tail = tail.getNext();
          }
          tail.setNext(temp);
          temp.setNext(null);
      }
  
      public void rotateRight()
      {
          Node temp = null;
          Node current = head;
  
          while(current.getNext() != null)
          {
              temp = current;
              current = current.getNext();
          }
          current.setNext(head);
          head = current;
          temp.setNext(null);
      }
  
      public void reverse()
      {
          Node reversedPart = null;
          Node current = head;
  
          while(current != null)
          {
              Node next = current.next;
              current.next = reversedPart;
              reversedPart = current;
              current = next;
          }
          head = reversedPart;
      }
  
      public Node copyList(Node source)
      {
          Node copyHead = null;
          Node copyTail = null;
  
          Node temp = new Node(source);
          Node current = head.getNext();
  
          for(int i = 0; i &lt; size(); i++)
          {
              Node newNode = new Node(temp.getData());
              if(copyHead == null)
              {
                  copyHead = newNode;
                  copyTail = copyHead;
              }
              else
              {
                  copyTail.setNext(newNode);
                  copyTail = copyTail.getNext();
              }
          }
  
          return copyHead;
      }
  
      public Object setDataIndexOf(Object data, int index)
      {
          Node node = nodeAt(index);
  
          if(node == null)
          {
              return null;
          }
          else
          {
              Object old = node.getData();
              node.setData(data);
              return old;
          }
      }
  
      public Object dataAt(int index)
      {
          Node current = head.getNext();
  
          if(index &lt; 1 || index &gt; size())
          {
              return null;
          }
  
          for(int i = 0; i &lt; index; i ++)
          {
              if(i != index - 1)
              {
                  current = current.getNext();
              }
          }
  
          return current.getData();
      }
  
      public Node nodeAt(int index)
      {
          Node current = head.getNext();
  
          if(index &lt; 1 || index &gt; size())
          {
              return null;
          }
  
          for(int i = 0; i &lt; index; i++)
          {
              if(i != index - 1)
              {
                  current = current.getNext();
              }
          }
  
          return current;
      }
  
      public int indexOf(Object data)
      {
          Node temp = new Node(data);
          Node current = head.getNext();
  
          for(int i = 0; i &lt; size(); i++)
          {
              if(current.getData().equals(temp.getData()))
              {
                  return i;
              }
              current = current.getNext();
          }
  
          return -1;
      }
  
      public Object min()
      {
          Integer min = (Integer)head.getData();
          Node current = head;
  
          while(current.getNext() != null)
          {
              if((Integer)current.getData() &lt; min)
              {
                  min = (Integer)current.getData();
              }
              current = current.getNext();
          }
  
          return min;
      }
  
      public Object max()
      {
          Integer max = (Integer)head.getData();
          Node current = head;
  
          while(current.getNext() != null)
          {
              if((Integer)current.getData() &gt; max)
              {
                  max = (Integer)current.getData();
              }
              current = current.getNext();
          }
  
          return max;
      }
  
      public void removeSecondAppear(Object data)
      {
          Node temp = new Node(data);
          Node current = head;
          Node previous = null;
  
          boolean found = false;
  
          while(current != null)
          {                       
              if(current.getData().equals(temp.getData()) &amp;&amp; current.getData() != null)
              {
                  if(found == true)
                  {
                      previous.setNext(current.getNext());
                      break;
                  }
                  else if(found == false)
                  {
                      found = true;
                  }
  
              }
              else{
                  found = false;
              }
  
              previous = current;
              current = current.getNext();
          }
  
      }
  
      public String toString()
      {
          Node current = head.getNext();
          String output = "";
  
          while(current != null)
          {
              output += "[" + current.getData().toString() + "]";
              current = current.getNext();
          }
  
          return output;
      }
  }
  </code></pre>
  
  <p>My node:</p>
  
  <pre><code>public class Node {
      Node next;
  
      Object data;
  
      public Node(Object _data)
      {
          next = null;
          data = _data;
      }
  
      public Node(Object _data, Node _next)
      {
          next = _next;
          data = _data;
      }
  
      public Object getData()
      {
          return data;
      }
  
      public void setData(Object _data)
      {
          data = _data;
      }
  
      public Node getNext()
      {
          return next;
      }
  
      public void setNext(Node _next)
      {
          next = _next;
      }
  }
  </code></pre>
  
  <p>I'm trying to create a function to rotate a singly linked in list in Java. I have made two functions for left and right.</p>
  
  <p>My left function seems to work, but not fully. For example. If my list contains the elements: 1 2 3</p>
  
  <p>Then my rotateLeft will make the list into 2 3. The 1 will be gone. But it should come on the position of previous 3.</p>
  
  <p>As for the rotateRight, the function is not functioning properly for some reason, been trying a few hours and can't find the solution.</p>
  
  <pre><code>    LinkedList LL = new LinkedList();
  
      LL.add("1");
      LL.add("2");
      LL.add("3");
      LL.add("4");
      LL.add("4");
      LL.add("5");
      LL.rotateLeft();
  </code></pre>
  
  <p>2, 3, 4, 4, 5, null is the output. My add method is the following:</p>
  
  <pre><code>public void add(Object data)
  {
      Node temp = new Node(data);
      Node current = head;
  
      while(current.getNext() != null)
      {
          current = current.getNext();
      }
  
      current.setNext(temp);
  
      listCount++;
  }
  </code></pre>