排序二叉树

最新推荐文章于 2020-01-09 20:18:58 发布
最新推荐文章于 2020-01-09 20:18:58 发布
阅读量216 收藏 1
点赞数
分类专栏： # 数据结构 文章标签： 排序二叉树 前序遍历 中序遍历 后序遍历 二叉树查找节点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013565133/article/details/103683159
版权

这是二叉树参考图：
在这里插入图片描述

构建排序二叉树

function BinaryTree() {
    var Node = function (key) {
        this.key = key;
        this.left = null;
        this.right = null;
    };

    var root = null;
    var insertNode = function (node, newNode) {
        if (newNode.key < node.key) {
            if (node.left === null) {
                node.left = newNode;
            } else {
                insertNode(node.left, newNode);
            }
        } else if (newNode.key > node.key) {
            if (node.right === null) {
                node.right = newNode;
            } else {
                insertNode(node.right, newNode);
            }
        }
    }
    this.insert = function (key) {
        var newNode = new Node(key);
        if (root === null) {
            root = newNode;
        } else {
            insertNode(root, newNode);
        }
        return root;
    }
}

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

上面是构建一个排序好的二叉树，下面是从构建好的排序二叉树中获取相关节点的信息，这就需要遍历，遍历有三种方法：中序遍历，前序遍历和后序遍历。

中序遍历排序

function BinaryTree() {
    var Node = function (key) {
        this.key = key;
        this.left = null;
        this.right = null;
    };

    var root = null;
    var insertNode = function (node, newNode) {
        if (newNode.key < node.key) {
            if (node.left === null) {
                node.left = newNode;
            } else {
                insertNode(node.left, newNode);
            }
        } else if (newNode.key > node.key) {
            if (node.right === null) {
                node.right = newNode;
            } else {
                insertNode(node.right, newNode);
            }
        }
    }
    this.insert = function (key) {
        var newNode = new Node(key);
        if (root === null) {
            root = newNode;
        } else {
            insertNode(root, newNode);
        }
        return root;
    }

    //中序遍历
    var inOrderTraverseNode = function(node,callback){
        if(node){
            inOrderTraverseNode(node.left,callback);
            callback(node.key);
            inOrderTraverseNode(node.right,callback);
        }
    }
    this.inOrderTraverse = function(callback){
        inOrderTraverseNode(root,callback);
    }
}

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

var callback = function(key){
    console.log(key);
}

binaryTree.inOrderTraverse(callback);

中序遍历是先访问当前节点的左节点，然后访问当前节点自己，最后访问当前节点的右节点

前序遍历复制已有的二叉树

相比重新生成二叉树，通过前序遍历复制之前生成好的二叉树效率会更高。

function BinaryTree() {
    var Node = function (key) {
        this.key = key;
        this.left = null;
        this.right = null;
    };

    var root = null;
    var insertNode = function (node, newNode) {
        if (newNode.key < node.key) {
            if (node.left === null) {
                node.left = newNode;
            } else {
                insertNode(node.left, newNode);
            }
        } else if (newNode.key > node.key) {
            if (node.right === null) {
                node.right = newNode;
            } else {
                insertNode(node.right, newNode);
            }
        }
    }
    this.insert = function (key) {
        var newNode = new Node(key);
        if (root === null) {
            root = newNode;
        } else {
            insertNode(root, newNode);
        }
        return root;
    }

    //中序遍历
    var inOrderTraverseNode = function (node, callback) {
        if (node) {
            inOrderTraverseNode(node.left, callback);
            callback(node.key);
            inOrderTraverseNode(node.right, callback);
        }
    }
    this.inOrderTraverse = function (callback) {
        inOrderTraverseNode(root, callback);
    }

    //前序遍历
    var preOrderTraverseNode = function (node, callback) {
        if (node) {
            callback(node.key);
            preOrderTraverseNode(node.left, callback);
            preOrderTraverseNode(node.right, callback);
        }
    }
    this.preOrderTraverse = function (callback) {
        preOrderTraverseNode(root, callback);
    }
}

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

var callback = function (key) {
    console.log(key);
}

//这里调用不同的方法测试
binaryTree.preOrderTraverse(callback);

前序遍历是先访问当前节点自己，然后访问当前节点的左节点，最后访问当前节点的右节点。

后序遍历

后序遍历是先访问当前节点的左节点，然后访问当前节点的右节点，最后访问当前节点自己。

二叉树节点查找

  • 查找最小值和最大值
  • 查找某个给定的数值在二叉树中是否存在
