Deletion By KEY

Implementing a Linked List in Java using Class

public class LinkedList {

Node head;
static class Node {

int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
public static LinkedList insert(LinkedList list, int data)
{
Node new_node = new Node(data);
new_node.next = null;
if (list.head == null) {
list.head = new_node;
}
else {
Node last = list.head;
while (last.next != null) {
last = last.next;
}
last.next = new_node;
}
return list;
}
public static void printList(LinkedList list)
{
Node currNode = list.head;
System.out.print("LinkedList: ");
while (currNode != null) {

System.out.print(currNode.data + " ");

currNode = currNode.next;
}
System.out.println();
}
public static LinkedList deleteByKey(LinkedList list, int key)
{
// Store head node
Node currNode = list.head, prev = null;
if (currNode != null && currNode.data == key) {
list.head = currNode.next; // Changed head
System.out.println(key + " found and deleted");
return list;
}
while (currNode != null && currNode.data != key) {
prev = currNode;
currNode = currNode.next;
}
if (currNode != null) {
prev.next = currNode.next;
System.out.println(key + " found and deleted");
 }
if (currNode == null) {
System.out.println(key + " not found");
}
return list;
}
public static void main(String[] args)
{
LinkedList list = new LinkedList();
list = insert(list, 1);
list = insert(list, 2);
list = insert(list, 3);
list = insert(list, 4);
list = insert(list, 5);
list = insert(list, 6);
list = insert(list, 7);
list = insert(list, 8);

printList(list);
deleteByKey(list, 1);
printList(list);
deleteByKey(list, 4);
printList(list);
deleteByKey(list, 10);
printList(list);
}
}
OUTPUT

1 found and deleted

LinkedList: 2 3 4 5 6 7 8
4 found and deleted
LinkedList: 2 3 5 6 7 8
10 not found
LinkedList: 2 3 5 6 7 8

------------------------------------------------------------------

Find the middle of a given linked list

class LinkedList
{
Node head;
class Node
{
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
void printMiddle()
{
Node slow_ptr = head;
Node fast_ptr = head;
if (head != null)
{
 while (fast_ptr != null && fast_ptr.next != null)
{
fast_ptr = fast_ptr.next.next;
slow_ptr = slow_ptr.next;
}
System.out.println("The middle element is [" +
slow_ptr.data + "] \n");
}
}
public void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
public void printList()
{
Node tnode = head;
while (tnode != null)
{
System.out.print(tnode.data+"->");
tnode = tnode.next;
}
System.out.println("NULL");
}
public static void main(String [] args)
{
LinkedList llist = new LinkedList();
for (int i=5; i>0; --i)
{
llist.push(i);
llist.printList();
llist.printMiddle();
}
}
}
OUTPUT

5->NULL
The middle element is [5]

4->5->NULL
The middle element is [5]

3->4->5->NULL
The middle element is [4]

2->3->4->5->NULL
The middle element is [4]

1->2->3->4->5->NULL
The middle element is [3]
----------------------------------------------

public class QuickSortLinkedList

{
static class Node
{
int data;
 Node next;

Node(int d)
{
this.data = d;
this.next= null;
}
}

Node head;
void addNode(int data)
{
if(head == null)
{
head = new Node(data);
return;
}

Node curr = head;

while(curr.next != null)
curr = curr.next;

Node newNode = new Node(data);

curr.next = newNode;
}

void printList(Node n)
{
while(n != null)
{
System.out.print(n.data);
System.out.print(" ");
n = n.next;
}
}
Node paritionLast(Node start, Node end)
{
if(start == end ||
start == null || end == null)
return start;

Node pivot_prev = start;

Node curr = start;
int pivot = end.data;
while(start != end )
{
if(start.data < pivot)
{
pivot_prev = curr;
int temp = curr.data;
curr.data = start.data;
start.data = temp;
curr = curr.next;
}
start = start.next;
}
int temp = curr.data;
curr.data = pivot;
end.data = temp;
 return pivot_prev;
}
void sort(Node start, Node end)
{
if(start == end )
return;
Node pivot_prev = paritionLast(start, end);
sort(start, pivot_prev);
if( pivot_prev != null &&
pivot_prev == start )
sort(pivot_prev.next, end);
else if(pivot_prev != null &&
pivot_prev.next != null)
sort(pivot_prev.next.next, end);
}
public static void main(String[] args)
{
QuickSortLinkedList list = new QuickSortLinkedList();
list.addNode(30);
list.addNode(3);
list.addNode(4);
list.addNode(20);
list.addNode(5);

Node n = list.head;
while(n.next != null)
n= n.next;

System.out.println("Linked List before sorting");

list.printList(list.head);

list.sort(list.head , n);

System.out.println("\nLinked List after sorting");

list.printList(list.head);
}
}

OUTPUT
Linked List before sorting
30 3 4 20 5
Linked List after sorting
3 4 5 20 30

--------------------------------------------------------------------