js数据结构与算法——二叉树

function BinaryTree(){
            var Node = function(key){
                this.key = key; //值
                this.left = null; //左箭头
                this.right = null; //右箭头
            }
            //根节点
            var root = null;

            var insertNode = function(oldNode,newNode){
                if(newNode.key < oldNode.key){
                    if(oldNode.left === null){
                        oldNode.left = newNode
                    }else{
                        insertNode(oldNode.left,newNode)//递归查找
                    }
                }else{
                    if(oldNode.right === null){
                        oldNode.right = newNode
                    }else{
                        insertNode(oldNode.right,newNode);
                    }
                }
            }

            //插入节点
            this.insert = function(key) {
                var newNode = new Node(key);
                if(root === null){
                    root = newNode;
                }else{
                    insertNode(root,newNode)
                }
            }

            //中序排列
            this.inOrderTraverse = function(callback){
                inOrderTraverseNode(root,callback)
            }

            //中序排序辅助函数

            var inOrderTraverseNode = function(node,callback){
                if(node !== null){
                    inOrderTraverseNode(node.left,callback);//遍历左节点
                    callback(node.key);//遍历根节点,中节点
                    inOrderTraverseNode(node.right,callback);//遍历右节点
                }
            }

            //先序遍历,先访问节点本身在遍历左节点,最后遍历右节点

            this.preOrderTraverse = function(callback){
                preOrderTraverseNode(root,callback);
            }

            var preOrderTraverseNode = (node,callback)=>{
                if(node !== null){
                    callback(node.key);
                    preOrderTraverseNode(node.left,callback);
                    preOrderTraverseNode(node.right,callback);
                }
            }

            //后序遍历,先访问节点的后代节点,再访问节点本身

            this.postOrderTraverse = function(callback){
                postOrderTraverseNode(root,callback);
            }

            var postOrderTraverseNode = (node,callback) =>{
                if(node !== null){
                    postOrderTraverseNode(node.left,callback);
                    postOrderTraverseNode(node.right,callback);
                    callback(node.key);
                }
            }

            //搜索最大值,最小值
            this.min = function(){
                return minNode(root);
            }

            var minNode = (node)=>{
                if(node){
                    while(node && node.left !== null){
                        node = node.left;
                    }
                    return node.key
                }
                return null;
            }

            this.max = function(){
                return maxNode(root);
            }

            var maxNode = (node) => {
                if(node){
                    while(node && node.right !== null){
                        node = node.right;
                    }
                    return node.key
                }
                return null;
            }
            //搜索一个特定的值

            this.search = function(key){
                return searchNode(root,key);
            }

            var searchNode = (node,key) =>{
                if(node === null){
                    return false;
                }
                if(key < node.key){
                    return searchNode(node.left,key)
                } else if( key > node.key){
                    return searchNode(node.right,key);
                }else{
                    return true;
                }
            }

            //移除一个节点

            this.remove = function(key){
                return removeNode(root,key);
            }

            var removeNode = (node,key) =>{
                if(node === null){
                    return false
                }
                if(key < node.key){
                    node.left = removeNode(node.left,key);
                    return node
                }else if(key > node.key){
                    node.right = removeNode(node.right,key);
                    return node;
                }else{
                    //第一种情况  一个叶子节点
                    if(node.left === null && node.right === null){
                        node = null;
                        return node;
                    }
                    //第二种情况  一个只有一个子节点的节点

                    if(node.left === null){
                        node = node.right;
                        return node;
                    }else if(node.right === null){
                        node = node.left;
                        return node;
                    }

                    //第三种情况  一个有两个子节点的节点
                    var aux = findMinNode(node.right);
                    node.key = aux.key;
                    node.right = removeNode(node.right,aux.key);
                    return node;
                }
            }

            var findMinNode = (node)=>{
                if(node){
                    while(node && node.left !== null){
                        node = node.left;
                    }
                    return node
                }
                return null;
            }

        }    

        let node = [8,3,10,1,6,14,4,7,13];
        var binaryTree = new BinaryTree();
        node.forEach((key)=>{
            binaryTree.insert(key);
        })

       var printNode = (val) => {
           console.log(val)
       }
        binaryTree.inOrderTraverse(printNode) //中序遍历
        binaryTree.preOrderTraverse(printNode) //先序遍历
        binaryTree.postOrderTraverse(printNode) //后序遍历

        console.log(binaryTree.min() + ‘: min‘)
        console.log(binaryTree.max() + ‘: max‘)
        console.log(binaryTree.search(8) + ‘: search‘)
        console.log(binaryTree.remove(8) )

原文地址:https://www.cnblogs.com/huangmin1992/p/10433557.html

时间: 2024-10-25 10:58:49

