public void TestIndividualOperations()
{
var left = new NumberNode(27);
var right = new NumberNode(14);
var node = new BinNode(left, TokenType.PLUS, right);
var actual = new Interpreter().visit(node);
var expected = new Number(41);
expected.ShouldDeepEqual(actual);
node = new BinNode(left, TokenType.MINUS, right);
actual = new Interpreter().visit(node);
expected = new Number(13);
expected.ShouldDeepEqual(actual);
node = new BinNode(left, TokenType.MULTIPLY, right);
actual = new Interpreter().visit(node);
expected = new Number(378);
expected.ShouldDeepEqual(actual);
node = new BinNode(left, TokenType.DIVIDE, right);
actual = new Interpreter().visit(node);
expected = new Number(1.9285714285714286);
expected.ShouldDeepEqual(actual);
}
//找到高度更高的子树
private static BinNode <T> TallerChild(BinNode <T> x)
{
return(x.LChild.Stature() > x.RChild.Stature()
? x.LChild
: (x.RChild.Stature() > x.LChild.Stature() ?
x.RChild : x.IsLChild?x.LChild : x.RChild));
}
public static void BuildTree(BinNode <double> tree) // Enter -1 To End
{
Console.WriteLine("Current Root Is: " + tree.GetValue());
Console.Write("Enter Left Num: ");
double leftValue = double.Parse(Console.ReadLine());
if (leftValue == -1)
{
return;
}
BinNode <double> left = new BinNode <double>(leftValue);
Console.Write("Enter Right Num: ");
double rightValue = double.Parse(Console.ReadLine());
if (rightValue == -1)
{
return;
}
BinNode <double> right = new BinNode <double>(rightValue);
tree.SetRight(right);
tree.SetLeft(left);
BuildTree(left);
BuildTree(right);
}
public void TestFullExpression()
{
var node = new BinNode(
new NumberNode(27),
TokenType.PLUS,
new BinNode(
new BinNode(
new BinNode(
new NumberNode(43),
TokenType.DIVIDE,
new NumberNode(36)
),
TokenType.MINUS,
new NumberNode(48)
),
TokenType.MULTIPLY,
new NumberNode(51)
)
);
var actual = new Interpreter().visit(node);
var expected = new Number(-2360.0833333333335);
expected.ShouldDeepEqual(actual);
}
public BinNode(PackingObject obj, BinNode parent, Rect rect)
{
this.nodes = new BinNode[2];
this.parent = parent;
this.obj = obj;
this.rect = rect;
}
private static BinNode <TKey, TValue> Remove(BinNode <TKey, TValue> rootNode, TKey key)
{
if (rootNode == null)
{
return(null);
}
if (rootNode.Key.CompareTo(key) > 0)
{
rootNode.LeftNode = Remove((BinNode <TKey, TValue>)rootNode.LeftNode, key);
}
else if (rootNode.Key.CompareTo(key) < 0)
{
rootNode.RightNode = Remove((BinNode <TKey, TValue>)rootNode.RightNode, key);
}
else
{
if (rootNode.LeftNode == null)
{
return((BinNode <TKey, TValue>)rootNode.LeftNode);
}
if (rootNode.RightNode == null)
{
return((BinNode <TKey, TValue>)rootNode.RightNode);
}
var temp = GetMin((BinNode <TKey, TValue>)rootNode.RightNode);
rootNode.Element = temp.Element;
rootNode.Key = temp.Key;
rootNode.RightNode = DeleteMin(rootNode.RightNode);
}
return(rootNode);
}
public Number visit(BinNode node)
{
Contract.Requires(node != null);
var left = node.nodeA.accept(this).value;
var right = node.nodeB.accept(this).value;
double value;
if (node.operative == TokenType.PLUS)
{
value = left + right;
}
else if (node.operative == TokenType.MINUS)
{
value = left - right;
}
else if (node.operative == TokenType.MULTIPLY)
{
value = left * right;
}
else if (node.operative == TokenType.DIVIDE)
{
value = left / right;
}
else
{
throw new Exception($"Invalid operator {node.operative}");
}
return(new Number(value));
}
/// <summary>
/// 查找函数
/// <remarks>
/// 查找到元素，如果命中，将其伸展到根结点，
/// 否则将Hot结点伸展到跟结点
/// </remarks>
/// </summary>
/// <param name="e">要查找的元素</param>
/// <returns></returns>
public override BinNode <T> Search(T e)
{
BinNode <T> p = SearchIn(Root, e);
Root = Splay(p ?? Hot);
return(Root);
}
/// <summary>
/// 重写插入
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public override BinNode <T> Insert(T e)
{
if (Root == null)
{
Size++;
return(Root = new BinNode <T>(e));
}
if (Eq(e, Search(e).Data))
{
return(Root);
}
Size++;
BinNode <T> t = Root;
if (Lt(Root.Data, e))
{
t.Parent = Root = new BinNode <T>(e, null, t, t.RChild);
if (t.HasRChild)
{
t.RChild.Parent = Root;
t.RChild = null;
}
}
else
{
t.Parent = Root = new BinNode <T>(e, null, t.LChild, t);
if (t.HasLChild)
{
t.LChild.Parent = Root;
t.LChild = null;
}
}
UpdateHeightAbove(t);
return(Root);
}
/// <summary>
/// 替换节点：将 beReplace 节点替换为 node
/// </summary>
/// <param name="node"></param>
/// <param name="beReplace">被替换的节点</param>
private BinNode <T> Replace(BinNode <T> node, BinNode <T> beReplace)
{
if (beReplace.IsRoot())
{
Root = node;
if (null != Root)
{
Root.ParentNode = null;
}
return(Root);
}
if (null != node)
{
node.ParentNode = beReplace.ParentNode;
}
if (beReplace.IsRChild())
{
beReplace.ParentNode.RightChild = node;
}
else
{
beReplace.ParentNode.LeftChild = node;
}
return(node);
}
public static int Calc(BinNode <int> exp)
{
// 1+, 2-, 3*, 4/
if (IsLeaf(exp))
{
return(exp.GetValue());
}
// כאן זה לא עלה אלא פעולה ולכן יש בודאות שני הבנים
int left = Calc(exp.GetLeft());
int right = Calc(exp.GetRight());
int oper = exp.GetValue();
if (oper == 1)
{
return(left + right);
}
if (oper == 2)
{
return(left - right);
}
if (oper == 3)
{
return(left * right);
}
// if (oper == 4) - זה מה שנשאר
return(left / right);
}
public BinNode(byte[] element, uint frequency, BinNode left = null, BinNode right = null)
{
Element = element;
Freq = frequency;
Left = left;
Right = right;
}
static void Main(string[] args)
{
//BinNode<int> root = new BinNode<int>(1);
//BinNode<int> left = new BinNode<int>(2);
//BinNode<int> right = new BinNode<int>(3);
//root.SetLeft(left);
//root.SetRight(right);
//Console.WriteLine(root);
// BinNode<string> root = CreateStringTree();
BinNode <int> tree = RandomCreateTree(2, new Random(), 10, 80);
Console.WriteLine(tree);
//PrintEvenNodes(tree);
BinNode <int> r = null;
Random rnd = new Random();
for (int i = 0; i < 10; i++)
{
r = CreateSearchTree(r, rnd.Next(1, 101));
}
BinNode <int> t = new BinNode <int>(54);
BinNode <int> left = new BinNode <int>(null, 48, new BinNode <int>(54));
t.SetLeft(left);
BinNode <int> right = new BinNode <int>(new BinNode <int>(63), 77, null);
t.SetRight(right);
Console.WriteLine(r);
PrintInOrderTree(r);
}
private static void Main()
{
var dNode = new BinNode <char, int>('D', 14);
var bNode = new BinNode <char, int>('B', 13, null, dNode);
var hNode = new BinNode <char, int>('H', 22);
var iNode = new BinNode <char, int>('I', 41);
var fNode = new BinNode <char, int>('F', 44, hNode, iNode);
var gNode = new BinNode <char, int>('G', 22);
var eNode = new BinNode <char, int>('E', 54, gNode, null);
var cNode = new BinNode <char, int>('C', 12, eNode, fNode);
var aNode = new BinNode <char, int>('A', 23, bNode, cNode);
BinNode <char, int> .Preorder(aNode);
Console.ReadLine();
Console.Clear();
BinNode <char, int> .Inorder(aNode);
Console.ReadLine();
Console.Clear();
BinNode <char, int> .Postorder(aNode);
Console.ReadLine();
Console.Clear();
Console.WriteLine(BinNode <char, int> .Search(aNode, 'F'));
Console.ReadLine();
Console.Clear();
}
public static void PrintTreeWithLevels <T>(BinNode <T> t)
{
//תור עזר של צמתים
Queue <BinNode <T> > qNodes = new Queue <BinNode <T> >();
Queue <int> levels = new Queue <int>();
//הכנסת השורש
qNodes.Insert(t);
int currLevel = 0;
levels.Insert(currLevel);
while (!qNodes.IsEmpty())
{
//נשלוף את הצומת
BinNode <T> temp = qNodes.Remove();
currLevel = levels.Remove();
//קוד לביצוע
Console.WriteLine(temp.GetValue() + "-" + "level:" + currLevel);
if (temp.HasLeft())
{
qNodes.Insert(t.GetLeft());
levels.Insert(currLevel + 1);
}
if (temp.HasRight())
{
qNodes.Insert(t.GetRight());
levels.Insert(currLevel + 1);
}
}
}
public static bool IsBst(BinNode <int> t)
{
//אם עץ ריק
if (t == null)
{
return(true);
}
//אם יש ילד שמאלי גדול מהשורש הנוכחי
if (t.HasLeft())
{
if (t.GetValue() <= t.GetLeft().GetValue())
{
return(false);
}
}
//אם יש ילד ימני קטן מהשורש הנוכחי
if (t.HasRight())
{
if (t.GetValue() > t.GetRight().GetValue())
{
return(false);
}
}
//נבדק שגם תת עץ שמאל וגם תת עץ ימין הם עץ חיפוש
return(IsBst(t.GetLeft()) && IsBst(t.GetRight()));
}
/// <summary>
/// 按照3+4规则旋转 按照中序遍历的规则使之能够达到
/// t0->a->t1->b->t2->c->t3
/// </summary>
/// <param name="a">a</param>
/// <param name="b">b</param>
/// <param name="c">c</param>
/// <param name="t0">t0</param>
/// <param name="t1">t1</param>
/// <param name="t2">t2</param>
/// <param name="t3">t3</param>
/// <returns>返回局部子树的根节点</returns>
private BinNode <T> Connect34(BinNode <T> a, BinNode <T> b, BinNode <T> c,
BinNode <T> t0, BinNode <T> t1, BinNode <T> t2, BinNode <T> t3)
{
a.LChild = t0;
if (t0 != null)
{
t0.Parent = a;
}
a.RChild = t1;
if (t1 != null)
{
t1.Parent = a;
}
UpdateHeight(a);
c.LChild = t2;
if (t2 != null)
{
t2.Parent = c;
}
c.RChild = t3;
if (t3 != null)
{
t3.Parent = c;
}
UpdateHeight(c);
b.LChild = a;
a.Parent = b;
b.RChild = c;
c.Parent = b;
UpdateHeight(b);
return(b);
}
static void Main(string[] args)
{
BinNode <double> tree = new BinNode <double>(1);
BuildTree(tree);
Console.WriteLine(TRG23(tree) - TRG23b(tree));
}
private static void CheckBCountToRoot(RedBlackTree <int> rbTree)
{
List <BinNode <int> > list = rbTree.TraverseLevel(rbTree.Root);
int count = 0;
for (int i = 0; i < list.Count; ++i)
{
BinNode <int> node = list[i];
if (null != node.LeftChild || null != node.RightChild)
{
continue;
}
int bCount = BCountToRoot(node);
if (count <= 0 && bCount > 0)
{
count = bCount;
}
if (count > 0 && bCount != count)
{
Console.WriteLine("CheckBCountToRoot:Error :" + node.Element.ToString());
}
Console.WriteLine(node.Element.ToString() + " " + count);
}
}
public static bool What(BinNode <int> pos)
{
BinNode <int> left = FirstLeft(pos);
BinNode <int> right = FirstRight(pos);
int sum = left.GetValue() + right.GetValue();
left = left.GetRight();
right = right.GetLeft();
while ((left != right) && (left.GetRight() != right) &&
(left.GetValue() + right.GetValue() != sum))
{
left = left.GetRight();
right = right.GetLeft();
}
if (left == right)
{
return(right.GetValue() == sum);
}
if (left.GetRight() == right)
{
return(left.GetValue() + right.GetValue() == sum);
}
return(false);
// return left.GetValue() + right.GetValue() == sum;
}
public void ZeroBalanceFactor_1()
{
var a = 3;
var testNode = new BinNode<int>(ref a);
Assert.AreEqual(0, testNode.BalanceFactor);
}
void BuildRecursivly(BinNode <List <Triangle3D> > node)
{
if (node.data.Count <= 1)
{
return;
}
Triangle3D main = node.data[0];
Plane plane = new Plane(main.a, main.normal);
for (int i = 1; i < node.data.Count; i++)
{
Triangle3D go = node.data[i];
float fa = Helper.SnapToZero(plane.Point(go.a));
float fb = Helper.SnapToZero(plane.Point(go.b));
float fc = Helper.SnapToZero(plane.Point(go.c));
if (fa >= 0 && fb >= 0 && fc >= 0)
{
if (node.right == null)
{
node.right = new BinNode <List <Triangle3D> >(new List <Triangle3D>());
node.right.data = new List <Triangle3D>();
}
node.right.data.Add(go);
}
else if (fa <= 0 && fb <= 0 && fc <= 0)
{
if (node.left == null)
{
node.left = new BinNode <List <Triangle3D> >(new List <Triangle3D>());
node.left.data = new List <Triangle3D>();
}
node.left.data.Add(go);
}
else
{
List <Triangle3D> ts = Rasterizer.ClipTriangle(go, plane);
node.data.AddRange(ts);
node.data.RemoveAt(i);
i--;
}
}
node.data.RemoveRange(1, node.data.Count - 1);
if (node.left != null)
{
BuildRecursivly(node.left);
}
if (node.right != null)
{
BuildRecursivly(node.right);
}
}
/// <summary>
/// 将某棵子树作为结点的左孩子
/// </summary>
/// <typeparam name="T">类型参数</typeparam>
/// <param name="p">结点</param>
/// <param name="rc">要插入的子树</param>
public static void AttachAsRChild <T>(this BinNode <T> p, BinNode <T> rc) where T : IComparable <T>
{
p.RChild = rc;
if (rc != null)
{
rc.Parent = p;
}
}
/// <summary>
/// 将某棵子树作为结点的左孩子
/// </summary>
/// <typeparam name="T">类型参数</typeparam>
/// <param name="p">结点</param>
/// <param name="lc">要插入的子树</param>
public static void AttachAsLChild <T>(this BinNode <T> p, BinNode <T> lc) where T : IComparable <T>
{
p.LChild = lc;
if (lc != null)
{
lc.Parent = p;
}
}
public static BinNode <int> FirstRight(BinNode <int> pos)
{
while (pos.GetRight() != null)
{
pos = pos.GetRight();
}
return(pos);
}
/// <summary>
/// Default CTOR
/// </summary>
public HuffmanTree()
{
root = null;
EncodedData = null;
freqList = null;
isNull = true;
comprssdLen = 0;
}
public static int TRG21High(BinNode <int> tree)
{
if (tree == null)
{
return(0);
}
return(1 + Math.Max(TRG21High(tree.GetLeft()), TRG21High(tree.GetRight())));
}
public static int CountNodes1 <T>(BinNode <T> tr)
{
if (tr == null)
{
return(0);
}
return(1 + CountNodes1(tr.GetLeft()) + CountNodes1(tr.GetRight()));
}
public static BinNode <int> FirstLeft(BinNode <int> pos)
{ // A: total 10pt
while (pos.GetLeft() != null) // 4pt
{
pos = pos.GetLeft(); // 4pt
}
return(pos); // 2pt
}
public BinNode <T> Uncle(BinNode <T> node)
{
if (node.ParentNode.IsLChild())
{
return(node.ParentNode.ParentNode.RightChild);
}
return(node.ParentNode.ParentNode.LeftChild);
}
public static int TRG27 <T>(BinNode <T> tree) // O(n)
{
if (tree == null)
{
return(0);
}
return(1 + Math.Max(TRG27(tree.GetRight()), TRG27(tree.GetLeft())));
}
