/// <summary> ///? 层次遍历 /// </summary> public IEnumerable <T> LevelTravesal(BinTreeNode <T> node) { var nodeQueue = new Queue <BinTreeNode <T> >(); var returnList = new List <T>(); nodeQueue.Enqueue(node); while (nodeQueue.Count > 0) { node = nodeQueue.Dequeue(); if (node != null) { returnList.Add(node.value); } if (node.left != null) { nodeQueue.Enqueue(node.left); } if (node.right != null) { nodeQueue.Enqueue(node.right); } } return(returnList); }
/// <summary> ///? 如果目标有空子节点,则设置为父亲 /// </summary> public bool SetNewParent(BinTreeNode <T> parent) { if (parent == null && this.parent == null) { return(false); } if (parent == null && this.parent != null) { ClearSelf(); return(false); } //插入到左 if (parent.left == null) { parent.left = this; this.parent = parent; return(true); } //插入到右 if (parent.right == null) { parent.right = this; this.parent = parent; return(true); } //节点已满,插入失败 return(false); }
/// <summary> ///? 从根节点开始的 先父 次左 后右 的链式的插入很麻烦 /// </summary> private bool InsertPLR(BinTreeNode <T> parent, BinTreeNode <T> newNode, ref Queue <BinTreeNode <T> > nodeQueue) { var insertResult = false; nodeQueue.Enqueue(parent.left); nodeQueue.Enqueue(parent.right); //! 尝试插入 insertResult = newNode.SetNewParent(parent); //尝试插入到parent,调用node中的SetParent if (insertResult == true) { return(true); } //! 插入失败,则尝试插入其子节点 else { while (!insertResult) { var toInsertNode = nodeQueue.Dequeue(); //递归调用 尝试插入节点,调用node中的SetParent insertResult = InsertPLR(toInsertNode, newNode, ref nodeQueue); } return(insertResult); } }
/// <summary> ///? 中序遍历 L-P-R /// </summary> public IEnumerable <T> InTraversal(BinTreeNode <T> node) { var nodeStack = new Stack <BinTreeNode <T> >(); var nodeList = new List <BinTreeNode <T> >(); var returnList = new List <T>(); while (true) { // 沿着左路一直走到底,沿途添加node到stack中 InTraverAlongLeft(node, ref nodeStack); // 如果stack中没有元素,跳出循环 if (nodeStack.Count <= 0) { break; } node = nodeStack.Pop(); // 如果左侧元素为空或者已经被访问,则访问该元素,否则将TraverAlongLeft if (node.left == null || node.left.isVisited) { InTraverVisit(node, ref nodeStack, ref nodeList); } } foreach (var item in nodeList) { item.isVisited = false; returnList.Add(item.value); } return(returnList); }
private void AutoBalance(BinTreeNode <T> node) { var grandPa = node.parent.parent; if (grandPa == null) { return; } else if (grandPa.left == null || grandPa.right == null) { //! 当grandpa有一个子节点为空 //! 交换grandPa ,parent,node的值,node从parent的子节点变成grandpa的子节点 var temp = grandPa.value; grandPa.value = node.parent.value; node.parent.value = node.value; node.parent.left = null; node.parent.right = null; node.parent = grandPa; node.value = temp; if (grandPa.left == null) { grandPa.left = node; } if (grandPa.right == null) { grandPa.right = node; } return; } AutoBalance(node.parent); }
public bool IsLeafNode => this.parent != null && this.left == null && this.right == null; //叶子节点 public BinTreeNode(T value) { this.value = value; this.parent = null; this.left = null; this.right = null; this.height = -1; }
private void InTraverVisit( BinTreeNode <T> node, ref Stack <BinTreeNode <T> > nodeStack, ref List <BinTreeNode <T> > nodeList) { if (node.right != null) { nodeStack.Push(node.right); } nodeList.Add(node); node.isVisited = true; }
private void PreTraverVisit( BinTreeNode <T> node, ref Stack <BinTreeNode <T> > nodeStack) { if (node.right != null) { nodeStack.Push(node.right); } if (node.left != null) { nodeStack.Push(node.left); } }
/// <summary> ///? 清楚自身以及父节点中关于自身的信息 /// </summary> public void ClearSelf() { if (this.parent.left == this) { this.parent.left = null; } if (this.parent.right == this) { this.parent.right = null; } this.parent = null; }
/// <summary> /// 添加值 /// </summary> /// <param name="value"></param> public void Add(T value) { var newNode = CreateNewNode(value); if (_root == null) { _root = newNode; } else { CompareAndAdd(newNode, _root, false); AutoBalance(newNode); } }
/// <summary> ///? 更新高度 /// </summary> protected void UpdateHeight(BinTreeNode <T> node) { if (node == null) { return; } var orignHeight = node.height; node.UpdateHeight(); if (node.height != orignHeight) { UpdateHeight(node.parent); } }
/// <summary> ///? 先序遍历 P-L-R /// </summary> public IEnumerable <T> PreTraversal(BinTreeNode <T> node) { var nodeStack = new Stack <BinTreeNode <T> >(); var returnList = new List <T>(); nodeStack.Push(node); while (nodeStack.Count > 0) { node = nodeStack.Pop(); PreTraverVisit(node, ref nodeStack); returnList.Add(node.value); } return(returnList); }
protected BinTreeNode <T> SearchClosestBigger(BinTreeNode <T> node) { var bigger = node; if (bigger.right != null) { bigger = bigger.right; } //一直向左 while (bigger.left != null) { bigger = bigger.left; } return(bigger); }
protected BinTreeNode <T> SearchClosestSmaller(BinTreeNode <T> node) { var smaller = node; if (smaller.left != null) { smaller = smaller.left; } //一直向左 while (smaller.right != null) { smaller = smaller.right; } return(smaller); }
private void InTraverAlongLeft(BinTreeNode <T> node, ref Stack <BinTreeNode <T> > nodeStack) { while (node.isVisited == false) { nodeStack.Push(node); if (node.left != null && !node.left.isVisited) { node = node.left; } else { break; } } }
/// <summary> ///? 优先排满一层 的添加 /// </summary> public virtual void Add(T value) { var newNode = new BinTreeNode <T>(value); if (_root == null) { _root = newNode; } else { InsertAtLastNearby(newNode); } ++_count; // 数量增加 _lastInsert = newNode; // 记录为最后一次插入的节点 UpdateHeight(newNode); // 更新高度 }
/// <summary> /// 添加值 /// </summary> public override void Add(T value) { var newNode = new BinTreeNode <T>(value); var isAdded = false; if (_root == null) { _root = newNode; isAdded = true; } else { isAdded = CompareAndAdd(newNode, _root, false); } //元素不重复,添加成功 if (isAdded) { ++_count; // 数量增加 UpdateHeight(newNode); // 更新高度 } }
private bool CompareAndAdd( BinTreeNode <T> newNode, BinTreeNode <T> originNode, bool isLeft) { if (originNode == null) { //! 如果节点为空,则为新节点的父亲的子节点赋值 if (isLeft) { newNode.parent.left = newNode; } else { newNode.parent.right = newNode; } return(true); } else { //! 如果节点非空,节点为新节点的父亲 newNode.parent = originNode; //! 比较大小,决定向左还是向右 var compareResult = newNode.value.CompareTo(originNode.value); if (compareResult == 1) { // 如果大于,放右边 return(CompareAndAdd(newNode, originNode.right, false)); } else if (compareResult == 0) { newNode.ClearSelf(); // 如果等于,不添加 return(false); } else { // 如果小于,放左边 return(CompareAndAdd(newNode, originNode.left, true)); } } }
/// <summary> ///? 在最后一次插入节点的附近寻找空节点插入 /// </summary> private void InsertAtLastNearby(BinTreeNode <T> newNode) { //! 上一次插入的节点可能被删除了 var nodeQueue = new Queue <BinTreeNode <T> >(); if (_lastInsert == null || _lastInsert == _root) { InsertPLR(_root, newNode, ref nodeQueue); return; } var toInsert = _lastInsert.GetSibling(); //! toInsert 为空,可以插入 if (toInsert == null) { InsertPLR(_lastInsert.parent, newNode, ref nodeQueue); return; } else { //! 上一次插入节点的父节点满了 if (_lastInsert.parent.parent == null) { InsertPLR(_root, newNode, ref nodeQueue); return; } toInsert = _lastInsert.parent.GetSibling(); if (toInsert == null) { InsertPLR(_lastInsert.parent.parent, newNode, ref nodeQueue); return; } else { //! 上一次插入节点的兄弟节点也满了,不妨从根节点开始 InsertPLR(_root, newNode, ref nodeQueue); return; } } }
private void GetCloseNumber(ref BinTreeNode <T> originNode) { var temp = originNode; if (originNode.right != null) { temp = originNode.right; while (temp.left != null) { temp = temp.left; } } else if (originNode.left != null) { temp = originNode.left; while (temp.left != null) { temp = temp.right; } } originNode.value = temp.value; // if (temp.parent.left == temp) temp.parent.left }
private BinTreeNode <T> CompareAndRemove(T value, ref BinTreeNode <T> node, bool isRemoving) { // 遇到空节点,结束 查询/移除 循环 if (node == null) { return(null); } // 遇到等值节点,返回结果 if (node.value.Equals(value)) { // 是否是移除操作 if (isRemoving) { var temp = new BinTreeNode <T>(node.value); if (node.IsLeafNode) { node.ClearSelf(); //如果为叶子节点,直接移除 } else { var replace = SearchClosestBigger(node); //得到最近的点,优先选择较大的 if (replace == null) { replace = SearchClosestSmaller(node); //次选较小的 } node.value = replace.value; //替换值 // 如果是叶子节点,则移除并且从父节点开始更新高度; if (replace.IsLeafNode) { var tempParent = replace.parent; replace.ClearSelf(); //移除替换点 UpdateHeight(tempParent); } //如果不是叶子节点,则替换节点必定只有唯一子节点 //将其昨晚父节点的子节点,并更新高度 else { if (replace.left != null) { replace.parent.left = replace.left; replace.left.parent = replace.parent.left; UpdateHeight(replace.parent); replace.ClearSelf(); } else if (replace.right != null) { replace.parent.right = replace.right; replace.right.parent = replace.parent.right; UpdateHeight(replace.parent); replace.ClearSelf(); } } } return(temp); } } //! 比较大小,决定向左还是向右递归 var compareResult = value.CompareTo(node.value); if (compareResult == 1) { // 如果大于,放右边 return(CompareAndRemove(value, ref node.right, isRemoving)); } else { // 如果小于等于,放左边 return(CompareAndRemove(value, ref node.left, isRemoving)); } }
public AVLTree() { _root = null; }
private BinTreeNode <T> CompareAndRemove(T value, ref BinTreeNode <T> originNode, bool isRemoving) { if (originNode == null) { return(null); //! 遇到空节点,结束 查询/移除 循环 } if (originNode.value.Equals(value)) { //! 遇到等值节点,结束 查询/移除 循环 if (isRemoving) { var temp = new BinTreeNode <T>(originNode.value); var tempp = originNode; GetCloseNumber(ref originNode); return(temp); //TODO ZIG 旋转 // ZAG旋转 // ZIG-ZAG // ZAG-ZIG //TODO RotateAT //左侧不位空,赋予左侧值,清除左节点 // if (originNode.left != null) { // originNode.value = originNode.left.value; // originNode.left.ClearSelf(); // //若右侧也不为空,则进行自动平衡修正 // if (originNode.right != null) // AutoBalance(originNode.right); // return temp; // } // //右侧不位空,赋予右侧值,清除右节点 // else if (originNode.right != null) { // originNode.value = originNode.right.value; // originNode.right.ClearSelf(); // var toBalance = originNode.right == null?originNode : originNode.right; // // if (originNode.left != null) // // AutoBalance(originNode.left); // return temp; // } // //左右都为空,清除节点 // else { // originNode.ClearSelf(); // return temp; // } } else { return(originNode); } } //! 比较大小,决定向左还是向右 var compareResult = value.CompareTo(originNode.value); if (compareResult == 1) { // 如果大于,放右边 return(CompareAndRemove(value, ref originNode.right, isRemoving)); } else { // 如果小于等于,放左边 return(CompareAndRemove(value, ref originNode.left, isRemoving)); } }
private void PostTraverVisit( BinTreeNode <T> node, ref Stack <BinTreeNode <T> > nodeStack, ref List <BinTreeNode <T> > nodeList) { nodeList.Add(node); node.isVisited = true; }