public void RotateLinkedList(int k)
{
//SingleLinkedListNode newhead = head;
SingleLinkedListNode temp = head;
while (k > 0)
{
SingleLinkedListNode lastNode = head;
while (lastNode.next.next != null)
{
lastNode = lastNode.next;
}
//Last Node
temp = head;
head = lastNode.next;
head.next = temp;
lastNode.next = null;
//SingleLinkedListNode temp = Intialhead;
//while (temp != null)
//{
// temp = temp;
//}
//tempHead.next = head;
//tempHead = lastNode;
k--;
}
GetAllSingleLinkedListNodesWithPointers();
}
public void RemoveSingleLinkedListNodeFromLast()
{
int lenthofLinkedList = GetLengthofLinkedList();
SingleLinkedListNode previousSingleLinkedListNode = GetSingleLinkedListNodeAtPosition(lenthofLinkedList - 1);
previousSingleLinkedListNode.next = null;
}
public void RemoveSingleLinkedListNodeFromFirst()
{
if (head != null)
{
SingleLinkedListNode tempHeadNextSingleLinkedListNode = head.next;
head = tempHeadNextSingleLinkedListNode;
}
}
//public void ReverseLinkedListGroupBySize(int k)
//{
// int lenthofLinkedList = GetLengthofLinkedList();
// int counter = lenthofLinkedList;
// int numberofelementsInThisGroup = k;
// int numberofGroups = 0;
// int counterforgroup = 1;
// while (counter >= k)
// {
// numberofGroups++;
// counter = counter - k;
// }
// if (counter < k && counter != 0)
// {
// numberofGroups++;
// counter = 0;
// }
// while (counterforgroup <= numberofGroups)
// {
// //DO Something
// numberofelementsInThisGroup = lenthofLinkedList - numberofelementsInThisGroup;
// counterforgroup++;
// }
//}
public void MergeTwoLinkedList(SingleLinkedLists firstLinkedList, SingleLinkedLists secondLinkedList)
{
SingleLinkedLists mergedLinkedList = new SingleLinkedLists();
SingleLinkedListNode tempFirstLinkedList = firstLinkedList.head;
SingleLinkedListNode tempSecondLinkedList = secondLinkedList.head;
//Creating temp
while (tempFirstLinkedList != null && tempSecondLinkedList != null)
{
//Do Something and Insert into Final MergeLinkedList
if (tempFirstLinkedList.data <= tempSecondLinkedList.data)
{
//Head
mergedLinkedList.AddSingleLinkedListNodeAtLast(tempFirstLinkedList.data);
mergedLinkedList.AddSingleLinkedListNodeAtLast(tempSecondLinkedList.data);
}
else if (tempSecondLinkedList.data <= tempFirstLinkedList.data)
{
//Head
mergedLinkedList.AddSingleLinkedListNodeAtLast(tempSecondLinkedList.data);
mergedLinkedList.AddSingleLinkedListNodeAtLast(tempFirstLinkedList.data);
}
tempFirstLinkedList = tempFirstLinkedList.next;
tempSecondLinkedList = tempSecondLinkedList.next;
}
#region Commented Code
//while (tempFirstLinkedList != null)
//{
// mergedLinkedList.AddSingleLinkedListNodeAtLast(tempFirstLinkedList.data);
// tempFirstLinkedList = tempFirstLinkedList.next;
//}
//while (tempSecondLinkedList != null)
//{
// mergedLinkedList.AddSingleLinkedListNodeAtLast(tempSecondLinkedList.data);
// tempSecondLinkedList = tempSecondLinkedList.next;
//}
//SingleLinkedListNode temp1 = mergedLinkedList.head;
//while (mergedLinkedList != null)
//{
// SingleLinkedListNode temp2 = temp1.next;
// SingleLinkedListNode temp3 = null;
// if (temp2 != null && temp1.data > temp2.data)
// {
// temp3 = temp2;
// temp2 = temp1;
// temp1 = temp3;
// }
// temp1 = temp1.next;
//}
//mergedLinkedList.GetAllSingleLinkedListNodesWithPointers();
#endregion Commented Code
}
private SingleLinkedListNode GetLastSingleLinkedListNode()
{
SingleLinkedListNode temp = head;
while (temp.next != null)
{
temp = temp.next;
}
return(temp);
}
public void AddSingleLinkedListNodeAtFirst(int data)
{
if (head == null)
{
head = new SingleLinkedListNode(data);
}
else
{
SingleLinkedListNode singleLinkedListNode = new SingleLinkedListNode(data);
singleLinkedListNode.next = head;
head = singleLinkedListNode;
}
}
public void AddSingleLinkedListNodeAtLast(int data)
{
if (head == null)
{
head = new SingleLinkedListNode(data);
}
else
{
SingleLinkedListNode lastSingleLinkedListNode = GetLastSingleLinkedListNode();
SingleLinkedListNode newSingleLinkedListNode = new SingleLinkedListNode(data);
lastSingleLinkedListNode.next = newSingleLinkedListNode;
newSingleLinkedListNode.next = null;
}
}
public void ReverseLinkedList()
{
SingleLinkedListNode previous = null;
SingleLinkedListNode current = head;
while (current != null)
{
SingleLinkedListNode nextTemp = current.next;
current.next = previous;
previous = current;
current = nextTemp;
}
head = previous;
}
public void OddEvenLinkedList()
{
SingleLinkedListNode odd = head;
SingleLinkedListNode oddHead = head;
SingleLinkedListNode even = head.next;
SingleLinkedListNode evenHead = head.next;
while (even != null && even.next != null)
{
odd.next = odd.next.next;
even.next = even.next.next;
odd = odd.next;
even = even.next;
}
odd.next = evenHead;
}
public void RemoveSingleLinkedListNodeAtPosition(int singleLinkedListNodePosition)
{
int lengthofLinkedList = GetLengthofLinkedList();
if (singleLinkedListNodePosition <= lengthofLinkedList)
{
SingleLinkedListNode previousSingleLinkedListNode = GetSingleLinkedListNodeAtPosition(singleLinkedListNodePosition - 1);
SingleLinkedListNode NextSingleLinkedListNode = GetSingleLinkedListNodeAtPosition(singleLinkedListNodePosition + 1);
previousSingleLinkedListNode.next = NextSingleLinkedListNode;
GetAllSingleLinkedListNodesWithPointers();
}
else
{
Console.WriteLine("SingleLinkedListNode Position does not exists in Linked List");
}
}
public void IsLinkedListPalindrome()
{
int lenthofLinkedList = GetLengthofLinkedList();
string result = "It's a Palindrome";
int counter = 1;
for (int i = lenthofLinkedList; i > (lenthofLinkedList / 2); i--)
{
SingleLinkedListNode tempLastNode = GetSingleLinkedListNodeAtPosition(i);
SingleLinkedListNode tempfirstNode = GetSingleLinkedListNodeAtPosition(counter);
if (tempLastNode.data != tempfirstNode.data)
{
result = "Not a Palindrome";
}
counter++;
}
Console.WriteLine(result);
}
public int GetLengthofLinkedList()
{
if (head == null)
{
return(0);
}
SingleLinkedListNode singleLinkedListNode = head;
int counter = 1;
while (singleLinkedListNode.next != null)
{
singleLinkedListNode = singleLinkedListNode.next;
counter++;
}
return(counter);
}
public void AddSingleLinkedListNodeAtPosition(int data, int position)
{
SingleLinkedListNode singleLinkedListNode = new SingleLinkedListNode(data);
if (position == 1)
{
AddSingleLinkedListNodeAtFirst(data);
}
else
{
SingleLinkedListNode previousSingleLinkedListNode = GetSingleLinkedListNodeAtPosition(position - 1);
SingleLinkedListNode nextSingleLinkedListNode = GetSingleLinkedListNodeAtPosition(position);
previousSingleLinkedListNode.next = singleLinkedListNode;
singleLinkedListNode.next = nextSingleLinkedListNode;
}
GetAllSingleLinkedListNodesWithPointers();
}
public SingleLinkedListNode GetNextSingleLinkedListNode(int value)
{
SingleLinkedListNode nextSingleLinkedListNode = head;
int singleLinkedListNodePosition;
if (CheckIfSingleLinkedListNodeExists(value, out singleLinkedListNodePosition))
{
if (singleLinkedListNodePosition != 1)
{
nextSingleLinkedListNode = GetSingleLinkedListNodeAtPosition(singleLinkedListNodePosition + 1);
}
}
else
{
Console.WriteLine("SingleLinkedListNode does not exist");
}
return(nextSingleLinkedListNode);
}
//public void ReverseNodesInLinkedList(int k)
//{
// int i = 1;
// int j = k;
// while (j <= GetLengthofLinkedList())
// {
// ReverseNodes(i, j);
// i = i + k;
// j = j + k;
// }
//}
//private void ReverseNodes(int i, int j)
//{
// while(i!=j && i<j)
// {
// SingleLinkedListNode firstNode = GetSingleLinkedListNodeAtPosition(i);
// SingleLinkedListNode secondNode = GetSingleLinkedListNodeAtPosition(j);
// SingleLinkedListNode firstNextNode = firstNode.next;
// SingleLinkedListNode secondNextNode = secondNode.next;
// SingleLinkedListNode temp;
// temp = secondNode;
// secondNode = firstNode;
// firstNode = temp;
// SingleLinkedListNode t1 = head;
// firstNode.next = firstNextNode;
// secondNode.next = secondNextNode;
// SingleLinkedListNode t2 = head;
// i = i + 1;
// j = j - 1;
// }
// return;
//}
public void GetAllSingleLinkedListNodesWithPointers()
{
if (head == null)
{
Console.WriteLine("No singleLinkedListNodes present");
}
else
{
SingleLinkedListNode singleLinkedListNode = head;
int counter = 1;
while (singleLinkedListNode != null)
{
Console.WriteLine("SingleLinkedListNode at position {0}: ", counter);
Console.WriteLine("SingleLinkedListNode Value: {0}", singleLinkedListNode.data);
singleLinkedListNode = singleLinkedListNode.next;
counter++;
}
}
}
public bool CheckIfSingleLinkedListNodeExists(int data, out int singleLinkedListNodePosition)
{
SingleLinkedListNode singleLinkedListNode = head;
singleLinkedListNodePosition = -1;
int counter = 1;
bool singleLinkedListNodeExists = false;
while (singleLinkedListNode != null)
{
if (singleLinkedListNode.data == data)
{
singleLinkedListNodeExists = true;
singleLinkedListNodePosition = counter;
break;
}
singleLinkedListNode = singleLinkedListNode.next;
counter++;
}
return(singleLinkedListNodeExists);
}
public void FindDuplicates()
{
SingleLinkedListNode temp1 = head;
SingleLinkedListNode temp2 = head.next;
while (temp1 != null)
{
while (temp2 != null)
{
if (temp2.data == temp1.data)
{
Console.WriteLine("Duplicate Value is: " + temp1.data);
}
temp2 = temp2.next;
}
temp1 = temp1.next;
if (temp1 != null)
{
temp2 = temp1.next;
}
}
}
public void GetSpecificSingleLinkedListNodeValueByPosition(int position)
{
if (head == null)
{
Console.WriteLine("No singleLinkedListNodes present");
}
else
{
SingleLinkedListNode singleLinkedListNode = head;
int counter = 1;
while (counter <= GetLengthofLinkedList())
{
if (counter == position)
{
Console.WriteLine("SingleLinkedListNode at position {0}: ", counter);
Console.WriteLine("SingleLinkedListNode Value: {0}", singleLinkedListNode.data);
}
singleLinkedListNode = singleLinkedListNode.next;
counter++;
}
}
}
public SingleLinkedListNode GetSingleLinkedListNodeAtPosition(int singleLinkedListNodePosition)
{
SingleLinkedListNode singleLinkedListNode = head;
int counter = 1;
if (singleLinkedListNodePosition == 1)
{
return(head);
}
while (counter <= GetLengthofLinkedList())
{
if (singleLinkedListNodePosition == counter)
{
return(singleLinkedListNode);
}
else
{
singleLinkedListNode = singleLinkedListNode.next;
counter++;
}
}
return(null);
}
public SingleLinkedListNode GetSingleLinkedListNodeByValueandPosition(int value, int singleLinkedListNodePosition)
{
SingleLinkedListNode singleLinkedListNode = head;
int counter = 1;
if (singleLinkedListNodePosition == 1 && singleLinkedListNode.data == value)
{
return(head);
}
while (singleLinkedListNode != null)
{
if (singleLinkedListNode.data == value && singleLinkedListNodePosition == counter)
{
return(singleLinkedListNode);
}
else
{
singleLinkedListNode = singleLinkedListNode.next;
counter++;
}
}
return(null);
}
