private LinkedListNode NthToLast(LinkedListNode head, int n)
{
var p1 = head;
var p2 = head;
if (n <= 0) return null;
// Move p2 n nodes into the list. Keep n1 in the same position.
for (var i = 0; i < n - 1; i++)
{
if (p2 == null)
{
return null; // Error: list is too small.
}
p2 = p2.Next;
}
if (p2 == null)
{ // Another error check.
return null;
}
// Move them at the same pace. When p2 hits the end,
// p1 will be at the right element.
while (p2.Next != null)
{
p1 = p1.Next;
p2 = p2.Next;
}
return p1;
}
LinkedListNode FindBeginning(LinkedListNode head)
{
LinkedListNode slow = head;
LinkedListNode fast = head;
// Find meeting point
while (fast != null && fast.Next != null)
{
slow = slow.Next;
fast = fast.Next.Next;
if (slow == fast)
{
break;
}
}
// Error check - there is no meeting point, and therefore no loop
if (fast == null || fast.Next == null)
{
return null;
}
/* Move slow to Head. Keep fast at Meeting Point. Each are k steps
/* from the Loop Start. If they move at the same pace, they must
* meet at Loop Start. */
slow = head;
while (slow != fast)
{
slow = slow.Next;
fast = fast.Next;
}
// Both now point to the start of the loop.
return fast;
}
void DeleteDupsB(LinkedListNode head)
{
if (head == null) return;
var current = head;
while (current != null)
{
/* Remove all future nodes that have the same value */
var runner = current;
while (runner.Next != null)
{
Tap(0);
if (runner.Next.Data == current.Data)
{
runner.Next = runner.Next.Next;
}
else
{
runner = runner.Next;
}
}
current = current.Next;
}
}
public static LinkedListNode findIntersection(LinkedListNode list1, LinkedListNode list2)
{
if (list1 == null || list2 == null) return null;
/* Get tail and sizes. */
Result result1 = getTailAndSize(list1);
Result result2 = getTailAndSize(list2);
/* If different tail nodes, then there's no intersection. */
if (result1.tail != result2.tail)
{
return null;
}
/* Set pointers to the start of each linked list. */
LinkedListNode shorter = result1.size < result2.size ? list1 : list2;
LinkedListNode longer = result1.size < result2.size ? list2 : list1;
/* Advance the pointer for the longer linked list by the difference in lengths. */
longer = getKthNode(longer, Math.Abs(result1.size - result2.size));
/* Move both pointers until you have a collision. */
while (shorter != longer)
{
shorter = shorter.Next;
longer = longer.Next;
}
/* Return either one. */
return longer;
}
public void Run()
{
/* Create linked list */
int[] vals = {1, 3, 7, 5, 2, 9, 4};
var head = new LinkedListNode(vals[0], null, null);
var current = head;
for (var i = 1; i < vals.Length; i++)
{
current = new LinkedListNode(vals[i], null, current);
}
Console.WriteLine(head.PrintForward());
var head2 = head.Clone();
var head3 = head.Clone();
var head4 = head.Clone();
/* Partition */
var h = Partition(head, 5);
var h2 = Partition2(head2, 5);
var h3 = Partition3(head3, 5);
var h4 = Partition4(head4, 5);
/* Print Result */
Console.WriteLine(h.PrintForward());
Console.WriteLine(h2.PrintForward());
Console.WriteLine(h3.PrintForward());
Console.WriteLine(h4.PrintForward());
}
public void Run()
{
const int length = 10;
var nodes = new LinkedListNode[length];
for (var i = 0; i < length; i++)
{
nodes[i] = new LinkedListNode(i >= length / 2 ? length - i - 1 : i, null, null);
}
for (var i = 0; i < length; i++)
{
if (i < length - 1)
{
nodes[i].SetNext(nodes[i + 1]);
}
if (i > 0)
{
nodes[i].SetPrevious(nodes[i - 1]);
}
}
// nodes[length - 2].data = 9; // Uncomment to ruin palindrome
var head = nodes[0];
Console.WriteLine(head.PrintForward());
Console.WriteLine(IsPalindrome(head));
Console.WriteLine(IsPalindrome2(head));
}
public void Run()
{
var first = new LinkedListNode(0, null, null);
var originalList = first;
var second = first;
for (var i = 1; i < 8; i++)
{
second = new LinkedListNode(i % 2, null, null);
first.SetNext(second);
second.SetPrevious(first);
first = second;
}
var list1 = originalList.Clone();
var list2 = originalList.Clone();
var list3 = originalList.Clone();
DeleteDupsA(list1);
DeleteDupsB(list2);
DeleteDupsC(list3);
Console.WriteLine(originalList.PrintForward());
Console.WriteLine(list1.PrintForward());
Console.WriteLine(list1.PrintForward());
Console.WriteLine(list1.PrintForward());
Console.WriteLine(_tapB);
Console.WriteLine(_tapC);
}
Result IsPalindromeRecurse(LinkedListNode head, int length)
{
if (head == null || length == 0)
{
return new Result(null, true);
}
else if (length == 1)
{
return new Result(head.Next, true);
}
else if (length == 2)
{
return new Result(head.Next.Next, head.Data == head.Next.Data);
}
Result res = IsPalindromeRecurse(head.Next, length - 2);
if (!res.result || res.node == null)
{
return res; // Only "result" member is actually used in the call stack.
}
else
{
res.result = head.Data == res.node.Data;
res.node = res.node.Next;
return res;
}
}
private LinkedListNode AddLists(LinkedListNode list1, LinkedListNode list2, int carry)
{
if (list1 == null && list2 == null && carry == 0)
{
return null;
}
var result = new LinkedListNode();
var value = carry;
if (list1 != null)
{
value += list1.Data;
}
if (list2 != null)
{
value += list2.Data;
}
result.Data = value % 10;
if (list1 != null || list2 != null)
{
var more = AddLists(list1 == null ? null : list1.Next,
list2 == null ? null : list2.Next,
value >= 10 ? 1 : 0);
result.SetNext(more);
}
return result;
}
bool IsPalindrome2(LinkedListNode head) {
LinkedListNode fast = head;
LinkedListNode slow = head;
Stack<int> stack = new Stack<int>();
while (fast != null && fast.Next != null) {
stack.Push(slow.Data);
slow = slow.Next;
fast = fast.Next.Next;
}
/* Has odd number of elements, so skip the middle */
if (fast != null) {
slow = slow.Next;
}
while (slow != null) {
int top = stack.Pop();
Console.WriteLine(slow.Data + " " + top);
if (top != slow.Data) {
return false;
}
slow = slow.Next;
}
return true;
}
public void Run()
{
const int listLength = 10;
const int k = 3;
// Create linked list
var nodes = new LinkedListNode[listLength];
for (var i = 1; i <= listLength; i++)
{
nodes[i - 1] = new LinkedListNode(i, null, i - 1 > 0 ? nodes[i - 2] : null);
Console.Write("{0} -> ", nodes[i - 1].Data);
}
Console.WriteLine();
// Create loop;
nodes[listLength - 1].Next = nodes[listLength - k - 1];
Console.WriteLine("{0} -> {1}", nodes[listLength - 1].Data, nodes[listLength - k - 1].Data);
var loop = FindBeginning(nodes[0]);
if (loop == null)
{
Console.WriteLine("No Cycle.");
}
else
{
Console.WriteLine(loop.Data);
}
}
LinkedListNode AddLists(LinkedListNode l1, LinkedListNode l2, int carry)
{
if (l1 == null && l2 == null && carry == 0)
{
return null;
}
LinkedListNode result = new LinkedListNode();
int value = carry;
if (l1 != null)
{
value += l1.Data;
}
if (l2 != null)
{
value += l2.Data;
}
result.Data = value % 10;
if (l1 != null || l2 != null)
{
LinkedListNode more = AddLists(l1 == null ? null : l1.Next,
l2 == null ? null : l2.Next,
value >= 10 ? 1 : 0);
result.SetNext(more);
}
return result;
}
public void SetPrevious(LinkedListNode p)
{
Prev = p;
if (p != null && p.Next != this)
{
p.SetNext(this);
}
}
LinkedListNode NthToLastR3(LinkedListNode head, int k)
{
Result res = NthToLastR3Helper(head, k);
if (res != null)
{
return res.Node;
}
return null;
}
int LinkedListToInt(LinkedListNode node)
{
int value = 0;
if (node.Next != null)
{
value = 10 * LinkedListToInt(node.Next);
}
return value + node.Data;
}
public void Run()
{
#region First Part
{
var lA1 = new LinkedListNode(9, null, null);
var lA2 = new LinkedListNode(9, null, lA1);
var lA3 = new LinkedListNode(9, null, lA2);
var lB1 = new LinkedListNode(1, null, null);
var lB2 = new LinkedListNode(0, null, lB1);
var lB3 = new LinkedListNode(0, null, lB2);
var list3 = AddLists(lA1, lB1, 0);
Console.WriteLine(" " + lA1.PrintForward());
Console.WriteLine("+ " + lB1.PrintForward());
Console.WriteLine("= " + list3.PrintForward());
var l1 = LinkedListToInt(lA1);
var l2 = LinkedListToInt(lB1);
var l3 = LinkedListToInt(list3);
Console.Write(l1 + " + " + l2 + " = " + l3 + "\n");
Console.WriteLine(l1 + " + " + l2 + " = " + (l1 + l2));
}
#endregion First Part
#region Followup
{
var lA1 = new LinkedListNode(3, null, null);
var lA2 = new LinkedListNode(1, null, lA1);
//LinkedListNode lA3 = new LinkedListNode(5, null, lA2);
var lB1 = new LinkedListNode(5, null, null);
var lB2 = new LinkedListNode(9, null, lB1);
var lB3 = new LinkedListNode(1, null, lB2);
var list3 = AddLists2(lA1, lB1);
Console.WriteLine(" " + lA1.PrintForward());
Console.WriteLine("+ " + lB1.PrintForward());
Console.WriteLine("= " + list3.PrintForward());
var l1 = linkedListToInt(lA1);
var l2 = linkedListToInt(lB1);
var l3 = linkedListToInt(list3);
Console.Write(l1 + " + " + l2 + " = " + l3 + "\n");
Console.WriteLine(l1 + " + " + l2 + " = " + (l1 + l2));
}
#endregion Followup
}
public static LinkedListNode getKthNode(LinkedListNode head, int k)
{
LinkedListNode current = head;
while (k > 0 && current != null)
{
current = current.Next;
k--;
}
return current;
}
public LinkedListNode Clone()
{
LinkedListNode next2 = null;
if (Next != null)
{
next2 = Next.Clone();
}
LinkedListNode head2 = new LinkedListNode(Data, next2, null);
return head2;
}
public static LinkedListNode CreateLinkedListFromArray(int[] vals)
{
LinkedListNode head = new LinkedListNode(vals[0], null, null);
LinkedListNode current = head;
for (int i = 1; i < vals.Length; i++)
{
current = new LinkedListNode(vals[i], null, current);
}
return head;
}
public static LinkedListNode LinkedListWithValue(int N, int value)
{
LinkedListNode root = new LinkedListNode(value, null, null);
LinkedListNode prev = root;
for (int i = 1; i < N; i++) {
LinkedListNode next = new LinkedListNode(value, null, null);
prev.SetNext(next);
prev = next;
}
return root;
}
int NthToLastR1(LinkedListNode head, int n)
{
if (n == 0 || head == null) {
return 0;
}
int k = NthToLastR1(head.Next, n) + 1;
if (k == n) {
Console.WriteLine(n + "th to last node is " + head.Data);
}
return k;
}
bool DeleteNode(LinkedListNode n)
{
if (n == null || n.Next == null)
{
return false; // Failure
}
LinkedListNode next = n.Next;
n.Data = next.Data;
n.Next = next.Next;
return true;
}
int Length(LinkedListNode l)
{
if (l == null)
{
return 0;
}
else
{
return 1 + Length(l.Next);
}
}
public static LinkedListNode RandomLinkedList(int N, int min, int max)
{
LinkedListNode root = new LinkedListNode(RandomIntInRange(min, max), null, null);
LinkedListNode prev = root;
for (int i = 1; i < N; i++) {
int data = RandomIntInRange(min, max);
LinkedListNode next = new LinkedListNode(data, null, null);
prev.SetNext(next);
prev = next;
}
return root;
}
bool IsPalindrome(LinkedListNode head)
{
int size = 0;
LinkedListNode n = head;
while (n != null)
{
size++;
n = n.Next;
}
Result p = IsPalindromeRecurse(head, size);
return p.result;
}
public void SetNext(LinkedListNode n)
{
Next = n;
if (this == Last)
{
Last = n;
}
if (n != null && n.Prev != this)
{
n.SetPrevious(this);
}
}
LinkedListNode Partition(LinkedListNode node, int pivot)
{
LinkedListNode beforeStart = null;
LinkedListNode beforeEnd = null;
LinkedListNode afterStart = null;
LinkedListNode afterEnd = null;
/* Partition list */
while (node != null)
{
var next = node.Next;
node.Next = null;
if (node.Data < pivot)
{
if (beforeStart == null)
{
beforeStart = node;
beforeEnd = beforeStart;
}
else
{
beforeEnd.Next = node;
beforeEnd = node;
}
}
else
{
if (afterStart == null)
{
afterStart = node;
afterEnd = afterStart;
}
else
{
afterEnd.Next = node;
afterEnd = node;
}
}
node = next;
}
/* Merge before list and after list */
if (beforeStart == null)
{
return afterStart;
}
beforeEnd.Next = afterStart;
return beforeStart;
}
PartialSum AddListsHelper(LinkedListNode l1, LinkedListNode l2)
{
if (l1 == null && l2 == null)
{
return new PartialSum();
}
PartialSum sum = AddListsHelper(l1.Next, l2.Next);
int val = sum.carry + l1.Data + l2.Data;
LinkedListNode full_result = insertBefore(sum.sum, val % 10);
sum.sum = full_result;
sum.carry = val / 10;
return sum;
}
public static Result getTailAndSize(LinkedListNode list)
{
if (list == null) return null;
int size = 1;
LinkedListNode current = list;
while (current.Next != null)
{
size++;
current = current.Next;
}
return new Result(current, size);
}
private bool DeleteNode(LinkedListNode node)
{
if (node == null || node.Next == null)
{
return false; // Failure
}
var next = node.Next;
node.Data = next.Data;
node.Next = next.Next;
return true;
}
