Skip to main content

Data Structures using Java

package com.test.count;

/**
 * 
 * @author Kiran
 *
 */
public class LinkedList {

Node headNode;
/**
*  This method appends the Node at the end of the List
*  
* @param data
*/
public void appendNode(int data) {
Node currentNode = headNode;
if(currentNode == null) {
Node newNode = new Node(data);
headNode = newNode;
return;
}
while(currentNode.getNextNode()!=null) {
currentNode = currentNode.getNextNode();
}
currentNode.setNextNode(new Node(data));
}

/**
* This method prints all the Nodes/Values of the 
* LinkedList
* 
*/
public void printNodes() {
Node currentNode = headNode;
if(currentNode==null) {
System.out.println(" The Node is Null");
return;
} else {
System.out.print("   "+ currentNode.getData());
while(currentNode.getNextNode()!=null) {
currentNode = currentNode.getNextNode();
System.out.print("=>  "+ currentNode.getData());
}
}
}
/**
*  This method deletes the Node with the given Data
*  
* @param data
*/
public void deleteNode(int data) {
Node currentNode = headNode;
Node previousNode = headNode;
if(currentNode.getData()==data) {
headNode = currentNode.getNextNode(); 
return;
} else {
while(currentNode.getNextNode()!=null) {
previousNode = currentNode;
currentNode = currentNode.getNextNode();
if(currentNode.getData()==data) {
previousNode.setNextNode(currentNode.getNextNode());
}
}
//if the last element is the element we are looking for 
if(currentNode.getData()==data) {
currentNode = null;
}
}
}

/**
* This method finds the given element Index in the list
* If the Element is Not found, it will return -1
* 
* @return
*/
private int findNodeLocation(int data) {
int index = -1;
Node currentElement = headNode;
int counter =  0;
if(currentElement!=null) {
if(currentElement.getData()==data) {
System.out.println(" Found the Element, "
+ " which is at the Head of the LinkedList ");
return 0;
} else {
while(currentElement.getNextNode()!=null) {
currentElement = currentElement.getNextNode();
counter++;
if(currentElement.getData()==data) {
System.out.println(" The Element is Found at the Index "+ counter);
return counter;
}
}
//If the Element is found at the Last Element, return the Last Element's index
if(currentElement.getData()==data) {
return counter++;
}
}
}
return index;
}
/**
* 
* @param a
*/
public static void main(String a[]) {
LinkedList linkedList = new LinkedList();
linkedList.appendNode(2);
linkedList.appendNode(3);
linkedList.appendNode(5);
linkedList.appendNode(6);
linkedList.appendNode(8);
linkedList.appendNode(20);
linkedList.printNodes();
System.out.println("\n ****  After Removing the Elements from the LinkedList *******");
linkedList.deleteNode(6);
linkedList.printNodes();
int indexOfTheElement = linkedList.findNodeLocation(20);
System.out.println("\n The Index Of the Element Searching is "+ indexOfTheElement);
}

}



Comments

Popular posts from this blog

HashMap in Java

1) Implement HashMap in Java, with the put and get operations   HashMap can be implemented in Java Using Arrays. Use the same logic that the Out of the Box   HashMap follows, for resizing, and load factor, when ever the HashMap reaches the size of the   resize with the load factor a new Array is created, and the previous array contents are copied over   to the new Array.  HashMap is Not Synchronized by default. We can synchronize the whole map by using Synchronization, or by using collection.synchronizedmap(map), which synchronizes all the operations on the map. Alternatively We can use the CocurrentHashMap which does not lock the read operations, rather locks the segments that are being written. 2) HashMap vs LinkedHashMap vs IdentityHashMap 3) HashMap vs ConcurrentHashMap 4) Implement a Cache using LinkedHashMap