C# 平衡二叉树 SBT 源码

最新推荐文章于 2023-03-31 16:32:42 发布
最新推荐文章于 2023-03-31 16:32:42 发布
阅读量678 收藏
点赞数
嗯今天写一个软件的时候不知不觉用到了BST，嗯，BST么，虽然实现很麻烦但是好在.NET已经实现了，直接调用呗……
可等我调用的时候才发现…… MS根本没有给你开放接口……用反编译一看，其实.NET早就把红黑树实现了，就是SortedSet只是因为MS懒得给你写帮助文档（这不是我说的，是Jeffrey在CLRVIA C#里说的……）于是么…… 你就只能默默地用反编译去提取了……
只是…… 反正我是没有提取出来……引用的其他internal类太多了，懒得一个个提取了，干脆直接写了个SBT人在这里供大家使用……
因为是SBT么，刚刚出来的东西，所以就先实现了陈启峰在他论文里提到的功能，再加了一些我自己的，也就是：
Add 添加
Remove 删除
Rank获取第一个（最后一个）值与参数相同的节点的排名
Select 返回排名是i的那个值
Pred 返回比一个值小的最大的值
Succ 返回比一个值大的最小的值
而且都是 ln 复杂度（这不废话么……）

然后么，就是源码了，这个是可以直接使用的，注释已经写好（虽然只是对每个函数的描述）
反正我是大致测了一下，应该没有错的……
然后性能么…… 

运算量：3x10^5
我的实现版本MS家的红黄黑树
Add:12.61 8.34
Remove:6.53 6.86
单位：秒
现在就测了这两个，我之后可能会把其他补上。
然后记得在编译时，在项目属性的生成页下头把代码优化加上，不然会慢6倍吧（我车的时候是这样……）……

把System.dll和  System.Runtime.Serialization.dll  引用上就够了……

using System;
usingSystem.Runtime.Serialization;
usingSystem.Security.Permissions;

