JavaScript数据结构-6-3平衡二叉排序树

最新推荐文章于 2021-08-02 14:59:18 发布
最新推荐文章于 2021-08-02 14:59:18 发布
阅读量132 收藏
点赞数
分类专栏： 前端 文章标签： javascript 数据结构 avl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34153210/article/details/104371366
版权

平衡二叉树相对于排序树，就是在插入和删除之后，判断父节点的左子树和右子树的高度之差，绝对值是否小于等于1。这个差值就叫平衡因子，当插入一个节点，平衡因子等于-2或者2，表示树不平衡，需要进行旋转，旋转这个词描述的不好，就是进行一系列操作，能让平衡因子绝对值小于2，我的代码是在二叉排序树上修改而来，只修改了insert和delete操作，核心是一系列RR,RL,LL,LR方法，我的RL和LR写的有点长，看到别的代码，RL就是先LL再RR，有兴趣的可以修改我的这两个方法。

<!DOCTYPE html>
<html>
    <head>
        <title>平衡二叉树
        </title>
        <meta charset="utf-8">
            <script src="BST.js" type="text/javascript">
            </script>
            <style type="text/css">
                canvas { border: 1px solid black; }
                .box { display: flex;
                 flex-direction: column; }
                 .line{display: flex;
                   flex-direction: row; }

            </style>
     
    </head>
    <body>
        <p>
        
        </p>
        <canvas height="300" id="tutorial" width="800">
        </canvas>
        <div class="line">
            <label >
            节点列表
            </label>
            <input id="nodes" value="3,1,5,4,6" placeholder="输入数字，英文逗号隔开" type="text">
            
            <button onclick="develop()">初始化</button>
        </div>
         <div class="line">
            <label >
            增加节点
            </label>
            <input id="nodeinsert" value="8" type="text">
            
            <button onclick="insert()">增加</button>
        </div>
           <div class="line">
            <label >
            删除节点
            </label>
            <input id="nodedelete"  type="text">
            
            <button onclick="del()">删除</button>
        </div>
        <div class="line">
         <label >
            子树最大值
            </label>
            	  <input id="nodemax"  value ='5' type="text">	
            	  <button onclick="max()">查找</button>
            	     	  <label id='maxlabel'></label>
        </div>
        <div class="line">
         <label >
            子树最小值
            </label>
            	  <input id="nodemin"  value ='5' type="text">	
            	  <button onclick="min()">查找</button>
            	  <label id='minlabel'></label>
        </div>
        <div class='box' > 
        	 <div class='line'><label>先序遍历</label><label id='pre'></label></div>
        	 <div  class='line'><label>中序遍历</label><label id='in'></label> </div>
        	 <div  class='line'><label>后序遍历</label><label id='post'></label> </div>
        </div>
    </body>
