都是常用的功能。

删除是最复杂的。。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>test</title>
    <script src="js/lib/angular.min.js"></script>
    <script >
        function BinarySearchTree(){
            var Node = function(key){
                this.key = key;
                this.left = null;
                this.right = null;
            };
            var root = null;

            this.insert = function(key){
                var newNode = new Node(key);

                if (root === null) {
                    root = newNode;
                } else {
                    insertNode(root, newNode);
                }
            };

            var insertNode = function(node, newNode) {
                if (newNode.key < node.key) {
                    if (node.left === null) {
                        node.left = newNode;
                    } else {
                        insertNode(node.left, newNode);
                    }
                }else{
                    if (node.right == null) {
                        node.right = newNode;
                    } else {
                        insertNode(node.right, 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 = function (node, callback) {
                        if (node !== null) {
                            callback(node.key); //{1}
                            preOrderTraverseNode(node.left, callback); //{2}
                            preOrderTraverseNode(node.right, callback); //{3}
                        }
                    };

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

            var postOrderTraverseNode = function (node, callback) {
                        if (node !== null) {
                            postOrderTraverseNode(node.left, callback); //{1}
                            postOrderTraverseNode(node.right, callback); //{2}
                            callback(node.key); //{3}
                        }
                    };

                    this.min = function() {
                        return minNode(root);
                    };

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

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

                    var maxNode = function (node) {
                        if (node){
                            while (node && node.right !== null) { //{5}
                                node = node.right;
                            }
                            return node.key;
                        }
                        return null;
                    };

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

                    var searchNode = function(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) {
                        root = removeNode(root, key);
                    };

                    var removeNode = function(node, key){
                        if (node === null){ //{2}
                            return null;
                        }
                        if (key < node.key){ //{3}
                            node.left = removeNode(node.left, key); //{4}
                            return node; //{5}
                        } else if (key > node.key){ //{6}
                            node.right = removeNode(node.right, key); //{7}
                            return node; //{8}
                        } else { //键等于node.key
                            //第一种情况——一个叶节点
                            if (node.left === null && node.right === null){ //{9}
                            node = null; //{10}
                            return node; //{11}
                            }
                            //第二种情况——一个只有一个子节点的节点
                            if (node.left === null){ //{12}
                            node = node.right; //{13}
                            return node; //{14}
                            } else if (node.right === null){ //{15}
                            node = node.left; //{16}
                            return node; //{17}
                            }
                            //第三种情况——一个有两个子节点的节点
                            var aux = findMinNode(node.right); //{18}
                            node.key = aux.key; //{19}
                            node.right = removeNode(node.right, aux.key); //{20}
                            return node; //{21}
                        }
                    };

        }

        function printNode(value) {
                console.log(value);
        }

          var tree = new BinarySearchTree();
          tree.insert(11);
          tree.insert(7);
                tree.insert(15);
                tree.insert(5);
                tree.insert(3);
                tree.insert(9);
                tree.insert(8);
                tree.insert(10);
                tree.insert(13);
                tree.insert(12);
                tree.insert(14);
                tree.insert(20);
                tree.insert(18);
                tree.insert(25);
                tree.insert(6);

                tree.inOrderTraverse(printNode);
                tree.preOrderTraverse(printNode);
                tree.postOrderTraverse(printNode);
                console.log(tree.min());
                console.log(tree.max());
                console.log(tree.search(1) ? 'Key 1 found.' : 'Key 1 not found.');
                console.log(tree.search(8) ? 'Key 8 found.' : 'Key 8 not found.');

    </script>

</head>
<body>

</body>
</html>

javascript二叉树基本功能实现的更多相关文章

  1. javascript二叉树

    javascript中的二叉树一(binary tree) 毕业也快2年了,毕业之后就没有认真写过博客了,都是那里学习一下,这里弄一下.学习了也不做笔记,过后就忘记了.我对这种状态打从心里是讨厌的. ...

  2. javascript 自动填充功能

    javascript 自动填充功能 javascript: (function(){ $("#zipcode").val("zip");$("#pho ...

  3. javascript的倒计时功能中newData().getTime()在iOS下会报错问题解决

    javascript的倒计时功能中newData().getTime()在iOS下会报错问题解决 在做移动端时间转化为时间戳时,遇到了一个问题,安卓手机上访问时,能拿到时间戳,从而正确转换时间,而在i ...

  4. javascript 页面导出功能

    javascript 页面导出功能 <a class="btn" href="javascript:void(0);" onclick="win ...

  5. JavaScript ES6 核心功能一览(转)

    原文地址:Overview of JavaScript ES6 features (a.k.a ECMAScript 6 and ES2015+) 原文作者:Adrian Mejia 译文出自:掘金翻 ...

  6. Javascript中暂停功能的实现

    <script language="javascript"> /*Javascript中暂停功能的实现 Javascript本身没有暂停功能(sleep不能使用)同时 ...

  7. Javascript自定义事件功能与用法实例分析

    原文地址:https://www.jb51.net/article/127776.htm 本文实例讲述了javascript自定义事件功能与用法.分享给大家供大家参考,具体如下: 概述 自定义事件很难 ...

  8. 如何编写 Cloud9 JavaScript IDE 的功能扩展

    上周末我们在JSConf.eu发布了 Cloud9 IDE ,同时发布了对应的GitHub项目.在4天时间里该项目得到340个人的关注和将近50个fork.Cloud9的口号是由"由Java ...

  9. 手机开发必备技巧:javascript及CSS功能代码分享

    1. viewport: 也就是可视区域.对于桌面浏览器,我们都很清楚viewport是什么,就是出去了所有工具栏.状态栏.滚动条等等之后用于看网页的区域,这是真正有效的区域.由于移动设备屏幕宽度不同 ...

随机推荐

  1. 极大似然估计、贝叶斯估计、EM算法

    参考文献:http://blog.csdn.net/zouxy09/article/details/8537620 极大似然估计 已知样本满足某种概率分布,但是其中具体的参数不清楚,极大似然估计估计就 ...

  2. DEDECMS 5.7之前版本远程SQL注入漏洞

    2012/4/29 凌晨 知道创宇安全研究团队截获到最新DEDECMS SQL注入 0day,官网目前提供下载的最新版5.7也受影响,截止本告警发出时官方尚未给出补丁或解决方案,此漏洞利用简单且ded ...

  3. PHP中的替代语法(转)

    我们经常在wordpress一类博客程序的模板里面看到很多奇怪的PHP语法,比如: <?php if(empty($GET_['a'])): ?> <font color=" ...

  4. derby数据库操作比较难理解的错误及解决方法大全

    一.插入(INSERT时报错) 1.错误:java.sql.SQLIntegrityConstraintViolationException: 列“test”无法接受空值. 可能原因:建表时test列 ...

  5. 新浪微博客户端(23)-计算Cell内控件的frame

    DJStatusCellFrame.m #import "DJStatusCellFrame.h" #import "DJStatus.h" #import & ...

  6. Array和ArrayList互相转换

    class Order{ public string orderId; public string orderName; public decimal orderPrice; } public cla ...

  7. [Effective JavaScript 笔记]第5章:数组和字典--个人总结

    前言 这节里其实一直都在讨论对象这个在js中的万能的数据结构.对象可以表式为多种的形式,表示为字典和数组之间的区别.更多的我觉得这章讨论多的是一些对应实现功能的相关操作,有可能出现的bug以及如何避免 ...

  8. 使用nginx的proxy_cache做网站缓存

    为什么要做web cache,我想大家最主要的是解决流量的压力.随着网站流量的提升,如果只是单台机器既处理静态文件,又处理动态脚本,显然效率很难上升,不能处理日益上涨的流量压力.与此同时某些网站的页面 ...

  9. 【Spring】Spring系列2之bean的配置

    2.bean的配置 2.1.IOC概述 2.2.bean的获取 2.3.依赖注入方式 2.4.属性注入细节 内部bean,不需要ID,ID无效,外部不能引用: 2.5.集合属性注入 2.6.使用p命名 ...

  10. 【SpringMVC】SpringMVC系列7之POJO 对象绑定请求参数值

      7.POJO 对象绑定请求参数值 7.1.概述 Spring MVC 会按请求参数名和 POJO 属性名进行自动匹配,自动为该对象填充属性值.而且支持级联属性.如:dept.deptId.dept ...