namespaceSystem.Collections.Generic
{
    [Serializable]
    public class SBTree<T> :IEnumerable<T>,ISerializable
    {
        [Serializable]
        sealed class Node :IEquatable<Node>,ISerializable
        {
            public Node(T data) { Data = data; Size = 1;}
            public Node() { }
            Node(SerializationInfo info, StreamingContextcontext)
            {
                Data =(T)info.GetValue("Data", typeof(T));
                Left =(Node)info.GetValue("Left", typeof(Node));
                Right =(Node)info.GetValue("Right", typeof(Node));
                Father =(Node)info.GetValue("Father", typeof(Node));
                Size =info.GetInt32("Size");
            }
            public void GetObjectData(SerializationInfoinfo, StreamingContext context)
            {
                info.AddValue("Data", Data);
                info.AddValue("Left", Left);
                info.AddValue("Right", Right);
                info.AddValue("Father", Father);
                info.AddValue("Size", Size);
            }

            public T Data { get; internal set;}
            public int Size { get; internal set;}
            internal Node left, right;
            public Node Left { get { return left; } internalset { left = value; } }
            public Node Right { get { return right; }internal set { right = value; } }
            public Node Father { get; internal set;}

            public static void RightRotate(ref Nodenode)
            {
                Node T =node.Left;
                if((node.Left = T.Right)!=null) T.Right.Father = node;
                node.Size+= (T.Right == null ? 0 : T.Right.Size) - T.Size;
                T.Right =node; T.Father = node.Father; node.Father = T;
                T.Size =T.Right.Size + (T.Left == null ? 0 : T.Left.Size) + 1;
                node =T;
            }
            public static void LeftRotate(ref Nodenode)
            {
                Node T =node.Right;
                if((node.Right = T.Left)!=null) T.Left.Father = node;
                node.Size+= (T.Left == null ? 0 : T.Left.Size) - T.Size;
                T.Left =node; T.Father = node.Father; node.Father = T;
                T.Size =T.Left.Size + (T.Right == null ? 0 : T.Right.Size) +1;
                node =T;
            }
            public static void Maintain(ref Node node, boolmaintain_right)
            {
                if (node== null) return;
                if(maintain_right)
                {
                    if (node.Right == null)return;
                    int lsize;
                    if (node.Left == null) lsize= 0; else lsize = node.Left.Size;
                    if (node.Right.Right != null&& node.Right.Right.Size> lsize)
                        Node.LeftRotate(ref node);
                    else if (node.Right.Left !=null && node.Right.Left.Size> lsize)
                    {
                        RightRotate(ref node.right);
                        LeftRotate(ref node);
                    }
                    else return;
                }
                else
                {
                    if (node.Left == null)return;
                    int rsize;
                    if (node.Right == null) rsize= 0; else rsize = node.Right.Size;
                    if (node.Left.Left != null&& node.Left.Left.Size> rsize)
                        Node.RightRotate(ref node);
                    else if (node.Left.Right !=null && node.Left.Right.Size> rsize)
                    {
                        Node.LeftRotate(ref node.left);
                        Node.RightRotate(ref node);
                    }
                    else return;
                }

                Maintain(ref node.left, false);
                Maintain(ref node.right, true);
                Maintain(ref node, false);
                Maintain(ref node, true);
            }

            public bool Equals(Node a)
            {
                returnData.Equals(a.Data);
            }
            public bool Equals(T a)
            {
                returnData.Equals(a);
            }
            public override bool Equals(objecta)
            {
                if (a isT)
                    returnEquals((T)a);
                else if (ais Node)
                    returnEquals((Node)a);
                returnfalse;
            }
            public override int GetHashCode()
            {
                returnData.GetHashCode();
            }
            public override string ToString()
            {
                returnData.ToString();
            }
        }

        public SBTree() { comparer =Comparer<T>.Default; }
        publicSBTree(IComparer<T> comparer) {this.comparer = comparer; }
        protectedSBTree(SerializationInfo info, StreamingContextcontext)
        {
            root =LoadNodeFromArray((T[])info.GetValue("data",typeof(T[])));
            comparer =(IComparer<T>)info.GetValue("comparer",typeof(IComparer<T>));
        }

        [SecurityPermission(SecurityAction.LinkDemand, Flags =SecurityPermissionFlag.SerializationFormatter)]
        public virtual voidGetObjectData(
        SerializationInfo info,StreamingContext context)
        {
            info.AddValue("data", ToArray());
            info.AddValue("comparer",comparer);
        }

        Node root;
        IComparer<T> comparer;


        void Add(ref Node node, Tv)
        {
            node.Size += 1;
            if (comparer.Compare(v, node.Data)<= 0)
            {
                if(node.left == null)
                {node.left = new Node(v); node.left.Father = node; }
                elseAdd(ref node.left, v);
                Node.Maintain(ref node, false);
            }
            else
            {
                if(node.right == null)
                {node.right = new Node(v); node.right.Father = node; }
                elseAdd(ref node.right, v);
                Node.Maintain(ref node, true);
            }
        }
        ///<summary>
        /// 在SBT中插入一个新的数据复杂度O(ln(count))
        ///</summary>
        /// <paramname="v"></param>
        public void Add(Tv)
        {
            if (root == null)
                root = newNode(v);
            else
                Add(refroot, v);
        }

        T Remove(ref Node node, Tv)
        {
            node.Size -= 1;
            int com_result = comparer.Compare(v,node.Data);
            if (com_result == 0 || (com_result< 0 && node.Left ==null) || (com_result > 0&& node.Right ==null))
            {
                T re =node.Data;
                if(node.Left == null)
                    node =node.Right;
                else if(node.Right == null)
                    node =node.Left;
                else
                    node.Data = Remove(refnode.left, node.Right.Data);
                returnre;
            }
            else if (com_result <0)
                returnRemove(ref node.left, v);
            else
                returnRemove(ref node.right, v);
        }
        ///<summary>复杂度O(ln(count))</summary>
        /// <paramname="v"></param>
        ///<returns>是否成功</returns>
        public bool Remove(Tv)
        {
            if (!Contains(v)) return false;
            Remove(ref root, v);
            return true;
        }

        ///<summary>
        /// 寻找到的是深度最浅的节点
        ///</summary>
        /// <paramname="node"></param>
        /// <paramname="v"></param>
        ///<returns></returns>
        Node Find(Node node, Tv)
        {
            if (node == null) return null;
            int com_res = comparer.Compare(v,node.Data);
            if (com_res == 0)
                returnnode;
            if (com_res < 0)
                returnFind(node.Left, v);
            else
                returnFind(node.Right, v);
        }
        Node Find(T v) { returnFind(root, v); }
        ///<summary>
        /// 此SBT中是否包含值为v的对象复杂度O(ln(count))
        ///</summary>
        /// <paramname="v"></param>
        ///<returns></returns>
        public bool Contains(T v) {return Find(v) != null; }
        bool Contains(Nodenode)
        {
            while (node.Father != null) node =node.Father;
            return Object.ReferenceEquals(root,node);
        }
        Node FindFirst(Node node, Tv)
        {
            if (node == null) return null;
            int com_res = comparer.Compare(v,node.Data);
            if (com_res == 0)
            {
                Node re =node;
                while(re.Left != null &&comparer.Compare(re.Left.Data, v) == 0) re = re.Left;
                returnre;
            }
            if (com_res < 0)
                returnFind(node.Left, v);
            else
                returnFind(node.Right, v);
        }
        Node FindFirst(T v) { returnFindFirst(root, v); }
        public T FindFirstData(Tv)
        {
            var node = FindFirst(root, v);
            if (node == null) returndefault(T);
            return node.Data;
        }
        Node FindLast(Node node, Tv)
        {
            if (node == null) return null;
            int com_res = comparer.Compare(v,node.Data);
            if (com_res == 0)
            {
                Node re =node;
                while(re.Right != null &&comparer.Compare(re.Right.Data, v) == 0) re =re.Right;
                returnre;
            }
            if (com_res < 0)
                returnFind(node.Left, v);
            else
                returnFind(node.Right, v);
        }
        Node FindLast(T v) { returnFindLast(root, v); }
        public T FindLastData(Tv)
        {
            var node = FindLast(root, v);
            if (node == null) returndefault(T);
            return node.Data;
        }
        ///<summary>
        ///查找SBT中与v相同的数据的数量
        ///</summary>
        /// <paramname="v"></param>
        ///<returns></returns>
        public int NumberContains(Tv)
        {
            int t = RankFirst(v);
            if (t == -1) return 0;
            return RankLast(v) - t + 1;
        }


        ///<summary>
        /// 是否为空 复杂度O(1)
        ///</summary>
        public bool Empty { get {return root == null; } }
        ///<summary>
        /// 数据数量 复杂度O(1)
        ///</summary>
        public int Count
        {
            get
            {
                if (Empty)return 0;
                returnroot.Size;
            }
        }

        int Rank(Nodenode)
        {
            if (node == null) return -1;
            int re;
            if (node.Left == null) re = 1;
            else re = node.Left.Size + 1;
            while (node.Father != null)
            {
                if(Object.ReferenceEquals(node.Father.Right, node))
                    re += node.Father.Size -node.Size;
                node =node.Father;
            }
            return re;
        }
        ///<summary>
        /// 从小到大，查询第一个 v的排名(根据comparer进行排序) 复杂度O(ln(count))
        /// 排名从1开始
        ///</summary>
        /// <paramname="v"></param>
        ///<returns>排名</returns>
        public int RankFirst(Tv)
        {
            return Rank(FindFirst(v));
        }
        public int RankLast(Tv)
        {
            return Rank(FindLast(v));
        }

        Node Select(Node node, intrank)
        {
            if (node == null) return null;
            int com_res = rank - ((node.Left == null) ? 0 :node.Left.Size) - 1;
            if (com_res == 0) return node;
            else if (com_res < 0) returnSelect(node.Left, rank);
            else return Select(node.Right, rank -((node.Left == null) ? 0 : node.Left.Size) - 1);
        }
        ///<summary>
        /// 选中排名在rank处的数据，复杂度O(ln(count))，排名从1开始
        ///</summary>
        /// <paramname="rank"></param>
        ///<returns></returns>
        public T Select(intrank)
        {
            if (rank > Count || rank< 1) throw newArgumentException("rank小于1或者超过了Count", "rank");
            return Select(root, rank).Data;
        }

        ///<summary>
        /// O(1)
        ///</summary>
        /// <paramname="node"></param>
        ///<returns></returns>
        Node Pred(Nodenode)
        {
            if (node.Left != null)
            {
                Node re =node.Left;
                while(re.Right != null) re = re.Right;
                returnre;
            }
            else
            {
                Node re =node;
                while(re.Father != null &&!Object.ReferenceEquals(re.Father.Right, re)) re =re.Father;
                returnre.Father;
            }
        }
        ///<summary>
        /// O(1)
        ///</summary>
        /// <paramname="node"></param>
        ///<returns></returns>
        Node Succ(Nodenode)
        {
            if (node.Right != null)
            {
                Node re =node.Right;
                while(re.Left != null) re = re.Left;
                returnre; 
            }
            else
            {
                Node re =node;
                while(re.Father != null &&!Object.ReferenceEquals(re.Father.Left, re)) re =re.Father;
                returnre.Father;
            }
        }
        ///<summary>
        /// 寻找比v小的最大的数据
        ///</summary>
        /// <paramname="v"></param>
        ///<returns></returns>
        public T Pred(Tv)
        {
            var note = Pred(FindFirst(root,v));
            if (note == null) returndefault(T);
            return note.Data;
        }
        ///<summary>
        /// 寻找比v大的最小的数据
        ///</summary>
        /// <paramname="v"></param>
        ///<returns></returns>
        public T Succ(Tv)
        {
            var note = Succ(FindLast(root, v));
            if (note == null) returndefault(T);
            return note.Data;
        }

        Node FirstNode()
        {
            if (root == null) return null;
            Node re = root;
            while (re.Left != null) re =re.Left;
            return re;
        }
        Node LastNode()
        {
            if (root == null) return null;
            Node re = root;
            while (re.Right != null) re =re.Right;
            return re;
        }
        public T First()
        {
            return FirstNode().Data;
        }
        public T Last()
        {
            return LastNode().Data;
        }

        public struct SBT_Enumrator :IEnumerator,IEnumerator<T>
        {
            internalSBT_Enumrator(SBTree<T> from, boolforward)
            {
                current_SBT = from;
                this.forward = forward;
                current_Node = current_SBT.FirstNode();
            }
            bool forward;
            Node current_Node;
            SBTree<T>current_SBT;
            public T Current { get { returncurrent_Node.Data; } }
            object IEnumerator.Current { get { returnCurrent; } }
            public bool MoveNext()
            {
                if(current_Node == null) return false;
                if(!current_SBT.Contains(current_Node)) throw newInvalidOperationExceptio n("已经对SBT集合进行了修改，并且Current已经被删除");
                Nodere;
                if(forward)
                    re =current_SBT.Succ(current_Node);
                else
                    re =current_SBT.Pred(current_Node);
                if (re ==null) return false;
                current_Node = re;
                returntrue;
            }
            public void Reset()
            {
                current_Node = current_SBT.FirstNode();
            }
            public void Dispose()
            {
                current_SBT = null;
                current_Node = null;
            }
        }
        publicIEnumerator<T> GetEnumerator() {return new SBT_Enumrator(this, true); }
        IEnumeratorIEnumerable.GetEnumerator() { return new SBT_Enumrator(this, true);}
        public structSBT_R_EnumeraDev :IEnumerable<T>
        {
            internalSBT_R_EnumeraDev(SBTree<T> from) {current_SBT = from; }
            SBTree<T>current_SBT;
            publicIEnumerator<T> GetEnumerator() {return new SBT_Enumrator(current_SBT, false); }
            IEnumerator IEnumerable.GetEnumerator() { returnnew SBT_Enumrator(current_SBT, false); }
        }
        public IEnumerableAsReverse() { return new SBT_R_EnumeraDev(this); }

        public voidClear()
        {
            root = null;
        }
        public void CopyTo(T[] arr,int arrayIndex)
        {
            int i = 0;
            foreach (var a in this)
                arr[arrayIndex + i++] = a;
        }

        void writeToArray(T[] arr,ref int index, Node node)
        {
            if (node == null) return;
            writeToArray(arr, ref index,node.Left);
            arr[index++] = node.Data;
            writeToArray(arr, ref index,node.Right);
        }
        public T[]ToArray()
        {
            var re = new T[Count];
            int index = 0;
            writeToArray(re, ref index, root);
            return re;
        }
        ///<summary>
        /// 当sbt不为空时，复杂度：O(n*log(n))n为arr.Length
        /// 当sbt为空时，复杂度：O(n)n为arr.Length
        ///</summary>
        /// <paramname="arr"></param>
        public void AddRange(T[]arr)
        {
            if (root == null)
            { root = LoadNodeFromArray(arr); return;}
            foreach (var a in arr)
                Add(a);
        }
        static NodeLoadNodeFromArray(T[] arr, int index, int len)
        {
            if (len == 0) return null;
            Node re = new Node(arr[index + (len>> 1)]) { Size = len };
            if ((re.Left = LoadNodeFromArray(arr, index, len>> 1)) != null) re.Left.Father =re;
            if ((re.Right = LoadNodeFromArray(arr, index +(len >> 1) + 1, len - (len>> 1) - 1)) != null) re.Right.Father= re;
            return re;
        }
        static NodeLoadNodeFromArray(T[] arr)
        {
            return LoadNodeFromArray(arr, 0,arr.Length);
        }
        ///<summary>
        /// 复杂度O(arr.Length)
        ///</summary>
        /// <paramname="arr"></param>
        /// <paramname="compare"></param>
        ///<returns></returns>
        public staticSBTree<T> LoadFromArray(T[] arr,IComparer<T> compare =null)
        {
            if (compare == null) compare =Comparer<T>.Default;
            var re = newSBTree<T>(compare);
            re.root = LoadNodeFromArray(arr);
            return re;
        }
    }
}

