public Treenode DeleteNode_BST(int key)
{
if (this == null || this.ValidateBST() == false)
{
return(this);
}
if (key > this.data)
{
this.right = this.right.DeleteNode_BST(key);
}
else if (key < this.data)
{
this.left = this.left.DeleteNode_BST(key);
}
else
{
if (this.left == null)
{
return(this.right);
}
if (this.right == null)
{
return(this.left);
}
this.data = this.left.FindBiggestOnLeft();
this.left = this.left.DeleteNode_BST(this.data);
}
return(this);
}
///////////////////////////////Trees/////////////////////////////////////////
//↓Find Path: find the path between root and a given node in binary tree, empty list if doesn't exist
static bool FindPath(Treenode root, int val, List <Treenode> path)
{
if (root == null)
{
return(false);
}
path.Add(root);
if (root.data == val)
{
return(true);
}
//if (root.left != null)
if (FindPath(root.left, val, path))
{
return(true);
}
//if (root.right != null)
if (FindPath(root.right, val, path))
{
return(true);
}
path.RemoveAt(path.Count - 1);
return(false);
}
/// <summary>
/// Returns hegiht of a given Treenode.
/// </summary>
/// <param name="root"></param>
/// <returns></returns>
public static int Height(Treenode root)
{
if (root == null)
{
return(0);
}
return(Math.Max(Height(root.left), Height(root.right)) + 1);
}
private static int FindBiggest(Treenode root)
{
if (root.right == null)
{
return(root.data);
}
return(FindBiggest(root.right));
}
private void GenerateList(Treenode root)
{
if (root == null)
{
return;
}
GenerateList(root.left);
list.Add(root.data);
GenerateList(root.right);
}
// Path Sum2
static List <List <int> > PathSum2(Treenode root, int sum)
{
if (root == null)
{
return(new List <List <int> >());
}
List <List <int> > total_path = new List <List <int> >();
PathSum2(root, sum, new List <int>(), total_path);
return(total_path);
}
static bool ValidateBST(Treenode root, int minValue, int maxValue)
{
if (root == null)
{
return(true);
}
if (root.data >= maxValue || root.data < minValue)
{
return(false);
}
return(ValidateBST(root.left, minValue, root.data) && ValidateBST(root.right, root.data, maxValue));
}
//////////////////////////////////////////////////////////////////////////////////////////////
static int minimumdepth(Treenode root)
{
if (root == null)
{
return(0);
}
if (root.left == null && root.right == null)
{
return(1);
}
return(Math.Min(minimumdepth(root.left), minimumdepth(root.right)) + 1);
}
public void PrintComplete(Treenode broot, PerfectTreeNode proot) //Print BinaryTree elements with corresponding spots from complete tree
{
if (broot == null)
{
return;
}
//proot.value = broot.data.ToString();
Console.SetCursorPosition(proot.col, proot.row);
Console.Write(broot.data);
PrintComplete(broot.left, proot.right);
PrintComplete(broot.right, proot.right);
}
// Decodes your encoded data to tree.
public Treenode deserialize(string data)
{
if (data == null)
{
return(null);
}
string[] nodes = data.Split(',');
Treenode root = new Treenode(int.Parse(nodes[0]));
Queue <Treenode> q = new Queue <Treenode>();
q.Enqueue(root);
int i = 1;
while (q.Any())
{
Treenode curr = q.Dequeue();
if (i < nodes.Length) //check left
{
string left = nodes[i];
if (left != "n")
{
Treenode l = new Treenode(int.Parse(left));
curr.left = l;
q.Enqueue(l);
}
i++;
}
if (i < nodes.Length) //check right
{
string right = nodes[i];
if (right != "n")
{
Treenode r = new Treenode(int.Parse(right));
curr.right = r;
q.Enqueue(r);
}
i++;
}
}
return(root);
}
static bool PathSum1(Treenode root, int sum, int cur_sum)
{
if (root == null)
{
return(false);
}
if (root.left == null && root.right == null)
{
cur_sum += root.data;
if (cur_sum == sum)
{
return(true);
}
}
return(PathSum1(root.left, sum, cur_sum + root.data) || PathSum1(root.right, sum, cur_sum + root.data));
}
static void PathSum2(Treenode root, int sum, List <int> cur_path, List <List <int> > total_path)
{
cur_path.Add(root.data);
if (root.left == null && root.right == null)
{
if (sum == root.data)
{
total_path.Add(cur_path);
}
}
if (root.left != null)
{
PathSum2(root.left, sum - root.data, cur_path, total_path);
}
if (root.right != null)
{
PathSum2(root.right, sum - root.data, cur_path, total_path);
}
cur_path.Remove(cur_path.Count - 1);
}
/////////////////////////////////Remove a node from BST/////////////////////////////////////////////
static Treenode DeleteNode(Treenode root, int key) //removes the given node and return the new head
{
if (root == null)
{
return(null);
}
if (key > root.data)
{
root.right = DeleteNode(root.right, key);
}
else if (key < root.data)
{
root.left = DeleteNode(root.left, key);
}
else
{
if (root.left == null)
{
return(root.right);
}
else if (root.right == null)
{
return(root.left);
}
//if the code reaches here, it means the root has two children!
//we can either find biggest node of left or smallest node on right, and upadte root's value with that and remove it.
//here we do it with left's biggest
root.data = FindBiggest(root.left);
//recursively remove the biggest node on left
root.left = DeleteNode(root.left, root.data);
}
return(root);
}
public BSTIterator(Treenode root)
{
list = new List <int>();
GenerateList(root);
next = 0;
}
// Encodes a tree to a single string.
public string serialize(Treenode root)
{
if (root == null)
{
return(null);
}
int height = Height(root);
Queue <Treenode> q = new Queue <Treenode>();
q.Enqueue(root);
int level = 1;
List <string> nodes = new List <string>();
while (q.Any()) //while q is not empty
{
int count = q.Count; //count of elements in this new level
while (count > 0)
{
Treenode curr = q.Dequeue();
if (curr == null)
{
nodes.Add("n");
}
else
{
nodes.Add(curr.data.ToString());
if (curr.left == null)
{
if (level < height)
{
q.Enqueue(null);
}
}
else
{
q.Enqueue(curr.left);
}
if (curr.right == null)
{
if (level < height)
{
q.Enqueue(null);
}
}
else
{
q.Enqueue(curr.right);
}
}
count--;
}
level++;
}
while (nodes[nodes.Count - 1] == "n")
{
nodes.RemoveAt(nodes.Count - 1);
}
string result = "";
for (int i = 0; i < nodes.Count; i++)
{
result += nodes[i];
if (i != nodes.Count - 1)
{
result += ",";
}
}
return(result);
}
public int CompareTo(Treenode obj)
{
return(data.CompareTo(obj.data));
}
////////////////// Path Sums /////////////////////
// Path Sum 1 (https://leetcode.com/problems/path-sum/)
static bool PathSum1(Treenode root, int sum)
{
return(PathSum1(root, sum, 0));
}
/////////////////////////////////////////////////////////////////////////////////
static bool ValidateBST(Treenode root)
{
return(ValidateBST(root, int.MinValue, int.MaxValue));
}
public Treenode(int d)
{
data = d;
left = null;
right = null;
}
public int Height()
{
return(Treenode.Height(this));
}