algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-13 07:13:37 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #693 from ulvimardaliyev/specific-position

Browse Source 
modification for specific position of inserted values
This commit is contained in:
Libin Yang
2019-01-27 09:47:19 +08:00
committed by GitHub
parent 6cc1414a2a f348e1832b
commit 20cebce230
1 changed files with 106 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

230
DataStructures/Lists/SinglyLinkedList.java
View File

@ -1,7 +1,7 @@
/** /**
* This class implements a SinglyLinked List. This is done * This class implements a SinglyLinked List. This is done
* using SinglyLinkedList class and a LinkForLinkedList Class. * using SinglyLinkedList class and a LinkForLinkedList Class.
* * <p>
* A linked list is similar to an array, it hold values. * A linked list is similar to an array, it hold values.
* However, links in a linked list do not have indexes. With * However, links in a linked list do not have indexes. With
* a linked list you do not need to predetermine it's size as * a linked list you do not need to predetermine it's size as
@ -9,113 +9,115 @@
* a singly linked list. Elements can only be added/removed * a singly linked list. Elements can only be added/removed
* at the head/front of the list. * at the head/front of the list.
* *
* @author Unknown * @author yanglbme
*
*/ */
class SinglyLinkedList{ class SinglyLinkedList {
/**Head refered to the front of the list */ /**
private Node head; * Head refer to the front of the list
/**
* Constructor of SinglyLinkedList
*/
public SinglyLinkedList(){
head = null;
}
/**
* This method inserts an element at the head
*
* @param x Element to be added
*/
public void insertHead(int x){
Node newNode = new Node(x); //Create a new link with a value attached to it
newNode.next = head; //Set the new link to point to the current head
head = newNode; //Now set the new link to be the head
}
/**
* Inserts a new node at a specified position
* @param head head node of the linked list
* @param data data to be stored in a new node
* @param position position at which a new node is to be inserted
* @return reference of the head of the linked list
*/ */
private Node head;
Node InsertNth(Node head, int data, int position) { /**
* Count of nodes
*/
private int count;
Node newNode = new Node(); /**
newNode.data = data; * This method inserts an element at the head
*
if (position == 0) { * @param x Element to be added
newNode.next = head; */
return newNode; public void insertHead(int x) {
} Node newNode = new Node(x);
newNode.next = head;
Node current = head; head = newNode;
++count;
while (--position > 0) {
current = current.next;
}
newNode.next = current.next;
current.next = newNode;
return head;
} }
/** /**
* This method deletes an element at the head * Inserts a new node at a specified position
* *
* @return The element deleted * @param data data to be stored in a new node
*/ * @param position position at which a new node is to be inserted
public Node deleteHead(){ */
Node temp = head;
head = head.next; //Make the second element in the list the new head, the Java garbage collector will later remove the old head
return temp;
}
/** public void insertNth(int data, int position) {
* Checks if the list is empty if (position < 0 || position > count) {
* throw new RuntimeException("position less than zero or position more than the count of list");
* @return true is list is empty }
*/ Node node = new Node(data);
public boolean isEmpty(){ Node dummy = new Node(-1);
return(head == null); dummy.next = head;
} Node cur = dummy;
for (int i = 0; i < position; ++i) {
cur = cur.next;
}
node.next = cur.next;
cur.next = node;
++count;
}
/** /**
* Prints contents of the list * This method deletes an element at the head
*/ *
public void display(){ * @return The element deleted
Node current = head; */
while(current!=null){ public Node deleteHead() {
System.out.print(current.getValue()+" "); if (isEmpty()) {
current = current.next; throw new RuntimeException("The list is empty!");
} }
System.out.println();
}
/** Node temp = head;
* Main method head = head.next;
* --count;
* @param args Command line arguments return temp;
*/ }
public static void main(String args[]){
SinglyLinkedList myList = new SinglyLinkedList();
System.out.println(myList.isEmpty()); //Will print true /**
* Checks if the list is empty
*
* @return true is list is empty
*/
public boolean isEmpty() {
return count == 0;
}
myList.insertHead(5); /**
myList.insertHead(7); * Prints contents of the list
myList.insertHead(10); */
public void display() {
Node current = head;
while (current != null) {
System.out.print(current.value + " ");
current = current.next;
}
System.out.println();
}
myList.display(); // 10(head) --> 7 --> 5 /**
* Main method
*
* @param args Command line arguments
*/
public static void main(String args[]) {
SinglyLinkedList myList = new SinglyLinkedList();
myList.deleteHead(); assert myList.isEmpty();
myList.display(); // 7(head) --> 5 myList.insertHead(5);
} myList.insertHead(7);
myList.insertHead(10);
myList.display(); // 10 -> 7 -> 5
myList.deleteHead();
myList.display(); // 7 -> 5
myList.insertNth(11, 2);
myList.display(); // 7 -> 5 -> 11
}
} }
/** /**
@ -123,29 +125,25 @@ class SinglyLinkedList{
* They consist of a value and a pointer to the node * They consist of a value and a pointer to the node
* after them. * after them.
* *
* @author Unknown * @author yanglbme
*
*/ */
class Node{ class Node {
/** The value of the node */ /**
public int value; * The value of the node
/** Point to the next node */ */
public Node next; //This is what the link will point to int value;
/** /**
* Constructor * Point to the next node
* */
* @param valuein Value to be put in the node Node next;
*/
public Node(int valuein){
value = valuein;
}
/**
* Returns value of the node
*/
public int getValue(){
return value;
}
/**
* Constructor
*
* @param value Value to be put in the node
*/
Node(int value) {
this.value = value;
}
} }