http://blog.sina.com.cn/s/blog_8a2a44ff0101hwbf.html

songyux6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构之---C语言实现平衡二叉树（AVL树）
杨鑫newlife的专栏
09-02 7565
数据结构之---C语言实现平衡二叉树（AVL树）
C#与数据结构--树论--平衡二叉树(AVL Tree) - abatei - 博客园
weixin_34242819的博客
10-04 134
C#与数据结构--树论--平衡二叉树(AVL Tree) - abatei - 博客园
二叉树之平衡树的c#实现
SmillCool的博客
02-01 855
在下小白一个 如有错误请指正 上代码 接上一篇二叉树的c#实现 using System; //数据结构 namespace DataStructure {     /// &lt;summary&gt;     /// 平衡树节点 具有高度     /// &lt;/summary&gt;     /// &lt;typeparam name="T"&gt;&lt;/typeparam&...
C#代码随想录算法训练营day17|平衡二叉树、二叉树的所有路径、左叶子之和
weixin_44740741的博客
03-31 110
给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。输入：root = [1,2,2,3,3,null,null,4,4]输入: root = [3,9,20,null,null,15,7]输入：root = [3,9,20,null,null,15,7]深度是到根节点的距离，高度是到叶子节点的距离，求。给定二叉树的根节点 root ，返回所有左叶子之和。输入：root = [1,2,3,null,5]输出：[“1->2->5”,“1->3”]输入：root = [1]
数据结构与算法[1]-平衡二叉树-C#版
ＭicroヾＬi技术Blog
09-26 1034
平衡二叉树 　　形态匀称的二叉树称为平衡二叉树 (Balanced binary tree) ，其严格定义是：　　一棵空树是平衡二叉树；若 T 是一棵非空二叉树，其左、右子树为 TL 和 TR ，令 hl 和 hr 分别为左、右子树的深度。当且仅当　　　①TL 、 TR 都是平衡二叉树； 　　　② ｜ hl － hr ｜≤ 1；时，则 T 是平衡二叉树。【例】如图 8.4 所示。         
平衡二叉树（B-Tree) C#
MyShowTime的专栏
10-04 2715
using System;namespace BTree{    class Node//二叉树结点数据类型    {        public int data;//数据        public Node lchild;//左子树        public Node rchild;//右子树        public Node(int i, Node l, Node r)       
平衡二叉树 java源码.zip
09-27
对于平衡二叉树的Java源码实现，源代码通常会包含表示节点的数据类，以及实现AVL树或红黑树的类。这些类会包含插入、删除、查找等基本操作，并可能包含旋转方法来保持树的平衡。此外，可能会有测试类用于验证算法的...
平衡二叉树
03-03
平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，
二叉树和平衡二叉树的C#实现源码
03-02
对于压缩包中的"Algrithm-20160302"文件，它可能包含了这些二叉树和平衡二叉树的C#实现源代码，你可以通过解压并查看源码来学习和理解这些数据结构的具体实现细节。通过阅读和实践这些代码，你将能够更好地掌握...
平衡二叉树源码
05-14
平衡二叉树源码，可直接编译运行。实现插入、删除、清空、查找、遍历等操作。
C#二叉树与平衡AVL.rar
09-25
在这个“C#二叉树与平衡AVL”压缩包中，我们可以深入探讨二叉排序树（Binary Sort Tree）和其特定类型——平衡二叉树（特别是AVL树）的概念、实现以及它们在C#中的应用。 首先，让我们理解二叉树的基本概念。二叉树...
查找——平衡二叉树的实现（代码超详细注释）
SJ2050的博客
09-03 6913
    既然你搜索到了这篇文章，那么平衡二叉树的作用想必心中已经清楚了，我们接下来就直接来谈谈代码... 目录   知识准备   进阶讲解     代码实现 谢谢阅读 知识准备       啥？你又不知道，真拿你没办法，给你一篇讲的不错的文章： 《大话数据结构》片段 进阶讲解         喂，看完别走呀，我再讲点进阶的知识，我们知道，...
【数据结构与算法】Size Balanced Tree（SBT）平衡二叉树
小哲的博客
11-02 1474
尺寸平衡树（SBT）平衡二叉树 原文链接大小平衡树（SBT）平衡二叉树 定义数据结构 struct SBT { int key,left,right,size; } tree[N]; 关键：存储值，左，右：左右子树，大小：保持平衡最终要的数据，表示子树的大小 SBT树的性质 定义一个节点X，同时满足下面两个条件 (a)、x.left.size &gt;= max(x.r...
平衡二叉树的实现代码加详细注释
huangguangyourena的博客
08-30 1836
当然了，说是详细的注释，但其实只是自己的一些想法。 下面的代码只是简单的平衡二叉树的建立，还没有增添删除功能，我会在接下来的时间补完代码再进行编辑的。 如果有误，还请各位多多指点。万分感谢。 以下是代码部分:#include #include #define true 1 #define false 0 #define LH 1 //表示左子树高 #
平衡二叉树SBT+map+treap（poj3481Double Queue）
龙崎的专栏
02-10 462
Double Queue Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 11119   Accepted: 5046 Description The new founded Balkan Investment Group Bank (BIG-Bank) ope
【平衡二叉树】SBT学习笔记
CreationAugust is 14 years old forever
11-26 3270
醒目：文章部分内容来源于网络上的资料，感谢xkey（http://blog.csdn.net/acceptedxukai ）、百度百科、神的不在场证明（http://www.cnblogs.com/zgmf_x20a/）感谢网络上提供各种资料的神犇们 概述 SBT，即Size Balanced Tree，节点大小平衡树，是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构。它是由中国广东
平衡二叉树(AVL树)C/C++、C#代码实现
qq_44800780的博客
11-23 510
平衡二叉树是带有平衡条件的二叉查找树，指的是空树或者任一结点左、右高度差的j绝对值不超过1的二叉树. 比如: 实现的难点在于，二叉树的平衡旋转 分为四种旋转，RR、LL、LR、RL旋转 RR旋转 麻烦结点在发现者右子树的右边，所以叫RR插入，需要RR旋转 LL旋转 麻烦结点在发现者左子树的左边，所以叫LL插入，需要LL旋转 LR旋转 RL旋转 C/C++实现 #include <s...
c#-平衡二叉树实现
xie__jin__cheng的博客
10-23 780
上一篇：平衡二叉树-c语言实现 概要说明 算法：定义一平衡因子（BF） 当最小不平衡树根结点的平衡因子BF是大于1时，就右旋，小于-1时就左旋。插入结点后，最小不平衡子树的BF与它的子树的BF符号相反时，就需要对结点先进行一次旋转以使得符号相同后，再反向旋转一次才能够完成平衡操作。 第二版代码 using System; namespace 平衡二叉树2 { class Pr...
C#高级查找算法之平衡二叉树
xy_learning的博客
10-22 619
关于平衡二叉树的传说听多了，“某某大厂笔试手撕平衡二叉树实现代码······”等，好像这是一个非常高深的难题似的，现在学习数据结构的时候遇到了，认真拿来看了看，发现不过如此。任何一个算法，理清楚它为什么这么做，然后根据代码看看它是怎么做到的，那也就不难了。 关于平衡二叉树的讲解网上非常多，各位大佬讲解鞭辟入里，这里推荐一个：https://blog.csdn.net/u014165620/art...
avl平衡二叉树源码
最新发布
06-26
AVL（Adelson-Velsky and Landis）平衡二叉树是一种自平衡的二叉搜索树，它的每个节点都维护一个平衡因子（balance factor），表示左子树高度和右子树高度的差。当插入或删除操作导致不平衡时，AVL会通过旋转（left rotation或right rotation）来重新调整平衡。 由于源码通常是编程语言特有的实现，这里无法直接提供完整的源代码。然而，我可以为你概述AVL平衡二叉树的基本结构和关键算法： 1. **节点结构**：每个节点包含键值、左子节点、右子节点以及平衡因子。在许多编程语言中，可能有如下的定义： ```c++ struct AVLNode { int key; AVLNode* left; AVLNode* right; int balance; }; ``` 2. **插入操作**：插入新节点后，通过计算和更新平衡因子，如果不平衡，则通过单旋（left旋或right旋）来调整。 3. **删除操作**：删除节点后同样需要更新平衡，并根据情况可能涉及左右旋或双旋。 4. **旋转**：有四种基本旋转类型：左旋、右旋、左右旋（LLR）、右左旋（RRR）。 5. **旋转后的更新**：在每次旋转后，都需要重新平衡父节点的平衡因子。 如果你对了解这些概念或者具体编程实现感兴趣，我建议查看一些开源的数据结构库（如C++的`std::map`底层实现，或者其他自定义的AVL树实现），或者在线查找相关的教学资源和示例代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值