/// <summary>
/// O(n)
/// </summary>
/// <param name="t"></param>
public SinglyNode <T> InsertLast(T t)
{
SinglyNode <T> current = _firstNode;
if (current == null)
{
_firstNode = new SinglyNode <T>()
{
Data = t
};
Count++;
return(_firstNode);
}
else
{
while (current.Next != null)
{
current = current.Next;
}
current.Next = new SinglyNode <T>()
{
Data = t
};
Count++;
return(current.Next);
}
}
/// <summary>
/// Given a linked list and a value x, partition it such that all nodes less that x come before nodes greater than r equal to x
/// </summary>
/// <param name="value"></param>
public void Partition(T value)
{
SinglyNode <T> dummyLess = new SinglyNode <T>();
SinglyNode <T> dummyLarger = new SinglyNode <T>();
dummyLess.Next = _firstNode;
_firstNode = dummyLess;
var largerCurr = dummyLarger;//set current point
while (_firstNode.Next != null)
{
if (_firstNode.Next.Data.CompareTo(value) >= 0) // greater than x, move to right
{
//add to large list
largerCurr.Next = _firstNode.Next; //add to larger list
largerCurr = largerCurr.Next; // move pointer
//remove from current list
_firstNode.Next = _firstNode.Next.Next;
}
else
{
_firstNode = _firstNode.Next;
}
}
_firstNode.Next = dummyLarger.Next;
_firstNode = dummyLess.Next;//remove dummy node
}
/// <summary>
///
/// </summary>
/// <param name="node1">sorted array</param>
/// <param name="node2">sorted array</param>
/// <returns></returns>
private SinglyNode <T> Merge(SinglyNode <T> node1, SinglyNode <T> node2)
{
if (node1 == null)
{
return(node2);
}
if (node2 == null)
{
return(node1);
}
SinglyNode <T> dummy = new SinglyNode <T>();
var curr = dummy;
while (node1 != null && node2 != null)
{
if (node1.Data.CompareTo(node2.Data) >= 0) //node1 value larger thant node2 value
{
curr.Next = node2;
node2 = node2.Next;
}
else
{
curr.Next = node1;
node1 = node1.Next;
}
curr = curr.Next;
}
curr.Next = node1 ?? node2;
return(dummy.Next);
}
private Node <T, T> ToBST(SinglyNode <T> node, int count)
{
if (count == 0)
{
return(null);
}
if (count == 1)
{
return(new Node <T, T>(node.Data, node.Data));
}
int middle = count / 2;
int steps = 0;
var curr = node;
while (steps < middle)
{
curr = curr.Next;
steps++;
}
return(new Node <T, T>(curr.Data, curr.Data,
leftChild: ToBST(node, middle),
rightChild: ToBST(curr.Next, count - middle - 1
)));
}
public void DeleteFirst()
{
if (_first.Next == null) // if only one node
{
_last = null;
}
_first = _first.Next;
}
public void Print()
{
SinglyNode <T> current = _firstNode;
while (current != null)
{
Console.WriteLine(current.Data);
current = current.Next;
}
}
private void Print(SinglyNode <T> node)
{
SinglyNode <T> current = node;
while (current != null)
{
Console.WriteLine(current.Data);
current = current.Next;
}
}
public void InsertFirst(T t)
{
SinglyNode <T> newNode = new SinglyNode <T>
{
Data = t,
Next = _firstNode
};
_firstNode = newNode;
Count++;
}
/// <summary>
/// Reverse from mth to nth nodes in the list, m and n meets 1 <= m <= n <= length
/// </summary>
/// <param name="m"></param>
/// <param name="n"></param>
public void PartlyReverse(int m, int n)
{
var curr = _firstNode;
var steps = 1;
SinglyNode <T> before = new SinglyNode <T>();
SinglyNode <T> start = new SinglyNode <T>();
SinglyNode <T> after = new SinglyNode <T>();
SinglyNode <T> pre = new SinglyNode <T>();
if (m == 1) //edge case
{
before = null;
start = _firstNode;
}
while (steps <= n)
{
if (steps == m - 1) // find starting point
{
before = curr;
start = curr.Next;
}
if (steps >= m && steps < n) //reverse
{
var temp = curr.Next;
curr.Next = pre;
pre = curr;
curr = temp;
steps++;
continue;
}
if (steps == n) //last step, steps and curr arrive at n, link curr and prev, set after
{
after = curr.Next;
curr.Next = pre;
break;
}
steps++;
curr = curr.Next;
}
if (before != null)
{
before.Next = curr; // edge case
}
else
{
_firstNode = curr;
}
start.Next = after;
}
public void DeleteFirst()
{
if (_firstNode != null)
{
_firstNode = _firstNode.Next;
Count--;
}
else
{
throw new Exception("The list is empty");
}
}
public void Rearrange()
{
if (_firstNode?.Next == null)
{
return;
}
var middleNode = GetMiddleNode(_firstNode);
var rightPart = middleNode.Next;
middleNode.Next = null;
_firstNode = Combine(_firstNode, Reverse(rightPart));
}
public void InsertFirst(T t)
{
SinglyNode <T> newNode = new SinglyNode <T>()
{
Data = t
};
if (IsEmpty())
{
_last = newNode;
}
newNode.Next = _first; // newNode--> old first
_first = newNode; // first place
}
/// <summary>
/// O(n)
/// </summary>
public void Reverse()
{
SinglyNode <T> prev = null;
SinglyNode <T> current = _firstNode;
while (current != null)
{
var next = current.Next;
current.Next = prev;
prev = current;
current = next;
}
_firstNode = prev;
}
/// <summary>
/// O(n)
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public T GetValueNthToLastNode(int n)
{
SinglyNode <T> leftPointer = _firstNode;
SinglyNode <T> rightPointer = _firstNode;
for (int i = 0; i < n - 1; i++) //rightPointer hop n nodes
{
rightPointer = rightPointer.Next ?? throw new Exception("N is Out of Range!");
}
while (rightPointer.Next != null) //left and right hop together until rightPointer reaches the last node(rightPointer.Next = null)
{
leftPointer = leftPointer.Next;
rightPointer = rightPointer.Next;
}
return(leftPointer.Data); //then leftPointer points to the nth last node.
}
/// <summary>
///Given a singly linked list, find middle of the linked list. For example, if given linked list is 1->2->3->4->5 then output should be 3. If there are even nodes, then there would be two middle nodes, we need to print second middle element.
/// </summary>
/// <returns></returns>
public T MiddleItem()
{
if (_firstNode == null)
{
return(default(T));
}
SinglyNode <T> slow = _firstNode;
SinglyNode <T> fast = _firstNode;
while (fast?.Next != null) //p.s. fast could be null, put question mark
{
slow = slow.Next;
fast = fast.Next.Next;
}
return(slow.Data);
}
/// <summary>
/// O(1)
/// </summary>
/// <param name="t"></param>
public void InsertLast(T t)
{
SinglyNode <T> newNode = new SinglyNode <T>()
{
Data = t
};
if (IsEmpty())
{
_first = newNode;
}
else
{
_last.Next = newNode;
_last = newNode;
}
}
private SinglyNode <T> Combine(SinglyNode <T> first, SinglyNode <T> second)
{
SinglyNode <T> dummy = new SinglyNode <T>();
var curr = dummy;
while (first != null && second != null)
{
curr.Next = first;
curr = curr.Next;
first = first.Next;
curr.Next = second;
curr = curr.Next;
second = second.Next;
}
curr.Next = first ?? second;
return(dummy.Next);
}
private SinglyNode <T> Reverse(SinglyNode <T> node)
{
if (node?.Next == null)
{
return(node);
}
SinglyNode <T> pre = null;
while (node != null)
{
var next = node.Next;
node.Next = pre;
pre = node;
node = next;
}
return(pre);
}
private SinglyNode <T> SortHelper(SinglyNode <T> head)
{
//base case
if (head?.Next == null)
{
return(head);
}
//recursion
var middelNode = GetMiddleNode(head);
var node2 = middelNode.Next; //set head for the right part
middelNode.Next = null; // break the list into two parts
var left = SortHelper(head); //potentially cause overflow-exception, head is the same with the method parameter, such that the size for head may not be reduced.
var right = SortHelper(node2);
return(Merge(left, right));
}
private SinglyNode <T> GetMiddleNode(SinglyNode <T> head)
{
if (head == null)
{
return(null);
}
if (head.Next == null)
{
return(head);
}
SinglyNode <T> slow = head;
SinglyNode <T> fast = head;
while (fast.Next != null && fast.Next.Next != null)
{
slow = slow.Next;
fast = fast.Next.Next;
}
return(slow);
}
/// <summary>
/// Suppose the list is ordered, remove all if duplicated
/// </summary>
public void RemoveAllIfDuplicated()
{
//use dummy node before _firstNode
var dummy = new SinglyNode <T>();
dummy.Next = _firstNode;
_firstNode = dummy;
while (_firstNode.Next != null && _firstNode.Next.Next != null)
{
if (_firstNode.Next.Data.CompareTo(_firstNode.Next.Next.Data) == 0)
{
var value = _firstNode.Next.Data;
while (_firstNode.Next != null && _firstNode.Next.Data.CompareTo(value) == 0)
{
_firstNode.Next = _firstNode.Next.Next;
}
}
else
{
_firstNode = _firstNode.Next;
}
}
_firstNode = dummy.Next;
}
public CircularLinkedList()
{
_first = null;
_last = null;
}
/// <summary>
/// Time complexity O(nlogn), splace O(1)
/// </summary>
///
public void Sort()
{
_firstNode = SortHelper(_firstNode);
}
