implemented

.idea/compiler.xml

@@ -7,10 +7,12 @@
         <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
         <outputRelativeToContentRoot value="true" />
         <module name="CR-MesoLabs-Collections-SinglyLinkedList" />
+        <module name="singlylinkedlist" />
       </profile>
     </annotationProcessing>
     <bytecodeTargetLevel target="1.8">
       <module name="CR-MesoLabs-Collections-SinglyLinkedList" target="1.5" />
+      <module name="singlylinkedlist" target="1.5" />
     </bytecodeTargetLevel>
   </component>
 </project>

.idea/libraries/Maven__junit_junit_4_12.xml

@@ -0,0 +1,13 @@
+<component name="libraryTable">
+  <library name="Maven: junit:junit:4.12">
+    <CLASSES>
+      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.12/junit-4.12.jar!/" />
+    </CLASSES>
+    <JAVADOC>
+      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.12/junit-4.12-javadoc.jar!/" />
+    </JAVADOC>
+    <SOURCES>
+      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.12/junit-4.12-sources.jar!/" />
+    </SOURCES>
+  </library>
+</component>

.idea/libraries/Maven__org_hamcrest_hamcrest_core_1_3.xml

@@ -0,0 +1,13 @@
+<component name="libraryTable">
+  <library name="Maven: org.hamcrest:hamcrest-core:1.3">
+    <CLASSES>
+      <root url="jar://$MAVEN_REPOSITORY$/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar!/" />
+    </CLASSES>
+    <JAVADOC>
+      <root url="jar://$MAVEN_REPOSITORY$/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3-javadoc.jar!/" />
+    </JAVADOC>
+    <SOURCES>
+      <root url="jar://$MAVEN_REPOSITORY$/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3-sources.jar!/" />
+    </SOURCES>
+  </library>
+</component>

.idea/modules.xml

@@ -3,6 +3,7 @@
   <component name="ProjectModuleManager">
     <modules>
       <module fileurl="file://$PROJECT_DIR$/CR-MesoLabs-Collections-SinglyLinkedList.iml" filepath="$PROJECT_DIR$/CR-MesoLabs-Collections-SinglyLinkedList.iml" />
+      <module fileurl="file://$PROJECT_DIR$/singlylinkedlist.iml" filepath="$PROJECT_DIR$/singlylinkedlist.iml" />
     </modules>
   </component>
 </project>

pom.xml

@@ -7,6 +7,14 @@
     <groupId>com.zipcodewilmington</groupId>
     <artifactId>singlylinkedlist</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>RELEASE</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 
 
 </project>

src/main/java/com/zipcodewilmington/singlylinkedlist/DataItems.java

@@ -0,0 +1,26 @@
+package com.zipcodewilmington.singlylinkedlist;
+
+public class DataItems{
+
+    private int key;
+    private String value;
+
+    public DataItems(int _key, String _value){
+        this.key=_key;
+        this.value=_value;
+    }
+
+    public int getKey() {
+        return key;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public String toString() {
+        return "("+getKey()+","+getValue()+")";
+    }
+
+}
+

src/main/java/com/zipcodewilmington/singlylinkedlist/HeadNode.java

@@ -0,0 +1,17 @@
+package com.zipcodewilmington.singlylinkedlist;
+
+public class HeadNode{
+
+// immutable class representing head node of linked list
+
+    Node nextNode;
+
+    public void setNextNode(Node _nextNode) {
+        nextNode=_nextNode;
+    }
+
+    public Node getNextNode() {
+        return nextNode;
+    }
+
+}

src/main/java/com/zipcodewilmington/singlylinkedlist/MainApplication.java

@@ -1,7 +1,23 @@
 package com.zipcodewilmington.singlylinkedlist;
 
+import java.util.LinkedList;
+
 /**
  * Created by leon on 1/10/18.
  */
 public class MainApplication {
-}
+
+    /*public  static void main () {
+       SinglyLinkedList  sl1=new SinglyLinkedList();
+        sl1.addNode( new DataItems(1,"hello") );
+        sl1.addNode(new DataItems(2,"John") );
+        sl1.addNode(new DataItems(3,"Smith") ) ;
+        sl1.addNode(new DataItems(4,"jose") ) ;
+        sl1.displayList() ;
+
+
+    }*/
+
+
+
+}

src/main/java/com/zipcodewilmington/singlylinkedlist/Node.java

@@ -0,0 +1,26 @@
+package com.zipcodewilmington.singlylinkedlist;
+
+public class Node {
+    private DataItems dataItems;
+    private Node nextNode;
+
+    public void setNextNode(Node _nextNode){
+        this.nextNode=_nextNode;
+    }
+
+    public Node getNextNode(){
+        return nextNode;
+    }
+
+    public DataItems getDataItems(){
+        return dataItems;
+    }
+
+    public void setDataItems(DataItems _dataItems){
+        this.dataItems=_dataItems;
+    }
+
+
+
+
+}