</html>
//******************************************//
class LinkLnode {
    constructor() {
        this.data = null; //数据
        this.next = null; //指针
    }
}
class LinkQueue {
    constructor() {
        //默认带一个不含数据的头节点
        var HeadNode = new LinkLnode();
        this.front = HeadNode; //头指针初始指向头节点
        this.rear = HeadNode; //尾指针初始指向头节点
    }
    IsEmpty() {
        if (this.front == this.rear) return true;
        else return false;
    }
    //入队
    EnQueue(value) {
        var Lnode = new LinkLnode();
        Lnode.data = value;
        Lnode.next = null;
        this.rear.next = Lnode;
        this.rear = Lnode;
    }
    //出队
    DeQueue() {
        if (this.front == this.rear) {
            return false;
        } //空队不能出队
        var p = this.front.next;
        var value = p.data;
        this.front.next = p.next; //等下换成p=p.next
        if (p == this.rear) {
            this.rear = this.front;
        }
        return value;
    }
}
//***********************************************//
class BST_Node {
    constructor(key, lchild, rchild) {
        this.key = key;
        this.lchild = lchild;
        this.rchild = rchild;
    }
}
class Line {
    constructor(moveTOx, moveTOy, lineTOx, lineTOy) {
        this.moveTOx = moveTOx;
        this.moveTOy = moveTOy;
        this.lineTOx = lineTOx;
        this.lineTOy = lineTOy;
    }
}
class View_Node {
    constructor(node, x, y, line) {
        this.node = node;
        this.x = x;
        this.y = y;
        this.line = line;
    }
}
class BST {
    constructor(keys) {
        //传入数组则构造树
        //传入空值则创建空头节点
        this.root = null;
        this.travels = [];
        if (keys != null) {
            for (var i = 0; i < keys.length; i++) {
                this.BST_Insert(this.root, keys[i]);
            }
        }
    }
    // BST_Insert(T, key) {
    //     if (T == null) {
    //         this.root = new BST_Node(key, null, null);
    //     } else {
    //         if (key < T.key) {
    //             if (T.lchild == null) {
    //                 T.lchild = new BST_Node(key, null, null);
    //                 return true;
    //             } else {
    //                 this.BST_Insert(T.lchild, key); //要加this，不加显示函数未定义
    //             }
    //         } else if (key > T.key) {
    //             if (T.rchild == null) {
    //                 T.rchild = new BST_Node(key, null, null);
    //                 return true;
    //             } else {
    //                 this.BST_Insert(T.rchild, key);
    //             }
    //         } else if (key === T.key) {
    //             return false;
    //         }
    //     }
    // }
    //在做旋转的时候，需要知道当前节点是父节点的左儿子还是右儿子，方法之一是调用
    //BST_Search获取当前的节点状态，还有一种方法是修改BST_Insert函数，增加父节点参数
    //BST_Insert(F,T, key)，最好是修改一下，但是我想了一下，当只有树不平衡的时候才需要查询，
    //因此性能上也不会损失太多，以后写代码最好还是传入父节点，提升性能
    //当然不传入父节点也能进行旋转操作，但是过于繁琐
    //因为只修改了插入和删除操作，正常操作应该是平衡树继承排序树，然后重写这两个方法，为图方便我直接在原有基础上修改
    Rotate_RR(T) {
        console.log('RR旋转' + T.key);
        var q = this.BST_Search(this.root, T.key);
        var p = T.rchild;
        T.rchild = p.lchild;
        p.lchild = T;
        if (T == this.root) {
            this.root = p;
        } else {
            if (q.S == 'l') q.F.lchild = p;
            if (q.S == 'r') q.F.rchild = p;
        }
    }
    Rotate_RL(T) {
        console.log('RL旋转' + T.key);
        var q = this.BST_Search(this.root, T.key);
        var b = T.rchild;
        var c = b.lchild;
        b.lchild = c.rchild;
        c.rchild = b;
        //T.rchild = c;
        T.rchild = c.lchild;
        c.lchild = T;
        if (T == this.root) {
            this.root = c
        } else {
            if (q.S == 'l') q.F.lchild = c;
            if (q.S == 'r') q.F.rchild = c;
        }
    }
    Rotate_LL(T) {
        console.log('LL旋转' + T.key);
        var q = this.BST_Search(this.root, T.key);
        var p = T.lchild;
        T.lchild = p.rchild;
        p.rchild = T;
        if (T == this.root) {
            this.root = p;
        } else {
            if (q.S == 'l') q.F.lchild = p;
            if (q.S == 'r') q.F.rchild = p;
        }
    }
    Rotate_LR(T) {
        console.log('LR旋转' + T.key);
        var q = this.BST_Search(this.root, T.key);
        var b = T.lchild;
        var c = b.rchild;
        b.rchild = c.lchild;
        c.lchild = b;
        //T.rchild = c;
        T.lchild = c.rchild;
        c.rchild = T;
        if (T == this.root) {
            this.root = c
        } else {
            if (q.S == 'l') q.F.lchild = c;
            if (q.S == 'r') q.F.rchild = c;
        }
    }
    BST_Insert(T, key) {
        if (T == null) {
            this.root = new BST_Node(key, null, null);
        } else {
            if (key < T.key) {
                if (T.lchild == null) {
                    T.lchild = new BST_Node(key, null, null);
                    return true;
                } else {
                    this.BST_Insert(T.lchild, key); //要加this，不加显示函数未定义
                    if ((this.BST_Height(T.lchild) - this.BST_Height(T.rchild)) == 2) {
                        if (
                            //T.rchild.lchild != null && T.rchild.rchild != null &&
                            this.BST_Height(T.lchild.lchild) - this.BST_Height(T.lchild.rchild) == 1) {
                            this.Rotate_LL(T);
                        } //end RR
                        else if (
                            //    T.rchild.lchild != null && T.rchild.rchild != null && 
                            this.BST_Height(T.lchild.lchild) - this.BST_Height(T.lchild.rchild) == -1) {
                            this.Rotate_LR(T);
                        }
                    } //end 
                }
            } else if (key > T.key) {
                if (T.rchild == null) {
                    T.rchild = new BST_Node(key, null, null);
                    return true;
                } else {
                    this.BST_Insert(T.rchild, key);
                    //判断需要进行RR选择还是RL旋转
                    //当插入完成，插入函数退栈的时候进行旋转操作
                    if ((this.BST_Height(T.lchild) - this.BST_Height(T.rchild)) == -2) {
                        if (
                            //T.rchild.lchild != null && T.rchild.rchild != null &&
                            this.BST_Height(T.rchild.lchild) - this.BST_Height(T.rchild.rchild) == -1) {
                            this.Rotate_RR(T);
                        } //end RR
                        else if (
                            //    T.rchild.lchild != null && T.rchild.rchild != null && 
                            this.BST_Height(T.rchild.lchild) - this.BST_Height(T.rchild.rchild) == 1) {
                            this.Rotate_RL(T);
                        }
                    } //end 
                }
            } else if (key === T.key) {
                return false;
            }
        }
    }
    //查找以root为根节点的树
    BST_Search(root, key) {
        //var F = new BST_Node(null, root, root); //修改
        var F = null;
        // if (key == this.root.key) F = new BST_Node(null, root, root);
        var T = root;
        var S = null; //S用来记录T的是F的左儿子还是右儿子
        while (T != null && key != T.key) {
            F = T;
            if (key < T.key) {
                S = 'l';
                T = T.lchild;
            } else if (key > T.key) {
                S = 'r';
                T = T.rchild;
            }
        }
        return {
            F, //父节点
            T, //当前节点
            S
        };
    }
    //查找以T为根节点，其子树最小的值
    BST_SearchMin(T) {
        var F = null;
        if (T == null) return null;
        else {
            while (T != null && T.lchild != null) {
                F = T;
                T = T.lchild;
            }
            return {
                F,
                T
            };
        }
    }
    //查找以T为根节点，其子树最大的值，返回父节点和当前节点
    BST_SearchMax(T) {
        var F = null;
        if (T == null) return null;
        else {
            while (T != null && T.rchild != null) {
                F = T;
                T = T.rchild;
            }
            return {
                F,
                T
            };
        }
    }
    //删除节点
    BST_Delete(root, key) {
        //找到该节点
        var p = this.BST_Search(root, key);
        if (p.T == null) return null;
        //叶子节点
        if (p.T.lchild == null && p.T.rchild == null) {
            //如果删除到最后只有一个根节点
            if (p.T == this.root) {
                this.root = null;
                return;
            }
            p.S == 'l' ? p.F.lchild = null : p.F.rchild = null;
        }
        //只有一个子节点,儿子取代父亲
        if (p.T.lchild == null && p.T.rchild != null) {
            //由于不支持指针变量，只能用下面的传值的方法
            //假如支持指针变量，直接将要删除的节点的指针放入S中，然后S=null就执行了删除操作
            p.S == 'l' ? p.F.lchild = p.T.rchild : p.F.rchild = p.T.rchild;
        }
        if (p.T.rchild == null && p.T.lchild != null) {
            //由于不支持指针变量，只能用下面的传值的方法 
            //假如支持指针变量，直接将要删除的节点的指针放入S中，然后S=null就执行了删除操作
            //当p是根节点的时候，会出错，因此加一个判断
            if (p.T == this.root) {
                this.root = p.T.lchild;
                return;
            }
            p.S == 'l' ? p.F.lchild = p.T.lchild : p.F.rchild = p.T.lchild;
        }
        //如果有两个子节点
        if (p.T.rchild != null && p.T.lchild != null) {
            //先找以右儿子为根节点的树的最小的节点，替换当前节点
            //删除最小的节点
            var rs = this.BST_SearchMin(p.T.rchild);
            this.BST_Delete(p.T, rs.T.key);
            p.T.key = rs.T.key; //将右子树的最小节点的值赋值回来
        }
    }
    //删除成功后，判断是否需要平衡，T是父节点，然后循环调用
    BST_Del_Rotaion(T) {
        while (T != null || T != undefined) {
            var F = this.BST_Search(this.root, T.key).F;
            if ((this.BST_Height(T.lchild) - this.BST_Height(T.rchild)) == 2) {
                if (
                    //T.rchild.lchild != null && T.rchild.rchild != null &&
                    this.BST_Height(T.lchild.lchild) - this.BST_Height(T.lchild.rchild) == 1 || this.BST_Height(T.lchild.lchild) - this.BST_Height(T.lchild.rchild) == 0) {
                    this.Rotate_LL(T);
                } //end RR
                else if (
                    //    T.rchild.lchild != null && T.rchild.rchild != null && 
                    this.BST_Height(T.lchild.lchild) - this.BST_Height(T.lchild.rchild) == -1) {
                    this.Rotate_LR(T);
                }
            } //end 
            if ((this.BST_Height(T.lchild) - this.BST_Height(T.rchild)) == -2) {
                if (
                    //T.rchild.lchild != null && T.rchild.rchild != null &&
                    this.BST_Height(T.rchild.lchild) - this.BST_Height(T.rchild.rchild) == -1 || this.BST_Height(T.rchild.lchild) - this.BST_Height(T.rchild.rchild) == 0) {
                    this.Rotate_RR(T);
                } //end RR
                else if (
                    //    T.rchild.lchild != null && T.rchild.rchild != null && 
                    this.BST_Height(T.rchild.lchild) - this.BST_Height(T.rchild.rchild) == 1) {
                    this.Rotate_RL(T);
                }
            } //end 
            T = F;
        }
    }
    //2020-2-15新增计算树的高度,RR,RL,LL,LR旋转
    BST_Height(T) {
        if (T == null) return -1; //也可以return 0 ,这样最下面一层的高度是1而不是0
        return Math.max(this.BST_Height(T.rchild), this.BST_Height(T.lchild)) + 1;
    }
    //绘制图形
    view() {
        var canvas = document.getElementById('tutorial');
        var ctx = canvas.getContext('2d');
        ctx.font = "20px serif";
        //先清空画布
        ctx.clearRect(0, 0, 800, 600);
        //ctx.fillText("1", 10, 50);
        //ctx.strokeText("1", 20, 50);
        var results = this.LevelOrder();
        for (var i = 0; i < results.length; i++) {
            ctx.beginPath();
            ctx.arc(results[i].x + 5, results[i].y - 5, 15, 0, 2 * Math.PI, false);
            ctx.stroke();
            ctx.fillText(results[i].node.key, results[i].x, results[i].y, 15);
            ctx.moveTo(results[i].line.moveTOx, results[i].line.moveTOy);
            ctx.lineTo(results[i].line.lineTOx, results[i].line.lineTOy);
            ctx.stroke();
        }
    }
    //先序遍历,结果放入数组中
    PreOrder(T) {
        if (T != null) {
            this.travels.push(T.key);
            this.PreOrder(T.lchild);
            this.PreOrder(T.rchild);
        }
    }
    //中序遍历
    InOrder(T) {
        if (T != null) {
            this.PreOrder(T.lchild);
            this.travels.push(T.key);
            this.PreOrder(T.rchild);
        }
    }
    //后序遍历
    PostOrder(T) {
        if (T != null) {
            this.PreOrder(T.lchild);
            this.PreOrder(T.rchild);
            this.travels.push(T.key);
        }
    }
    //层次遍历,并记录节点的横纵坐标,方便画图
    LevelOrder() {
        //数组存层次遍历数据
        var results = [];
        //初始化队列
        var Queue = new LinkQueue();
        //根节点入队
        var vroot = new View_Node();
        vroot.node = this.root;
        if (this.root == null) return false;
        //初始化位置
        vroot.x = 400;
        vroot.y = 100;
        //初始化间隔
        var t = 50;
        //根节点入队
        var rootline = new Line(0, 0, 0, 0);
        vroot.line = rootline;
        Queue.EnQueue(vroot);
        while (!Queue.IsEmpty()) {
            //出队
            var p = Queue.DeQueue();
            results.push(p);
            //访问vnode
            if (p.node.lchild != null) {
                var lnode = new View_Node();
                lnode.node = p.node.lchild;
                lnode.x = p.x - t;
                lnode.y = p.y + t;
                var line = new Line(p.x - 5, p.y + 5, lnode.x + 15, lnode.y - 15);
                lnode.line = line;
                Queue.EnQueue(lnode);
            }
            if (p.node.rchild != null) {
                var rnode = new View_Node();
                rnode.node = p.node.rchild;
                rnode.x = p.x + t;
                rnode.y = p.y + t;
                var line = new Line(p.x + 15, p.y + 5, rnode.x - 5, rnode.y - 15);
                rnode.line = line;
                Queue.EnQueue(rnode);
            }
        }
        return results;
    }
}
window.onload = function() {
    develop();
}

