public void deleteatMid()
{
if (Head == null)
{
Console.WriteLine("No Element exists to delete");
}
else if (Head.next == null)
{
Head = null;
return;
}
else
{
SingleListNode p = Head;
SingleListNode q = Head;
SingleListNode x = null;
while (q.next != null && q.next.next != null)
{
x = p;
p = p.next;
q = q.next.next;
}
if (q.next != null)
{
x = p.next;
p.next = x.next;
}
else
{
x.next = p.next;
}
}
}
public void deleteatPosition(int position)
{
if (Head == null)
{
Console.WriteLine("No Element exists to delete");
}
else if (Head.next == null)
{
Head = null;
return;
}
else
{
int postionPlace = 1;
SingleListNode temp = Head;
SingleListNode x = null;
while (position != postionPlace)
{
x = temp;
temp = temp.next;
postionPlace++;
}
x.next = temp.next;
}
}
private int CompareTwoLists(SingleListNode firstList, SingleListNode secondList)
{
//reverse second linked list.
secondList = reverseLinkedListRescursivly(secondList);
if (firstList == null || secondList == null)
{
return(0);
}
else
{
while (firstList != null && secondList != null)
{
if (firstList.data != secondList.data)
{
return(0);
}
firstList = firstList.next;
secondList = secondList.next;
}
if (firstList == null && secondList != null)
{
return(0);
}
if (firstList != null && secondList == null)
{
return(0);
}
}
return(1);
}
public SingleListNode createSingleLinkedListNew(int[] arr)
{
int arrLength = arr.Length;
if (arrLength == 0)
{
Console.WriteLine("No elemnents exits to create a single linked list");
Head = null;
return(Head);;
}
else
{
int k = 0;
Head = new SingleListNode();
Head.read(arr[k]);
SingleListNode temp = Head;
for (k = 1; k < arrLength; k++)
{
temp.next = new SingleListNode();
temp = temp.next;
temp.read(arr[k]);
}
}
return(Head);
}
public void insertatMiddle(int number)
{
SingleListNode ptr = new SingleListNode();
ptr.read(number);
if (Head == null)
{
Head = ptr;
return;;
}
SingleListNode temp = Head;
SingleListNode p = temp;
SingleListNode q = temp;
SingleListNode x = null;
while (q.next != null && q.next.next != null)
{
x = p;
p = p.next;
q = q.next.next;
}
if (q.next != null)
{
x = p.next;
p.next = ptr;
ptr.next = x;
}
else
{
x.next = ptr;
ptr.next = p;
}
}
public void swapNodesPairwise()
{
SingleListNode p = Head;
SingleListNode q = null;
SingleListNode temp = null;
SingleListNode new_start = null;
if (p.next == null)
{
return;
}
else
{
new_start = p.next;
}
while (p.next != null)
{
q = p.next;
temp = q.next;
q.next = p;
if (temp == null || temp.next == null)
{
p.next = null;
break;
}
p.next = temp.next;
p = temp;
}
Head = new_start;
}
public void reverseList()
{
if (Head == null)
{
Console.WriteLine("No Element exists to delete");
}
else if (Head.next == null)
{
return;
}
else
{
SingleListNode current = Head;
SingleListNode pnext = null;
SingleListNode result = null;
while (current != null)
{
pnext = current.next;
current.next = result;
result = current;
current = pnext;
}
Head = result;
}
}
internal void swapNodesinLLingroupsize(int k)
{
SingleListNode start = Head;
SingleListNode p = start;
SingleListNode q = null;
SingleListNode temp = null;
SingleListNode new_start = null;
int cnt = 1;
while (cnt != k)
{
if (p.next == null)
{
Head = start;
return;
}
p = p.next;
cnt++;
}
new_start = p;
q = new_start;
while (p.next != null)
{
p = start;
temp = q.next;
if (temp == null)
{
p = reverseLinkedListRescursivly(p);
Head = new_start;
return;
}
q.next = null;
q = temp;
start = temp;
cnt = 1;
while (cnt != k)
{
if (temp.next == null)
{
p = reverseLinkedListRescursivly(p);
p.next = q;
Head = new_start;
return;
}
temp = temp.next;
cnt++;
}
p = reverseLinkedListRescursivly(p); /// This logic is not working as p is gettting reverse and handling head postion 4 th one but out head postion should be firtst one (4th after reverse)
p.next = temp;
q = temp;
}
Head = new_start;
}
private int GetLinkedListLength(SingleListNode firstList)
{
SingleListNode temp = firstList;
int length = 0;
while (temp != null)
{
length++;
temp = temp.next;
}
return(length);
}
public void insertatStart(int number)
{
SingleListNode ptr = new SingleListNode();
ptr.read(number);
if (Head == null)
{
Head = ptr;
}
else
{
ptr.next = Head;
Head = ptr;
}
}
public void traverseLinkedList(SingleListNode p)
{
if (p == null)
{
Console.WriteLine("Empty list");
}
SingleListNode ptr = p;
while (ptr != null)
{
ptr.print();
ptr = ptr.next;
}
Console.WriteLine();
}
public void reverseListRecursive()
{
if (Head == null)
{
Console.WriteLine("No Element exists to delete");
}
else if (Head.next == null)
{
return;
}
else
{
SingleListNode temp = Head;
reverseLinkedListRescursivly(temp);
}
}
private SingleListNode reverseLinkedListRescursivly(SingleListNode p)
{
if (p.next == null)
{
Head = p;
return(Head);;
}
reverseLinkedListRescursivly(p.next);
// Recursive loop statement works now (p and q values are based on call (though we brake the link it will work on previous link)
SingleListNode q = p.next;
q.next = p;
p.next = null;
return(Head);
}
public void deleteatStart()
{
if (Head == null)
{
Console.WriteLine("No Element exists to delete");
}
else if (Head.next == null)
{
Head = null;
return;
}
else
{
SingleListNode temp = Head;
Head = temp.next;
}
}
public void insertatEnd(int number)
{
SingleListNode ptr = new SingleListNode();
ptr.read(number);
if (Head == null)
{
Head = ptr;
}
else
{
SingleListNode temp = Head;
while (temp.next != null)
{
temp = temp.next;
}
temp.next = ptr;
}
}
public void insertatSpecificPosition(int number, int position)
{
SingleListNode ptr = new SingleListNode();
ptr.read(number);
int postionPlace = 1;
SingleListNode temp = Head;
SingleListNode x = null;
while (postionPlace != position)
{
x = temp;
temp = temp.next;
postionPlace++;
}
x.next = ptr;
ptr.next = temp;
}
public void removeDuplicatesunsortedList()
{
SingleListNode p = Head;
SingleListNode q = null;
SingleListNode x = p;
int posotion = 1;
bool duplicatefound = false;
while (p.next != null)
{
duplicatefound = false;
q = p.next;
while (q != null)
{
if (p.data != q.data)
{
q = q.next;
}
else
{
duplicatefound = true;
x.next = p.next;
p = x.next;
x = p;
if (posotion == 1)
{
Head = x;
}
break;
}
}
if (!duplicatefound)
{
p = p.next;
x = p;
posotion++;
}
}
}
public void checkLinkedListisPallindrome()
{
SingleListNode p = Head;
SingleListNode q = Head;
SingleListNode x = null;
while (q.next != null && q.next.next != null)
{
x = p;
p = p.next;
q = q.next.next;
}
if (q.next != null)
{
//even
x = p.next;
p.next = null;
}
else
{
//Odd
x.next = null;
x = p.next;
p.next = null;
}
//Compare two lists
int result = CompareTwoLists(Head, x);
if (result == 1)
{
Console.WriteLine("This linked list is Pallindrome");
}
else
{
Console.WriteLine("This linked list is not a Pallindrome");
}
}
internal void removeDuplicatessortedList()
{
SingleListNode p = Head;
SingleListNode q = null;
while (p != null && p.next != null)
{
if (p.data == p.next.data)
{
q = p.next.next;
if (q == null)
{
p.next = null;
break;
}
p.next = q;
}
if (p.data != p.next.data)
{
p = p.next;
}
}
}
public void deleteatEnd()
{
if (Head == null)
{
Console.WriteLine("No Element exists to delete");
}
else if (Head.next == null)
{
Head = null;
return;
}
else
{
SingleListNode x = null;
SingleListNode temp = Head;
while (temp.next != null)
{
x = temp;
temp = temp.next;
}
x.next = null;
}
}
public SingleLinkedList()
{
Head = null;
}
public void AddtwoNumbersinLinkedList(int[] arr1, int[] arr2)
{
SingleListNode firstList = createSingleLinkedListNew(arr1);
SingleListNode secondList = createSingleLinkedListNew(arr2);
SingleListNode finalList = null;
int FirstListLength = GetLinkedListLength(firstList);
int SecondListLength = GetLinkedListLength(secondList);
int diff = 0;
//If two list are not having same length add 0 to match the length
if (FirstListLength != SecondListLength)
{
if (FirstListLength < SecondListLength)
{
diff = SecondListLength - FirstListLength;
while (diff == 0)
{
SingleListNode temp = new SingleListNode();
temp.read(0);
temp.next = firstList;
firstList = temp;
diff--;
}
}
else
{
diff = FirstListLength - SecondListLength;
while (diff != 0)
{
SingleListNode temp = new SingleListNode();
temp.read(0);
temp.next = secondList;
secondList = temp;
diff--;
}
}
}
firstList = reverseLinkedListRescursivly(firstList);
secondList = reverseLinkedListRescursivly(secondList);
int addition = 0, divedby10Value = 0, Reminder = 0, carry = 0, newnodeValue = 0;
SingleListNode ptr = new SingleListNode();
while (firstList != null)
{
//when divided by 10 is not equal to 0 then new node = remainder else newnode= additem.
addition = firstList.data + secondList.data + carry;
divedby10Value = addition / 10;
Reminder = addition % 10;
carry = divedby10Value;
if (divedby10Value != 0)
{
newnodeValue = Reminder;
}
else
{
newnodeValue = addition;
}
SingleListNode temp = new SingleListNode();
temp.read(newnodeValue);
if (finalList == null)
{
finalList = temp;
ptr = finalList;
}
else
{
ptr.next = new SingleListNode();
ptr = ptr.next;
ptr = temp;
//Not working this logic
}
if (firstList == null && secondList == null)
{
if (carry > 0)
{
}
}
firstList = firstList.next;
secondList = secondList.next;
}
}
public SingleListNode()
{
data = 0;
next = null;
}
internal void mergeTwoSortedLinkedLists(int[] arr1, int[] arr2)
{
SingleListNode firstLinkedList = this.createSingleLinkedListNew(arr1);
SingleListNode SecondLinkedList = this.createSingleLinkedListNew(arr2);
SingleListNode sortCheck = null;
if (firstLinkedList == null && SecondLinkedList == null)
{
Head = null;
return;
}
if (firstLinkedList == null)
{
Head = SecondLinkedList;
return;
}
if (SecondLinkedList == null)
{
Head = firstLinkedList;
return;
}
//First check which value is leess
if (firstLinkedList != null && SecondLinkedList != null)
{
if (firstLinkedList.data < SecondLinkedList.data)
{
sortCheck = firstLinkedList;
firstLinkedList = sortCheck.next;
}
else
{
sortCheck = SecondLinkedList;
SecondLinkedList = sortCheck.next;
}
Head = sortCheck;
}
while (firstLinkedList != null && SecondLinkedList != null)
{
if (firstLinkedList.data < SecondLinkedList.data)
{
sortCheck.next = firstLinkedList;
sortCheck = firstLinkedList;
firstLinkedList = sortCheck.next;
}
else
{
sortCheck.next = SecondLinkedList;
sortCheck = SecondLinkedList;
SecondLinkedList = sortCheck.next;
}
}
if (firstLinkedList != null)
{
sortCheck.next = firstLinkedList;
}
if (SecondLinkedList != null)
{
sortCheck.next = SecondLinkedList;
}
}