src/main/java/com/zipcodewilmington/singlylinkedlist/SinglyLinkedList.java

@@ -4,4 +4,178 @@ package com.zipcodewilmington.singlylinkedlist;
  * Created by leon on 1/10/18.
  */
 public class SinglyLinkedList {
+
+    HeadNode head;
+    public SinglyLinkedList(){
+        head = new HeadNode();
+
+    }
+
+    // insert node at the beginning of the list
+    public void addNode(DataItems _data){
+        Node newNode = new Node();
+        newNode.setDataItems(_data);
+        Node nextNode = head.getNextNode();
+        head.setNextNode(newNode);
+        newNode.setNextNode(nextNode);
+    }
+
+    public void addtoAnotherHeadNode(DataItems _data, HeadNode hd){
+        Node newNode = new Node();
+        newNode.setDataItems(_data);
+        Node nextNode = hd.getNextNode();
+        hd.setNextNode(newNode);
+        newNode.setNextNode(nextNode);
+    }
+    // insert node at the end of the list
+ /*   public void addNodeAttheEnd(DataItems _data){
+        Node newNode = new Node();
+        newNode.setDataItems(_data);
+        Node nodes = head.getNextNode();
+        HeadNode current;
+        //First Node
+        if (nodes == null) {
+            head.setNextNode(newNode);
+        }
+        else {
+            current=head;
+            while (current.getNextNode().getNextNode() != null) {
+
+               current=current.
+                //System.out.println("Node "+i+" : "+data.toString());
+                nodes = nodes.getNextNode();
+            }
+            head.setNextNode(newNode);
+        }
+    }*/
+    //returns a new linked list containing the same values
+
+    public HeadNode copyOfLinkedlist(){
+        HeadNode hd = new HeadNode();
+        Node nodes = head.getNextNode();
+        int i=0;
+        while(nodes!=null) {
+            DataItems data = nodes.getDataItems();
+            addtoAnotherHeadNode (data, hd);
+            nodes = nodes.getNextNode();
+
+        }
+
+        return hd;
+    }
+
+    // delete node at the beginning of the list
+    public void removeNode(){
+        Node toBeDeletedNode = head.getNextNode();
+        if(toBeDeletedNode!=null) {
+            Node nextNode = toBeDeletedNode.getNextNode();
+            head.setNextNode(nextNode);
+            toBeDeletedNode.setNextNode(null);
+        } else {
+            System.out.println("No nodes to be deleted");
+        }
+
+    }
+
+    // display all nodes data
+    public void displayList(){
+        Node nodes = head.getNextNode();
+        int i=0;
+        while(nodes!=null) {
+            DataItems data = nodes.getDataItems();
+            System.out.println("Node "+i+" : "+data.toString());
+            nodes = nodes.getNextNode();
+            i++;
+
+        }
+    }
+
+    // reverse order of linked list
+    public void reverseLinkedList(){
+        int sizeOfList = size();
+        Node lastNode = getNodeAtIndex(sizeOfList-1);
+        Node snode, tnode;
+        for(int i=sizeOfList-2;i>=0;i--){
+            snode = getNodeAtIndex(i);
+            tnode = snode.getNextNode();
+            tnode.setNextNode(snode);
+        }
+        getNodeAtIndex(0).setNextNode(null);
+        head.setNextNode(lastNode);
+    }
+
+
+    public int findKey(int _key){
+        int i=0;
+        DataItems data = dataAtNodeIndex(i);
+        while(data!=null){
+            if(data.getKey()== _key){
+                System.out.println("Node at index : "+i+" has data item : "+data.toString());
+                break;
+            }
+            i++;
+            data = dataAtNodeIndex(i);
+
+        }
+        if(i>0) {
+            return i;
+        }else{
+
+            return -1;
+        }
+
+
+    }
+
+    public boolean contains(int _key){
+        int i=0;
+        DataItems data = dataAtNodeIndex(i);
+        boolean flag=false;
+        while(data!=null){
+            if(data.getKey()== _key){
+               flag=true;
+            }
+            i++;
+            data = dataAtNodeIndex(i);
+        }
+        return flag;
+    }
+    // return the size of linked list
+    public int size() {
+        int count=0;
+        Node nodes = getNodeAtIndex(count);
+        while(nodes!=null) {
+            nodes = getNodeAtIndex(++count);
+        }
+        return count;
+    }
+
+
+    // return data item at particular node
+    public DataItems dataAtNodeIndex(int _index){
+        Node nodes = getNodeAtIndex(_index);
+        if(nodes!=null) {
+            return nodes.getDataItems();
+        } else {
+            return null;
+        }
+    }
+
+    // return node at particular index
+    private Node getNodeAtIndex(int _index){
+        if(_index<0) {
+            return null;
+        } else {
+            Node nodes = head.getNextNode();
+            int i=0;
+            while(i<_index && nodes!=null) {
+                nodes = nodes.getNextNode();
+                i++;
+            }
+            return nodes;
+        }
+    }
+
+
+
 }