function develop() {
    var nodes = document.getElementById('nodes');
    nodes = nodes.value.split(",");
    // node = Number(node);
    nodes = nodes.map(Number);
    var oneBST = new BST(nodes);
    oneBST.view();
    window.BST = oneBST;
    order();
}

function insert() {
    var node = document.getElementById('nodeinsert');
    node = Number(node.value);
    var oneBST = window.BST;
    oneBST.BST_Insert(oneBST.root, node);
    console.log(oneBST.root);
    oneBST.view();
    window.BST = oneBST;
    order();
}

function del() {
    var node = document.getElementById('nodedelete');
    node = Number(node.value);
    var oneBST = window.BST;
    var F = oneBST.BST_Search(oneBST.root, node).F;
    oneBST.BST_Delete(oneBST.root, node);
    if (F == null) F = oneBST.root;
    oneBST.BST_Del_Rotaion(F);
    //console.log(oneBST.root);
    oneBST.view();
    window.BST = oneBST;
    order();
}

function max() {
    var node = document.getElementById('nodemax');
    node = Number(node.value);
    var oneBST = window.BST;
    var root = oneBST.BST_Search(oneBST.root, node);
    var p = oneBST.BST_SearchMax(root.T);
    var maxlabel = document.getElementById('maxlabel');
    if (p == null) {
        maxlabel.innerHTML = 'not found';
    } else {
        maxlabel.innerHTML = p.T.key;
    }
}