function BinaryTree() {
    var Node = function (key) {
        this.key = key;
        this.left = null;
        this.right = null;
    };

    var root = null;
    var insertNode = function (node, newNode) {
        if (newNode.key < node.key) {
            if (node.left === null) {
                node.left = newNode;
            } else {
                insertNode(node.left, newNode);
            }
        } else if (newNode.key > node.key) {
            if (node.right === null) {
                node.right = newNode;
            } else {
                insertNode(node.right, newNode);
            }
        }
    }
    this.insert = function (key) {
        var newNode = new Node(key);
        if (root === null) {
            root = newNode;
        } else {
            insertNode(root, newNode);
        }
        return root;
    }

    //中序遍历
    var inOrderTraverseNode = function (node, callback) {
        if (node) {
            inOrderTraverseNode(node.left, callback);
            callback(node.key);
            inOrderTraverseNode(node.right, callback);
        }
    }
    this.inOrderTraverse = function (callback) {
        inOrderTraverseNode(root, callback);
    }

    //前序遍历
    var preOrderTraverseNode = function (node, callback) {
        if (node) {
            callback(node.key);
            preOrderTraverseNode(node.left, callback);
            preOrderTraverseNode(node.right, callback);
        }
    }
    this.preOrderTraverse = function (callback) {
        preOrderTraverseNode(root, callback);
    }

    //查找最小值
    var minNode = function (node) {
        if (node) {
            while (node && node.left !== null) {
                node = node.left;
            }
            return node.key;
        }
        return null;
    }

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

    //查找最大值
    var maxNode = function (node) {
        if (node) {
            while (node && node.right !== null) {
                node = node.right;
            }
            return node.key;
        }
        return null;
    }
    this.max = function () {
        return maxNode(root);
    }

    //查找给定值的节点
    //在searchNode递归前面加return，退出上一轮 `searchNode`，以免产生调用栈，如果不加 `return` 那在结束之后是是会层层回退到第一次调用，返回其结果。
    var searchNode = function (node, key) {
        if (!node) {
            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.search = function (key) {
        return searchNode(root, key);
    }
}

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

var callback = function (key) {
    console.log(key);
}

//这里调用不同的方法测试
binaryTree.preOrderTraverse(callback);
console.log(binaryTree.min());
console.log(binaryTree.max());
console.log(binaryTree.search(7));
背太阳的牧羊人
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树排序二叉树排序
12-26
二叉树排序二叉树排序二叉树排序二叉树排序二叉树排序二叉树排序二叉树排序
一步一步写算法（之排序二叉树）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
10-10 4万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     前面我们讲过双向链表的数据结构。每一个循环节点有两个指针，一个指向前面一个节点，一个指向后继节点，这样所有的节点像一颗颗珍珠一样被一根线穿在了一起。然而今天
二叉树，排序二叉树
心如止水-GISer的成长之路
08-29 6381
说到二叉树，这可是数据结构里面的非常重要的一种数据结构，二叉树是树的一种，本身具有递归性质，所以基于二叉树的一些算法很容易用递归算法去实现。作为一种非线性结构，比起线性结构还是相对复杂的，很多人甚至看不懂算法的意思，不能理解。其实一开始接触这些东西还是挺晕的，不过你多看几遍，上机实现可能你就会觉得没那么复杂。因为你最后会发现，这些数据结构对于提高程序设计的能力有很大帮助，也是软件开发中必不可少的。
使用JavaScript实现的排序二叉树.zip
最新发布
04-26
在计算机科学中，排序二叉树（Sorted Binary Tree）是一种特殊的二叉树数据结构，它满足以下特性：每个节点的左子树上所有节点的值都小于当前节点的值，而右子树上所有节点的值都大于当前节点的值。这种特性使得排序...
PHP排序二叉树基本功能实现方法示例
10-18
首先，我们要了解排序二叉树的概念。排序二叉树是一种特殊的二叉树，其中每个节点的左子节点的值小于其父节点，而右子节点的值大于其父节点。这种结构使得排序二叉树具有自动排序的特性，方便进行查找、插入和删除...
JavaScript排序二叉树
05-05
简单的JavaScript排序二叉树，方便理解，由浅入深学习必备
PHP ClassObject — PHP 自排序二叉树的深入解析
12-19
在自排序二叉树中，每个节点的左子树包含所有小于当前节点值的元素，而右子树包含所有大于当前节点值的元素。这样，当新元素插入时，它们会自动找到正确的位置，使得树保持有序状态。 为了实现自排序二叉树，我们...
二叉树排序
那时初见 的专栏
06-02 535
二叉树排序// 二叉树排序.cpp : 定义控制台应用程序的入口点。 //#include "stdafx.h" #include<stdio.h> #include<stdlib.h> #include<windows.h>struct data{ int num; struct data* lbaby, *rbaby; }*root, *tree, *leaf;void find
二叉树的排序
cxy_12s的博客
01-09 1007
一. 二叉树定义 二叉树是一个连通的无环图，并且每一个顶点的度不大于3。有根二叉树还要满足根结点的度不大于2。有了根结点之后，每个顶点定义了唯一的父结点，和最多2个子结点。然而，没有足够的信息来区分左结点和右结点。如果不考虑连通性，允许图中有多个连通分量，这样的结构叫做森林。 二. 二叉树类型 (1) 完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大...
c语言清空排序二叉树
07-28
要清空排序二叉树（Binary Search Tree，BST），可以执行以下步骤： 1. 创建一个函数，用于删除二叉树的节点。函数可以使用递归来实现。 2. 在删除函数中，首先检查当前节点是否为空。如果为空，则返回。 3. 如果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值