public bool FindTreeNode(double val, BinaryTreeNode node = null)
{
if (node == null)
{
node = root;
}
if (node.Data.Equals(val))
{
return true;
}
if (val <= node.Data)
{
if (node.LeftNode != null)
{
return FindTreeNode(val, node.LeftNode);
}
}
else if (val > node.Data)
{
if (node.RightNode != null)
{
return FindTreeNode(val, node.RightNode);
}
}
return false;
}
public List<BinaryTreeNode> total(int s, int e)
{
List<BinaryTreeNode> list = new List<BinaryTreeNode>();
if (s > e)
{
list.Add(null);
return list;
}else if (s == e)
{
list.Add(new BinaryTreeNode(s));
return list;
}
for (int i = s; i <= e; i++)
{
List<BinaryTreeNode> lefts = total(s, i - 1), rights = total(i + 1, e);
foreach (BinaryTreeNode left in lefts)
{
foreach (BinaryTreeNode right in rights)
{
BinaryTreeNode node = new BinaryTreeNode(i);
node.LeftNode = left;
node.RightNode = right;
list.Add(node);
}
}
}
return list;
}
public void AddTreeNode(double val, BinaryTreeNode node = null)
{
if (node == null)
{
node = root;
}
if (val <= node.Data)
{
if (node.LeftNode == null)
{
BinaryTreeNode tn = new BinaryTreeNode(val);
node.LeftNode = tn;
}
else
{
AddTreeNode(val, node.LeftNode);
}
}
else if (val > node.Data)
{
if (node.RightNode == null)
{
BinaryTreeNode tn = new BinaryTreeNode(val);
node.RightNode = tn;
}
else
{
AddTreeNode(val, node.RightNode);
}
}
}
public TreeAndGraph.BinaryTreeNode sortedArrayToBST(double[] num, int s , int e)
{
if (e < s)
{
return null;
}
int m = s + (e - s)/2;
double val = num[m];
TreeAndGraph.BinaryTreeNode root = new BinaryTreeNode(val);
root.LeftNode = sortedArrayToBST(num, s, m - 1);
root.RightNode = sortedArrayToBST(num, m + 1, e);
return root;
}
private BinaryTreeNode DFS(int s, int e)
{
if (looper == null || s > e)
{
return null;
}
int m = s + (e - s) / 2;
BinaryTreeNode left = DFS( s, m - 1);
BinaryTreeNode root = new BinaryTreeNode(looper.Data);
looper = looper.Next;
root.LeftNode = left;
root.RightNode = DFS( m + 1, e);
return root;
}
public TreeAndGraph.BinaryTreeNode buildTree(int[] preorder, int[] inorder, int p_s, int p_e, int i_s, int i_e)
{
if (i_s > i_e || p_s > p_e)
{
return null;
}
int pivot = preorder[p_s];
int i = 0;
for (; i < inorder.Length; i++)
{
if (inorder[i] == pivot)
{
break;
}
}
TreeAndGraph.BinaryTreeNode root = new BinaryTreeNode(pivot);
root.LeftNode = buildTree(preorder, inorder, p_s + 1, p_s + i - i_s, i_s, i - 1);
root.RightNode = buildTree(preorder, inorder, p_s + i - i_s+1, p_e, i + 1, i_e);
return root;
}
public TreeAndGraph.BinaryTreeNode buildTree(int[] inorder, int[] postorder, int i_s, int i_e, int p_s, int p_e)
{
if (i_s > i_e || p_s > p_e)
{
return null;
}
int pivot = postorder[p_e];
int i = 0;
for (; i < inorder.Length; i++)
{
if (inorder[i] == pivot)
{
break;
}
}
TreeAndGraph.BinaryTreeNode head = new BinaryTreeNode(pivot);
head.LeftNode = buildTree(inorder, postorder, i_s, i - 1, p_s, p_s + i - i_s - 1);
head.RightNode = buildTree(inorder, postorder, i + 1, i_e, p_s + i - i_s , p_e - 1);
return head;
}
private BinaryTreeNode getParent(BinaryTreeNode child)
{
BinaryTreeNode node = root;
double data = child.Data;
while (node.LeftNode != child && node.RightNode != child)
{
if (node.Data <= child.Data)
{
node = node.RightNode;
}
else
{
node = node.LeftNode;
}
}
return node;
}
public BinarySearchTree(double data)
{
root = new BinaryTreeNode(data);
}
private void deleteNode(BinaryTreeNode node)
{
BinaryTreeNode replace = node;
BinaryTreeNode pending = null;
if (node.LeftNode != null)
{
node = node.LeftNode;
if (node.RightNode != null)
{
pending = node.RightNode;
while (pending.RightNode != null)
{
pending = node.RightNode;
}
node.RightNode = pending.LeftNode;
}
else
{
pending = node;
replace.LeftNode = pending.LeftNode;
}
}
else if (node.RightNode != null)
{
node = node.RightNode;
if (node.LeftNode != null)
{
pending = node.LeftNode;
while (pending.LeftNode != null)
{
pending = node.LeftNode;
}
node.LeftNode = pending.RightNode;
}
else
{
pending = node;
replace.RightNode = pending.RightNode;
}
}
else if (node.LeftNode == null && node.RightNode == null)
{
replace = getParent(node);
if (replace.LeftNode == node)
{
replace.LeftNode = null;
}
else if (replace.RightNode == node)
{
replace.RightNode = null;
}
}
if (pending != null)
{
replace.Data = pending.Data;
}
}
public BinaryTreeNode FindTreeNodeX(double val, BinaryTreeNode node = null)
{
if (node == null)
{
node = root;
}
if (node.Data.Equals(val))
{
return node;
}
if (val <= node.Data)
{
if (node.LeftNode != null)
{
return FindTreeNodeX(val, node.LeftNode);
}
}
else if (val > node.Data)
{
if (node.RightNode != null)
{
return FindTreeNodeX(val, node.RightNode);
}
}
return null;
}