function min() {
    var node = document.getElementById('nodemin');
    node = Number(node.value);
    var oneBST = window.BST;
    var root = oneBST.BST_Search(oneBST.root, node);
    var p = oneBST.BST_SearchMin(root.T);
    var maxlabel = document.getElementById('minlabel');
    if (p == null) {
        maxlabel.innerHTML = 'not found';
    } else {
        maxlabel.innerHTML = p.T.key;
    }
}

function order() {
    var oneBST = window.BST;
    oneBST.travels = [];
    oneBST.PreOrder(oneBST.root);
    var pretravels = oneBST.travels;
    var prelabel = document.getElementById('pre');
    prelabel.innerHTML = pretravels.toString();
    oneBST.travels = [];
    oneBST.InOrder(oneBST.root);
    var intravels = oneBST.travels;
    var inlabel = document.getElementById('in');
    inlabel.innerHTML = intravels.toString();
    oneBST.travels = [];
    oneBST.PostOrder(oneBST.root);
    var posttravels = oneBST.travels;
    var postlabel = document.getElementById('post');
    postlabel.innerHTML = posttravels.toString();
}

 

香辣素毛肚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构经典习题 之 二叉排序树
yutong5818的博客
11-22 4755
设计一个算法 ，判断给定的二叉树是否为二叉排序树 ，假设二叉排序树已经存储在二叉链表存储结构中，树节点个数为n,节点值为int型。 (1)给出基本设计思想 （2）根据设计思想，采用c或c++语言描述算法，并在关键之处给出注释 。 （3）分析算法的时间复杂度和空间复杂度   这道题我第一次做的时候写的代码如下， int judge(BNode  *bt) { if (bt==NULL...
javascript数据结构之二叉搜索树实现方法
11-24
二叉搜索树是一种特殊的数据结构，它在计算机科学中用于高效地存储和检索有序数据。在JavaScript中，我们可以创建一个二叉搜索树类来实现这些功能。以下是对标题和描述中提到的知识点的详细说明： 1. **二叉搜索树...
6.3二叉排序树
BossHAO的博客
08-30 857
6.3二叉排序树 定义:二叉排序树（Binary Search Tree也叫二叉搜索树）或者是空树或者是具有以下性质的二叉树；（左小右大） 1）若左子树不空，则左子树上的所有结点的值均小于它的根结点的值。 2）若右子树不空，则右子树上的所有结点的值均大于它的根结点的值。 3）它的左右子树也是一颗二叉排序树。 对二叉排序树进行中序遍历可以得到一个递增的有序序列。 二叉排序树的目的，不是为了排序，...
数据结构与算法（6-3）二叉树的遍历（前序遍历、中序遍历、后序遍历、层序遍历）（层序遍历分别用队列和链队列实现）
great_yzl的博客
08-02 3534
目录 一、前序遍历 二、中序遍历 三、后序遍历 前中后序遍历总代码 四、层序遍历（队列实现(主流)） 总代码 五、层序遍历（链队列实现(自创)） 总代码 二叉树的遍历分为前序、中序、后序以及层序遍历。 前中后序是按照根结点的访问顺序来确定的，前中后序遍历的核心都是递归。 一、前序遍历 访问顺序：根->左->右 普通二叉树遍历（前序）：ABDCG 扩展二叉树遍历（前序）：ABD###C#G## 实现顺序： 1、生成根结点 2、递归遍历左子树...
C#数据结构-二叉树实现及常见面试题
qq826364410的专栏
03-28 1016
二叉查找树 二叉排序树，又称为二叉查找树。它或者是一棵空树，或者是具有下列性质的二叉树。 若它的左子树不为空，则左子树上所有的结点的值均小于根结构的值； 若它的右子树不为空，则右字数上所有结点的值均大于它的根结点的值； 1. 前序、中序、后序、层次遍历 一般会考查非递归版本的实现，频率很高，在下面的代码递归和非递归版本都有实现。 2. 二叉树的镜像 具体实现在下面的代...
数据结构算法常见面试考题
热门推荐
Zuoerfeng
11-08 13万+
（1） 红黑树的了解（平衡树，二叉搜索树），使用场景 把数据结构上几种树集中的讨论一下： 1.AVLtree 定义：最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 节点的平衡因子是它的左子树的高度减去它的右子树的高度（有时相反）。...
6. 数据结构进阶六之二叉树排序树
badman250的专栏
09-22 4222
6. 数据结构进阶六之二叉树排序树 ：“有些人因为贪婪，想得更多的东西，却把现在所有的也失掉了。 -- 伊索” 关于理论知识已经在上篇中进行描述，这篇我们主要来看下如何是实现二叉排序树。 1.  二叉排序树的定义 　二叉排序树(BinarySort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树： ①
基于JavaScript数据结构实现的二叉排序树社会关系网【100012932】
最新发布
07-14
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值，且左子树中的所有节点的键值都小于当前节点，右子树中的所有节点的键值都大于当前节点。...
js代码-12.5 排序数组转化为二叉搜索树
07-16
在JavaScript编程中，排序数组转化为二叉搜索树（BST）是一种常见的数据结构转换问题。二叉搜索树是一种特殊的二叉树，其中每个节点都满足以下性质：左子树中的所有节点值都小于当前节点，而右子树中的所有节点值都...
Data-Structures:Javascript中流行数据结构的实现
05-13
在JavaScript这样的编程语言中，理解并能熟练应用各种数据结构至关重要，尤其对于提升代码效率和解决复杂问题。以下是对标题和描述中涉及的知识点的详细说明： 1. **堆栈（Stack）**：堆栈是一种后进先出（LIFO）的...
(十三) AVL平衡二叉树
jssd的博客
09-04 324
文章目录AVL 平衡二叉树树的深度平衡因子如何将二叉搜索树改进成AVL什么时候改进怎么维护右旋转左旋转树的不平衡情况LLRRLRRL代码实现 AVL 平衡二叉树 树的深度 对于每个节点来说, 其存在的层数就是以此节点来表示的二叉树的深度. 二叉树的深度定义如下: 只有一个节点的树, 他的深度为1 一个节点的深度等于它的左孩子深度;和右孩子深度的最大值加1 平衡因子 每一个平衡树都会维护一个平衡...
JS数据结构之平衡二叉树（AVL树）
qq_44222205的博客
07-29 353
AV树的旋转AVL树概念不平衡概况四种平衡旋转方式RL平衡旋转(先右后左双旋转)LR平衡旋转(先左后右单旋转) AVL树概念 前面学习二叉查找树和二叉树的各种遍历，但是其查找效率不稳定(斜树)，而二叉平衡树的用途更多。查找相比稳定很多。(欢迎关注数据结构专栏) AVL树是带有平衡条件的二叉查找树。这个平衡条件必须要容易保持。而且要保证它的深度是O(logN). AVL的条件是左右树的高度差（平衡因子）不大于1；并且它的每个子树也都是平衡二叉树。 对于平衡二叉树的最小个数，n0=0;n1=1;nk=n
平衡二叉树AVL（JS实现）
zjw_python的博客
12-18 1636
1 定义 平衡二叉树是一种二叉排序树，其中每个节点的左子树和右子树的高度差至多等于1。其中，二叉树节点的左子树深度减去右子树深度的值称为平衡因子（BF），因此平衡二叉树节点的平衡因子值只能为1、0或-1。距离插入节点最近的，且平衡因子的绝对值大于1的节点为根的子树，我们称为最小不平衡子树。 2 平衡二叉树的构建过程 平衡二叉树的构建过程基于二叉排序树的构建过程，在插入节点的过程中，一旦出现不平衡...
js实现平衡二叉树
simple5960的博客
12-10 407
平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉排序树：它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树 平衡二叉树必须是二叉搜索树 var Node=function(key) { this.key=key; this.lchild=null; this.rchild=null; this.height=1;//平衡因子 } var root = null;//根节点 getRoot=function(){return r.
Javascript数据结构之禅：平衡二叉树(Balanced Binary Tree, AVL Tree)
Chainn的全栈之旅
03-03 2804
Javascript数据结构之禅：平衡二叉树(Balanced Binary Tree, AVL Tree)项目源码地址： github.com/KristenXu/JavascriptDatastructures/blob/master/AVLTree.js1 .基本概念AVL树的复杂程度真是比二叉搜索树高了整整一个数量级——它的原理并不难弄懂，但要把它用代码实现出来还真的有点费脑筋。下面我们来
6-3 遍历二叉树
Log.e的博客
04-19 1757
1.遍历概念： 顺着某一条搜索路径巡访二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次。 2.“访问”的含义很广，可以是对结点作各种处理， 如：输出结点的信息、修改结点的数据值等，但要求这种访问不破坏原来的数据结构。 （他是一个引用型操作） 遍历目的： 得到树中所有结点的一个线性排列。 4.遍历方法： DLR —— 先（根）序遍历， ...
React Router 如何使用history跳转
qq_34153210的博客
05-20 1万+
react 路由
React几种传递参数的方法
qq_34153210的博客
05-13 9286
1.父组件向子组件传参 回调函数也是参数的一种，也可以传给子组件，达到子组件控制父组件的目的 import React from 'react'; import ReactDOM from 'react-dom'; function Son(props) { return <div>父组件的名称是{props.name}</div> } function Father(props) { return ( <Son name="Father"/> );
React 如何动态加载本地图片
qq_34153210的博客
05-12 8335
react的标签是<img>,导入本地图片，可以用import加载 import React from 'react'; import testImgUrl from "../../images/1.png"; class App extends React.Component { constructor(props) { super(props); } render() { return ( &
使用javascript语言实现二叉排序树查找
03-26
3. 左右子树也都是二叉排序树。 为了实现二叉排序树的查找，我们需要以下步骤： 1. 从根节点开始，比较要查找的值与当前节点的值的大小关系； 2. 如果要查找的值比当前节点的值小，则进入左子树继续查找； 3. 如果...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值