public static void removeDuplicate(LinkedNode head)
{
LinkedNode previous = head;
LinkedNode current = head.Next;
LinkedNode runner = head;
while (current != null)
{
while (runner != current)
{
if (runner.Data.Equals(current.Data))
{
//never change link, copy the value
double temp = current.Next.Data;
current.Data = temp;
current.Next = current.Next.Next;
break;
}
runner = runner.Next;
}
if (runner == current)
{
previous = current;
current = current.Next;
runner = head;
}
}
}
private static Result verifyPalindrome(LinkedNode head, int length)
{
if (length == 2)
{
Result r = new Result(head.Next.Next, head.Data == head.Next.Data);
return r;
}
else if (length == 1)
{
Result r = new Result(head.Next, true);
return r;
}
else if (length == 0)
{
return new Result(null, true);
}
Result result = verifyPalindrome(head.Next, length - 2);
if (result == null)
{
return result;
}
else
{
result.quilify = result.node.Data == head.Data;
result.node = result.node.Next;
return result;
}
}
public LinkedNode Insert(LinkedNode Other)
{
if (Other.Weight <= this.Weight)
{
if (this.Next != null)
{
this.Next.Prev = Other;
Other.Next = this.Next;
}
this.Next = Other;
Other.Prev = this;
return Other;
}
if (this.Prev == null)
{
Other.Prev = null;
this.Prev = Other;
Other.Next = this;
}
else
{
this.Prev.Insert(Other);
}
return this;
}
//Math: 1step runs, 2steps, finally they meet at the point at from k step from loop, k is start distance
public static LinkedNode findLoopNode(LinkedNode head)
{
LinkedNode p1 = head;
LinkedNode p2 = head;
while (true)
{
p1 = p1.Next;
p2 = p2.Next.Next;
if (p1 == p2)
{
break;
}
}
if (p1 == null || p2==null)
{
return null;
}
p1 = head;
while (true)
{
if (p1 == p2)
{
return p1;
}
p1 = p1.Next;
p2 = p2.Next;
}
}
public static LinkedNode CommonNode(LinkedNode a, LinkedNode b)
{
int aLength = 0, bLength = 0;
LinkedNode aIter = a, bIter = b;
while (aIter != null)
{
aLength++;
aIter = aIter.next;
}
while (bIter != null)
{
bLength++;
bIter = bIter.next;
}
if (aLength < bLength)
{
aIter = b;
bIter = a;
} else
{
aIter = a;
bIter = b;
}
for (int i = 0; i < Math.Abs(aLength - bLength); ++i)
{
aIter = aIter.next;
}
while (aIter != bIter && aIter != null && bIter != null)
{
aIter = aIter.next;
bIter = bIter.next;
}
return aIter;
}
public static bool verifyPalindromeIterate(LinkedNode head)
{
System.Collections.Generic.Stack<double> stack = new System.Collections.Generic.Stack<double>();
LinkedNode SlowRunner = head;
LinkedNode FastRunner = head;
while (FastRunner != null && FastRunner.Next != null)
{
stack.Push(SlowRunner.Data);
FastRunner = FastRunner.Next.Next;
SlowRunner = SlowRunner.Next;
}
SlowRunner = SlowRunner.Next;
while (SlowRunner!=null)
{
if (stack.Pop() == SlowRunner.Data)
{
SlowRunner = SlowRunner.Next;
}
else
{
return false;
}
}
return true;
}
private static LinkedNode Merge(LinkedNode l1, LinkedNode l2)
{
LinkedNode head = null;
LinkedNode l1p = l1, l2p = l2;
if (l1.data < l2.data)
{
head = l1;
l1p = l1.next;
} else
{
head = l2;
l2p = l2.next;
}
LinkedNode cur = head;
while (l1p != null && l2p != null)
{
if (l1p.data < l2p.data)
{
cur.next = l1p;
l1p = l1p.next;
} else
{
cur.next = l2p;
l2p = l2p.next;
}
cur = cur.next;
}
cur.next = (l1p != null ? l1p : l2p);
return head;
}
//Sample
public static LinkedNode addLists(LinkedNode l1, LinkedNode l2, int carry)
{
if (l1 == null && l2 == null && carry == 0)
{
return null;
}
LinkedNode result = new LinkedNode(carry);
double value = carry;
if (l1 != null)
{
value += l1.Data;
}
if (l2 != null)
{
value += l2.Data;
}
result.Data = value % 10;
if (l1 != null || l2 != null || value >= 10)
{
LinkedNode more = addLists(
l1 == null ? null : l1.Next,
l2 == null ? null : l2.Next,
value >= 10 ? 1 : 0
);
result.Next = more;
}
return result;
}
public string Pop()
{
var result = tail.Data;
tail = tail.Previous;
Count--;
return(result);
}
public void removeNode(LinkedNode node)
{
LinkedNode next = node.next;
LinkedNode prev = node.prev;
prev.next = next;
next.prev = prev;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="value"></param>
/// <returns></returns>
protected LinkedNode <T> InsertBefore(LinkedNode <T> node, ref T value)
{
LinkedNode <T> result = LinkedNode <T> .InsertBefore(node, ref value);
System.Threading.Interlocked.Increment(ref m_Count);
return(result);
}
protected LinkedNode <T> AddAfter(LinkedNode <T> node, ref T value)
{
LinkedNode <T> result = LinkedNode <T> .AddAfter(node, ref value);
System.Threading.Interlocked.Increment(ref m_Count);
return(result);
}
public static LinkedNode <T> Prob_2_7_DoListsIntersect_v1 <T>(LinkedNode <T> firstList, LinkedNode <T> secondList)
{
var runner = firstList;
var firsListLength = 1;
while (runner.nextNode != null)
{
runner = runner.nextNode;
firsListLength++;
}
var secondRunner = secondList;
var secondListLength = 1;
while (secondRunner.nextNode != null)
{
secondRunner = secondRunner.nextNode;
secondListLength++;
}
//If nodes do not have the same last node
// they must not intersect
if (runner != secondRunner)
{
return(null);
}
var offset = firsListLength - secondListLength;
offset = offset < 0 ? (offset * -1) : offset;
//reset runners
runner = firstList;
secondRunner = secondList;
if (firsListLength > secondListLength)
{
runner = firstList.GetNodeXPositionsFromCurrent(offset);
secondRunner = secondList;
}
else if (secondListLength > firsListLength)
{
runner = firstList;
secondRunner = secondList.GetNodeXPositionsFromCurrent(offset);
}
while (runner.nextNode != null || secondRunner.nextNode != null)
{
if (runner == secondRunner)
{
return(runner);
}
runner = runner.nextNode;
secondRunner = secondRunner.nextNode;
}
return(null);
}
private static void RotateLeft(CustomLinkedList <int> linkedList, int position)
{
if (position == 0)
{
return;
}
// Let us understand the below
// code for example k = 4
// and list = 10->20->30->40->50->60.
LinkedNode <int> current = linkedList.Head;
// current will either point to kth
// or NULL after this loop. current
// will point to node 40 in the above example
int count = 1;
while (count < position && current.Next != null)
{
current = current.Next;
count++;
}
// If current is NULL, k is greater than
// or equal to count of nodes in linked list.
// Don't change the list in this case
if (current == null)
{
return;
}
// current points to kth node.
// Store it in a variable.
// kthNode points to node
// 40 in the above example
LinkedNode <int> kthNode = current;
// current will point to
// last node after this loop
// current will point to
// node 60 in the above example
while (current.Next != null)
{
current = current.Next;
}
// Change next of last node to previous head
// Next of 60 is now changed to node 10
current.Next = linkedList.Head;
// Change head to (k+1)th node
// head is now changed to node 50
linkedList.Head = kthNode.Next;
// change next of kth node to null
kthNode.Next = null;
}
public LRUCache(int capacity)
{
this.size = 0;
this.capacity = capacity;
head = new LinkedNode();
tail = new LinkedNode();
head.next = tail;
tail.prev = head;
}
//always add new node right after the head
public void addNode(LinkedNode node)
{
LinkedNode temp = head.next;
head.next = node;
node.prev = head;
node.next = temp;
temp.prev = node;
}
public ContainerRegistration(LinkedNode <Type, object> validators, Type mappedTo, LifetimeManager lifetimeManager, InjectionMember[] injectionMembers = null)
{
Type = mappedTo;
Key = typeof(LifetimeManager);
Value = lifetimeManager;
LifetimeManager.InUse = true;
InjectionMembers = injectionMembers;
Next = validators;
}
public static void deleteNode(LinkedNode ln)
{
if (ln.Next == null || ln == null)
{
return;
}
ln.Data = ln.Next.Data;
ln.Next = ln.Next.Next;
}
/// <summary>
/// <para>Expected Runtime: 0(1)</para>
/// </summary>
/// <param name="value"></param>
private void ReplaceMinimumNode(T value)
{
LinkedNode <T> newMinimumNode = new LinkedNode <T>(value);
this.isCachedMinimumValid = false;
newMinimumNode.InsertBetween(null, this.headNodeOfList);
this.headNodeOfList = newMinimumNode;
}
public void addFirst(T item)
{
LinkedNode temp = new LinkedNode();
temp.value = item;
temp.next = head.next;
count++;
head.next = temp;
}
private void removeNode(LinkedNode node)
{
LinkedNode before = node.back;
LinkedNode after = node.next;
before.next = after;
after.back = before;
SIZE--;
}
public int Count()
{
if (LinkedNode == null)
{
return(1);
}
return(1 + LinkedNode.Count());
}
public List <int> Go()
{
SinglyLinkedListImpl imp = new SinglyLinkedListImpl();
ILinkedNode <int> root = new LinkedNode <int>();
imp.FillLinkedList(root);
Sort(root);
return(new List <int>());
}
/// <summary>
/// <para>Push <param name="value">value</param> onto the stack.</para>
/// <para>Expected Runtime: O(1)</para>
/// </summary>
public void Push(T value)
{
LinkedNode <T> newNode = new LinkedNode <T>(value);
newNode.Next = this.headNodeOfStack;
this.headNodeOfStack = newNode;
this.Count++;
}
public static void RunTests()
{
LinkedNode l = new LinkedNode(1, new LinkedNode(2, new LinkedNode(3, new LinkedNode(4, null))));
Console.WriteLine(Print(l));
Console.WriteLine(DeleteKth(l, 2).data);
Console.WriteLine(Print(l));
Console.WriteLine(DeleteKth(l, 1).data);
Console.WriteLine(Print(l));
}
public static void deleteNode(LinkedNode ln)
{
if (ln.Next==null || ln ==null)
{
return;
}
ln.Data = ln.Next.Data;
ln.Next = ln.Next.Next;
}
public void InsertBetween(LinkedNode <T> previous, LinkedNode <T> next)
{
if (previous != null)
{
previous.Next = this;
}
this.Next = next;
}
private LinkedNode <T> GetByIndex(LinkedNode <T> temp, int index)
{
result = temp;
if (index != 0) // go to the next until index >0
{
GetByIndex(temp.Next, index - 1);
}
return(result);
}
public static LinkedNode <int> Prob_2_4_Partition_v1(LinkedNode <int> head, int partitionNum)
{
LinkedNode <int> prePivot = null;
var runner = head;
//Needed if first node is equal or grater than partition.
//We swipe the first node smaller to the parititon to the head.
if (runner.data >= partitionNum)
{
Console.WriteLine($"First node {runner.data} is equal or greater than partition {partitionNum}");
while (runner.nextNode != null && prePivot == null)
{
Console.WriteLine($"Comparing next node {runner.nextNode.data} to {partitionNum}");
//If we find a smaller node, we set it as the prepivot
if (runner.nextNode.data < partitionNum)
{
var nodeToMoveBack = runner.nextNode;
Console.WriteLine($"Next node {nodeToMoveBack.data} is smaller than parition. Moving");
runner.nextNode = runner.nextNode.nextNode;
nodeToMoveBack.nextNode = head;
head = nodeToMoveBack;
prePivot = nodeToMoveBack;
Console.WriteLine($"New head {head.data}");
}
else
{
runner = runner.nextNode;
}
}
}
//Continue with runner
while (runner.nextNode != null)
{
if (prePivot == null && runner.nextNode.data >= partitionNum)
{
prePivot = runner;
}
else if (prePivot != null && runner.nextNode.data < partitionNum)
{
var nodeToMoveBack = runner.nextNode;
runner.nextNode = runner.nextNode.nextNode;
nodeToMoveBack.nextNode = prePivot.nextNode;
prePivot.nextNode = nodeToMoveBack;
}
else
{
runner = runner.nextNode;
}
}
return(head);
}
static void Main(string[] args)
{
LinkedListGenerator llg = new LinkedListGenerator();
List <int> _linkedList = new List <int>();
LinkedNode linkNode = llg.OneWayLiked(10, ref _linkedList);
Metods _metods = new Metods();
_metods.ReverseList(linkNode);
}
private static string Print(LinkedNode p)
{
string o = p.data.ToString();
while (p.next != null)
{
o += " -> " + p.next.data;
p = p.next;
}
return o;
}
public static void RunTests()
{
LinkedNode l = new LinkedNode(1, new LinkedNode(2, new LinkedNode(3, new LinkedNode(4, null))));
Console.WriteLine(Print(l));
Console.WriteLine(DeleteKth(l, 2).data);
Console.WriteLine(Print(l));
Console.WriteLine(DeleteKth(l, 1).data);
Console.WriteLine(Print(l));
}
public void ListNodes(LinkedNode head, ref List <int> list)
{
if (head.next == null)
{
return;
}
list.Add(head.val);
ListNodes(head.next, ref list);
}
public static void Prob_2_3_DeleteMiddleNode_v1 <T>(LinkedNode <T> middleNode)
{
var nextNode = middleNode.nextNode;
if (nextNode != null)
{
middleNode.data = nextNode.data;
middleNode.nextNode = nextNode.nextNode;
}
}
public static void Output()
{
LinkedNode node = myList.getFirst();
while (node != null)
{
Console.WriteLine("" + node.n);
node = node.next;
}
}
/// <summary>
/// Implementation of ILinkedeNodeConfig
/// </summary>
/// <param name="linkedNode">The linked node</param>
/// <returns>The created factory</returns>
BaseNodeFactory ILinkedNodeConfig.CreateFactory(BaseNodeFactory linkedNode)
{
NetGraphContainerNodeFactory ret = (NetGraphContainerNodeFactory)LinkedNode.CreateFactory();
NetGraphContainerNodeFactory link = (NetGraphContainerNodeFactory)linkedNode;
ret.LinkedNode = link;
link.LinkedNode = ret;
return(ret);
}
public void DisplayAll()
{
LinkedNode temp = Num;
do
{
Console.WriteLine(temp.Number);
temp = temp.Next;
} while (temp != null);
}
/// <summary>
/// <para>Sets all cached values to null and all booleans related
/// to count, min and max to false.</para>
/// </summary>
protected void InvalidateAllCaches()
{
this.isCachedMinimumValid = false;
this.cachedMinimum = null;
this.isCachedMaximumValid = false;
this.cachedMaximum = null;
this.isCachedCountValid = false;
}
public static LinkedNode AddFirst(int value)
{
LinkedNode ln = new LinkedNode();
ln.Value = value;
ln.Previous = ln;
ln.Next = ln;
return(ln);
}
private LinkedNode nodeAt(int index)
{
LinkedNode node = first;
for (int i = -1; i < index; i++)
{
node = node.next;
}
return(node);
}
public void printList()
{
Console.Write("List ");
while (this.head != null)
{
Console.Write("{0} ", this.head.value);
this.head = this.head.next;
}
Console.WriteLine("");
}
public static void RunTests()
{
LinkedNode tail = new LinkedNode(6, new LinkedNode(7, new LinkedNode(8, new LinkedNode(9, null))));
LinkedNode a = new LinkedNode(1, new LinkedNode(3, new LinkedNode(10, tail)));
LinkedNode b = new LinkedNode(2, new LinkedNode(4, new LinkedNode(5, tail)));
Console.WriteLine(Print(CommonNode(a, b)));
a = new LinkedNode(1, new LinkedNode(3, new LinkedNode(10, null)));
b = new LinkedNode(2, new LinkedNode(4, new LinkedNode(5, null)));
Console.WriteLine(Print(CommonNode(a, b)));
}
public static void RunTests()
{
LinkedNode a = new LinkedNode(3, new LinkedNode(5, new LinkedNode(7, null)));
Console.WriteLine("a = " + Print(a));
LinkedNode b = new LinkedNode(1, new LinkedNode(2, new LinkedNode(5, new LinkedNode(8, null))));
Console.WriteLine("b = " + Print(b));
LinkedNode c = Reverse(a);
Console.WriteLine("c = " + Print(c));
c = Reverse(b);
Console.WriteLine("c = " + Print(c));
Console.WriteLine("c = " + Print(Reverse(new LinkedNode(4, null))));
}
public static LinkedNode getInst()
{
LinkedNode l1 = new LinkedNode(1);
LinkedNode l2 = new LinkedNode(2);
LinkedNode l3 = new LinkedNode(3);
LinkedNode l4 = new LinkedNode(4);
LinkedNode l5 = new LinkedNode(5);
l1.Next = l2;
l2.Next = l3;
l3.Next = l4;
l4.Next = l5;
return l1;
}
public static void reverse(LinkedNode start_node)
{
LinkedNode current_node = start_node;
LinkedNode last_node = null;
LinkedNode next_node = start_node.Next;
while (next_node != null)
{
current_node.Next = last_node;
last_node = current_node;
current_node = next_node;
next_node = next_node.Next;
}
}
public static bool verifyPalindrome(LinkedNode head)
{
int length = 0;
LinkedNode loop = head;
while (loop != null)
{
loop = loop.Next;
length++;
}
Result r = verifyPalindrome(head, length);
return r.quilify;
}
public static int getNthToLastRecursiveEx2(LinkedNode head, int n)
{
if (head == null)
{
return 0;
}
int i = getNthToLastRecursiveEx2(head.Next, n) + 1;
if (i == n)
{
result = head;
}
return i;
}
public static LinkedNode getNthToLastIterate(LinkedNode head, int n)
{
LinkedNode ToTarget = head;
LinkedNode ToEnd = head;
for (int i = 0; i < n; i++)
{
ToEnd = ToEnd.Next;
}
while (ToEnd!=null)
{
ToTarget = ToTarget.Next;
ToEnd = ToEnd.Next;
}
return ToTarget;
}
public static void reverseRecursive(LinkedNode current_node, LinkedNode next_node = null, LinkedNode last_node = null)
{
if (next_node == null)
{
if (last_node == null)
{
next_node = current_node.Next;
}
else
{
return;
}
}
current_node.Next = last_node;
reverseRecursive(next_node, next_node.Next, current_node);
}
public static void RunTests()
{
LinkedNode a = new LinkedNode(3, new LinkedNode(5, new LinkedNode(7, null)));
Console.WriteLine("a = " + Print(a));
LinkedNode b = new LinkedNode(1, new LinkedNode(2, new LinkedNode(5, new LinkedNode(8, null))));
Console.WriteLine("b = " + Print(b));
LinkedNode c = Merge(a, b);
Console.WriteLine("c = " + Print(c));
DoublyLinkedNode d = new DoublyLinkedNode(3, new DoublyLinkedNode(5, new DoublyLinkedNode(7, null)));
Console.WriteLine("d = " + Print(d));
DoublyLinkedNode e = new DoublyLinkedNode(1, new DoublyLinkedNode(2, new DoublyLinkedNode(5, new DoublyLinkedNode(8, null))));
Console.WriteLine("e = " + Print(e));
DoublyLinkedNode f = Merge(d, e);
Console.WriteLine("f = " + Print(f));
}
public static void RunTests()
{
LinkedNode a = new LinkedNode(3, new LinkedNode(5, new LinkedNode(7, null)));
Console.WriteLine("a = " + Print(a));
Console.WriteLine(Print(TestCycle(a)));
// 1 -> 2 -> 5 -> 8 -> 2 -> 5 -> ... looping
LinkedNode d = new LinkedNode(2, null);
LinkedNode c = new LinkedNode(8, null);
d.next = new LinkedNode(5, c);
LinkedNode b = new LinkedNode(1, d);
c.next = d;
Console.WriteLine(TestCycle(b).data);
Console.WriteLine(Print(TestCycle(new LinkedNode(1, null))));
}
public static LinkedNode partitionLinkedlistEx(LinkedNode head, double x)
{
if (head == null)
{
return null;
}
LinkedNode PivotSmall = null, PivotLarge = null;
LinkedNode loop = head, next =head.Next;
while (next != null)
{
next = loop.Next;
if (loop.Data <= x)
{
if (PivotSmall == null)
{
loop.Next = null;
PivotSmall = loop;
}
else
{
loop.Next = PivotSmall;
PivotSmall = loop;
}
}
else
{
if (PivotLarge == null)
{
loop.Next = null;
PivotLarge = loop;
}
else
{
loop.Next = PivotLarge;
PivotLarge = loop;
}
}
loop = next;
}
loop = PivotSmall;
for (; loop.Next != null; loop = loop.Next) ;
loop.Next = PivotLarge;
return PivotSmall;
}
public static LinkedNode getNthToLastRecursive(LinkedNode head, int n)
{
if (head == null)
{
count = 0;
return null;
}
LinkedNode node = getNthToLastRecursive(head.Next, n);
count++;
if (count == n)
{
return head;
}
return node;
}
private static LinkedNode Reverse(LinkedNode l)
{
if (l.next == null)
return l;
LinkedNode c = l.next, n = l.next.next, t = null;
l.next = null;
c.next = l;
while (n != null)
{
t = n.next;
n.next = c;
c = n;
n = t;
}
return c;
}
public static void RunTests()
{
LinkedNode l = new LinkedNode(0, new LinkedNode(1, new LinkedNode(2, new LinkedNode(3, new LinkedNode(4, null)))));
EvenOddMerge(l);
Console.WriteLine(Print(l));
l = new LinkedNode(0, null);
EvenOddMerge(l);
Console.WriteLine(Print(l));
l = new LinkedNode(0, new LinkedNode(1, null));
EvenOddMerge(l);
Console.WriteLine(Print(l));
l = new LinkedNode(0, new LinkedNode(1, new LinkedNode(2, null)));
EvenOddMerge(l);
Console.WriteLine(Print(l));
}
public static LinkedNode DeleteKth(LinkedNode l, int k)
{
LinkedNode result = null;
LinkedNode t = l;
while (k >= 0 && t != null)
{
t = t.next;
--k;
}
while (t != null)
{
t = t.next;
l = l.next;
}
result = l.next;
l.next = l.next.next;
return result;
}
public static LinkedNode partitionLinkedlist(LinkedNode head, double x)
{
if (head == null)
{
return null;
}
LinkedNode PivotSmallStart = null, PivotSmallEnd = null, PivotLargeStart = null, PivotLargeEnd = null;
LinkedNode loop = head;
while (loop != null)
{
//note: you cannot interate from start
if (loop.Data <= x)
{
if (PivotSmallStart == null)
{
PivotSmallEnd = loop;
PivotSmallStart = PivotSmallEnd;
}
else
{
PivotSmallEnd.Next = loop;
PivotSmallEnd = loop;
}
}
else
{
if (PivotLargeStart == null)
{
PivotLargeEnd = loop;
PivotLargeStart = PivotLargeEnd;
}
else
{
PivotLargeEnd.Next = loop;
PivotLargeEnd = loop;
}
}
loop = loop.Next;
}
PivotSmallEnd.Next = PivotLargeStart;
PivotLargeEnd.Next = null;
return PivotSmallStart;
}
public static LinkedNode addition(LinkedNode ln1, LinkedNode ln2)
{
double loop = 0;
LinkedNode head = null, end = null;
while (ln1 != null || ln2 != null)
{
double data1 = 0, data2 = 0;
if (ln1 == null)
{
data1 = 0;
}
else
{
data1 = ln1.Data;
ln1 = ln1.Next;
}
if (ln2 == null)
{
data2 = 0;
}
else
{
data2 = ln2.Data;
ln2 = ln2.Next;
}
double data = (data1 + data2 + loop) % 10;
loop = (int)(data1 + data2 + loop) / 10;
if (head == null)
{
head = new LinkedNode(data);
end = head;
}
else
{
LinkedNode ln = new LinkedNode(data);
end.Next = ln;
end = ln;
}
}
return head;
}
public static void EvenOddMerge(LinkedNode l)
{
LinkedNode last = l;
while (last.next != null)
last = last.next;
LinkedNode t = last;
LinkedNode h = l;
while (h != last && h != null)
{
LinkedNode tmp = h.next;
if (tmp.next != null)
{
h.next = tmp.next;
t.next = tmp;
tmp.next = null;
}
t = t.next;
h = h.next;
}
}
private static LinkedNode TestCycle(LinkedNode l)
{
if (l.next == null)
return null;
LinkedNode a = l, b = l;
while (b != null && b.next != null)
{
a = a.next;
b = b.next.next;
if (a == b)
{
b = l;
while (a != b)
{
a = a.next;
b = b.next;
}
return a;
}
}
return null;
}