src/test/java/com/zipcodewilmington/singlylinkedlist/SinglyLinkedListTest.java

@@ -1,7 +1,132 @@
 package com.zipcodewilmington.singlylinkedlist;
 
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.LinkedList;
+
 /**
  * Created by leon on 1/10/18.
  */
 public class SinglyLinkedListTest {
-}
+
+    @Test
+    public void testInsert() {
+        SinglyLinkedList sl = new SinglyLinkedList();
+
+        // Create to the list
+        DataItems data = new DataItems(1, "Data_" + 1);
+        sl.addNode(data);
+        data = new DataItems(2, "Data_" + 2);
+        sl.addNode(data);
+        data = new DataItems(4, "Data_" + 4);
+        sl.addNode(data);
+
+        sl.displayList();
+        DataItems actualData = sl.dataAtNodeIndex(0);
+        System.out.println("");
+
+        Assert.assertEquals(data, actualData);
+    }
+
+    @Test
+    public void testdelete() {
+        SinglyLinkedList sl = new SinglyLinkedList();
+        DataItems data = new DataItems(1, "Data_" + 1);
+        sl.addNode(data);
+        data = new DataItems(2, "Data_" + 2);
+        sl.addNode(data);
+        System.out.println("before deleting the node");
+        sl.displayList();
+        sl.removeNode();
+        System.out.println("after deleting the node");
+        sl.displayList();
+
+    }
+
+
+    @Test
+    public void testdisplay() {
+        SinglyLinkedList sl = new SinglyLinkedList();
+        DataItems data = new DataItems(3, "Data_" + 1);
+        sl.addNode(data);
+        data = new DataItems(2, "Data_" + 1);
+        sl.addNode(data);
+        sl.displayList();
+
+    }
+
+    @Test
+    public void testreversedLinkedlist() {
+        SinglyLinkedList sl = new SinglyLinkedList();
+        DataItems data = new DataItems(1, "Data_" + 1);
+        sl.addNode(data);
+        data = new DataItems(2, "Data_" + 2);
+        sl.addNode(data);
+        sl.reverseLinkedList();
+        sl.displayList();
+
+    }
+
+    @Test
+    public void testgetSize() {
+        SinglyLinkedList sl = new SinglyLinkedList();
+        DataItems data = new DataItems(1, "Data_" + 1);
+        sl.addNode(data);
+        data = new DataItems(2, "Data_" + 2);
+        sl.addNode(data);
+        int expected = 2;
+        int actual = sl.size();
+        Assert.assertEquals(expected, actual);
+        //sl.displayList() ;
+    }
+
+    @Test
+    public void testdatanodeindexy() {
+        SinglyLinkedList sl = new SinglyLinkedList();
+        DataItems data = new DataItems(1, "Data_" + 1);
+        sl.addNode(data);
+        data = new DataItems(2, "Data_" + 2);
+        sl.addNode(data);
+        sl.dataAtNodeIndex(1);
+
+    }
+
+    @Test
+    public void testcontains() {
+        SinglyLinkedList sl = new SinglyLinkedList();
+        DataItems data = new DataItems(1, "Data_" + 1);
+        sl.addNode(data);
+        data = new DataItems(2, "Data_" + 2);
+        sl.addNode(data);
+        sl.contains(2);
+    }
+
+    @Test
+    public void testCopyOfLinkedList() {
+        SinglyLinkedList sl = new SinglyLinkedList();
+
+        // Create to the list
+        DataItems data = new DataItems(1, "Data_" + 1);
+        sl.addNode(data);
+        data = new DataItems(2, "Data_" + 2);
+        sl.addNode(data);
+        data = new DataItems(4, "Data_" + 4);
+        sl.addNode(data);
+
+        sl.displayList();
+        System.out.println("copy oif a list") ;
+        HeadNode hd =  sl.copyOfLinkedlist();
+
+        Node nodes = hd.getNextNode();
+        int i=0;
+        while(nodes!=null) {
+             data = nodes.getDataItems();
+
+            System.out.println("Node "+i+" : "+data.toString());
+            nodes = nodes.getNextNode();
+
+            i++;
+        }
+    }
+}