यहाँ c # (.net) (दोनों के ऊपर चर्चा) संदर्भ के लिए में दो दृष्टिकोण हैं:
द्विआधारी पेड़ (ओ (एन) - के रूप में प्रत्येक नोड अधिक से अधिक का दौरा किया है) में एलसीए पाने की पुनरावर्ती संस्करण (समाधान के मुख्य बिंदुओं एलसीए है (क) जहां दोनों तत्वों (उपतरू के दोनों ओर रहते बाईं द्विआधारी पेड़ में केवल नोड और दाएं) एलसीए है। ख () और यह भी कोई फर्क नहीं पड़ता जो नोड वर्तमान दोनों ओर है - शुरू में मैं उस जानकारी रखने की कोशिश की, और स्पष्ट रूप से पुनरावर्ती क्रिया इतनी भ्रमित हो जाते हैं एक बार मैं यह महसूस किया है, यह बहुत ही सुंदर बन गया।।
दोनों नोड्स (ओ (एन)) सर्च कर रहे हैं, और पथ (का ट्रैक रखने के लिए अतिरिक्त जगह का उपयोग करता है - तो, # 1 शायद बेहतर है भी विचार था कि यदि द्विआधारी पेड़ में अच्छी तरह से तो अतिरिक्त स्मृति की खपत सिर्फ में होगा संतुलित है अंतरिक्ष शायद नगण्य है हे (लॉग (एन))।
ताकि रास्तों तुलना की जाती है (essentailly स्वीकार किए जाते हैं जवाब देने के लिए इसी तरह की है - लेकिन पथ सूचक नोड संभालने करके की जाती है द्विआधारी पेड़ नोड में मौजूद नहीं है)
बस पूरा होने (के लिए सवाल करने के लिए संबंधित नहीं ), एलसीए BST में (ओ (लॉग (एन))
टेस्ट
पुनरावर्ती:
private BinaryTreeNode LeastCommonAncestorUsingRecursion(BinaryTreeNode treeNode,
int e1, int e2)
{
Debug.Assert(e1 != e2);
if(treeNode == null)
{
return null;
}
if((treeNode.Element == e1)
|| (treeNode.Element == e2))
{
//we don't care which element is present (e1 or e2), we just need to check
//if one of them is there
return treeNode;
}
var nLeft = this.LeastCommonAncestorUsingRecursion(treeNode.Left, e1, e2);
var nRight = this.LeastCommonAncestorUsingRecursion(treeNode.Right, e1, e2);
if(nLeft != null && nRight != null)
{
//note that this condition will be true only at least common ancestor
return treeNode;
}
else if(nLeft != null)
{
return nLeft;
}
else if(nRight != null)
{
return nRight;
}
return null;
}
जहां निजी पुनरावर्ती संस्करण ऊपर निम्नलिखित सार्वजनिक विधि से शुरू हो जाती है:
public BinaryTreeNode LeastCommonAncestorUsingRecursion(int e1, int e2)
{
var n = this.FindNode(this._root, e1);
if(null == n)
{
throw new Exception("Element not found: " + e1);
}
if (e1 == e2)
{
return n;
}
n = this.FindNode(this._root, e2);
if (null == n)
{
throw new Exception("Element not found: " + e2);
}
var node = this.LeastCommonAncestorUsingRecursion(this._root, e1, e2);
if (null == node)
{
throw new Exception(string.Format("Least common ancenstor not found for the given elements: {0},{1}", e1, e2));
}
return node;
}
दोनों नोड्स के रास्तों पर नज़र रखने के द्वारा समाधान:
public BinaryTreeNode LeastCommonAncestorUsingPaths(int e1, int e2)
{
var path1 = new List<BinaryTreeNode>();
var node1 = this.FindNodeAndPath(this._root, e1, path1);
if(node1 == null)
{
throw new Exception(string.Format("Element {0} is not found", e1));
}
if(e1 == e2)
{
return node1;
}
List<BinaryTreeNode> path2 = new List<BinaryTreeNode>();
var node2 = this.FindNodeAndPath(this._root, e2, path2);
if (node1 == null)
{
throw new Exception(string.Format("Element {0} is not found", e2));
}
BinaryTreeNode lca = null;
Debug.Assert(path1[0] == this._root);
Debug.Assert(path2[0] == this._root);
int i = 0;
while((i < path1.Count)
&& (i < path2.Count)
&& (path2[i] == path1[i]))
{
lca = path1[i];
i++;
}
Debug.Assert(null != lca);
return lca;
}
जहां FindNodeAndPath के रूप में परिभाषित किया गया है
private BinaryTreeNode FindNodeAndPath(BinaryTreeNode node, int e, List<BinaryTreeNode> path)
{
if(node == null)
{
return null;
}
if(node.Element == e)
{
path.Add(node);
return node;
}
var n = this.FindNodeAndPath(node.Left, e, path);
if(n == null)
{
n = this.FindNodeAndPath(node.Right, e, path);
}
if(n != null)
{
path.Insert(0, node);
return n;
}
return null;
}
BST (एलसीए) - संबंधित नहीं है (बस संदर्भ के लिए पूरा करने के लिए)
public BinaryTreeNode BstLeastCommonAncestor(int e1, int e2)
{
//ensure both elements are there in the bst
var n1 = this.BstFind(e1, throwIfNotFound: true);
if(e1 == e2)
{
return n1;
}
this.BstFind(e2, throwIfNotFound: true);
BinaryTreeNode leastCommonAcncestor = this._root;
var iterativeNode = this._root;
while(iterativeNode != null)
{
if((iterativeNode.Element > e1 ) && (iterativeNode.Element > e2))
{
iterativeNode = iterativeNode.Left;
}
else if((iterativeNode.Element < e1) && (iterativeNode.Element < e2))
{
iterativeNode = iterativeNode.Right;
}
else
{
//i.e; either iterative node is equal to e1 or e2 or in between e1 and e2
return iterativeNode;
}
}
//control will never come here
return leastCommonAcncestor;
}
यूनिट टेस्ट
[TestMethod]
public void LeastCommonAncestorTests()
{
int[] a = { 13, 2, 18, 1, 5, 17, 20, 3, 6, 16, 21, 4, 14, 15, 25, 22, 24 };
int[] b = { 13, 13, 13, 2, 13, 18, 13, 5, 13, 18, 13, 13, 14, 18, 25, 22};
BinarySearchTree bst = new BinarySearchTree();
foreach (int e in a)
{
bst.Add(e);
bst.Delete(e);
bst.Add(e);
}
for(int i = 0; i < b.Length; i++)
{
var n = bst.BstLeastCommonAncestor(a[i], a[i + 1]);
Assert.IsTrue(n.Element == b[i]);
var n1 = bst.LeastCommonAncestorUsingPaths(a[i], a[i + 1]);
Assert.IsTrue(n1.Element == b[i]);
Assert.IsTrue(n == n1);
var n2 = bst.LeastCommonAncestorUsingRecursion(a[i], a[i + 1]);
Assert.IsTrue(n2.Element == b[i]);
Assert.IsTrue(n2 == n1);
Assert.IsTrue(n2 == n);
}
}