js数据结构与算法——二叉树的相关文章

js数据结构和算法---二叉树

原文: https://segmentfault.com/a/1190000000740261 //前序遍历 function preOrder(node) { if (node != null) { node.style.background = "black"; setTimeout(function () { preOrder(node.children[0]); },1500); setTimeout(function () { preOrder(node.children[1

javascript数据结构与算法--二叉树(插入节点、生成二叉树)

javascript数据结构与算法-- 插入节点.生成二叉树 二叉树中,相对较小的值保存在左节点上,较大的值保存在右节点中 /* *二叉树中,相对较小的值保存在左节点上,较大的值保存在右节点中 * * * */ /*用来生成一个节点*/ function Node(data, left, right) { this.data = data;//节点存储的数据 this.left = left; this.right = right; this.show = show; } function sh

[数据结构与算法] 二叉树及其遍历方式

声明:原创作品,转载时请注明文章来自SAP师太技术博客:www.cnblogs.com/jiangzhengjun,并以超链接形式标明文章原始出处,否则将追究法律责任!原文链接:http://www.cnblogs.com/jiangzhengjun/p/4289830.html 一.数据结构分类 (一)按逻辑结构 集合(无辑关系) 线性结构(线性表):数组.链表.栈.队列 非线性结构:树.图.多维数组 (二)按存储结构 顺序(数组)储结构.链式储结构.索引储结构.散列储结构 二.二叉树相关性质

js数据结构与算法存储结构

数据结构(程序设计=数据结构+算法) 数据结构就是关系,没错,就是数据元素相互之间存在的一种或多种特定关系的集合. 传统上,我们把数据结构分为逻辑结构和物理结构. 逻辑结构:是指数据对象中数据元素之间的相互关系,也是我们今后最需要关注和讨论的问题. 物理结构:是指数据的逻辑结构在计算机中的存储形式. 常用的数据结构有: 数组,队列(queue),堆(heap),栈(stack),链表(linked list ),树(tree),图(graph)和散列表(hash) 栈(stack):运算只在表的

数据结构与算法--二叉树(一)

1 基于二叉链表的有序二叉树 1.1 问题 BST是Binary Search Tree的缩写,译为二叉搜索树,或有序二叉树,是二叉树的一种,它的定义如下: 1)或者是一棵空树: 2)或者是具有下列性质的二叉树: I) 若左子树不空,则左子树上所有结点的值均小于它的根结点的值: II) 若右子树不空,则右子树上所有结点的值均大于它的根结点的值: III)左.右子树也分别为二叉排序树: BST在查找一个结点或插入一个结点时,具有极大的优势,速度非常快.是一种基础性数据结构,广泛应用于更加抽象的集合

数据结构与算法 —— 二叉树

二叉树 定义: 来自于百度百科. 在计算机科学中,二叉树是每个节点最多有两个子树的树结构.通常子树被称作"左子树"(left subtree)和"右子树"(right subtree).二叉树常被用于实现二叉查找树和二叉堆. 二叉树的每个结点至多只有二棵子树(不存在度大于2的结点),二叉树的子树有左右之分,次序不能颠倒.二叉树的第i层至多有2^{i-1}个结点:深度为k的二叉树至多有2^k-1个结点:对任何一棵二叉树T,如果其终端结点数为n_0,度为2的结点数为n_

小甲鱼数据结构和算法-----二叉树的构建和前序遍历

题目要求:建立二叉树并输出每个字符所在的层数.如下图要求输出 A 在第一层 B.C 在第二层 D.E在第三层 代码如下: #include <stdio.h> #include <stdlib.h> typedef struct BiTNode { char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; // 创建一棵二叉树,约定用户遵照前序遍历的方式输入数据 void CreateBiTree(BiTree *T)

数据结构和算法——二叉树

树1.树的优点有序数组: 查找很快,二分法实现的查找所需要的时间为O(logN),遍历也很快,但是在有序数组中插入,删除却需要先 找到位置, 在把数组部分元素后移,效率并不高. 链表: 链表的插入和删除都是很快速的,仅仅需要改变下引用值就行了,时间仅为O(1),但是在链表中查找数据却需要遍历所有的元素, 这个效率有些慢了.树的优点: 树结合了有序数组和链表的优点,可以实现快速的查找,也可以快速的删除,查找. 树的一些专用术语: 路径: 顺着连接节点的边从一个节点到另一个节点的,所经过的所有节点的

【4】学习JS 数据结构与算法笔记

第一章 JS 简介 1. 环境搭建的三种方式 1. 下载浏览器 2. 使用 Web 服务器 ( XAMPP ) 3. 使用 Node.js 搭建 Web 服务器 4. 代码地址>> 2. JS 语法