二叉树算法

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>二叉树算法</title>
<script type="text/javascript">
window.onload = function () {
function Node(data, left, right) {
	this.data = data;
	this.left = left;
	this.right = right;
}

Node.prototype.show = function() {
	return this.data;
}

//建立一个二叉树
function BST() {
	this.root = null;
}

//二叉树的插入操作
BST.prototype.insert = function(data) {
	var n = new Node(data, null, null);
	if(this.root === null) {
		this.root = n;
	}else {
		var current = this.root;
		var parent;
		while(true) {
			parent = current;
			if(data < current.data) {
				current = current.left;
				if(current === null) {
					parent.left = n;
					break;
				}
			}else {
				current = current.right;
				if(current === null) {
					parent.right = n;
					break;
				}
			}
		}
	}
}

//二叉树的历遍操作
BST.prototype.inOrder = function(node) {
	if(!(node === null)) {
		this.inOrder(node.left);
		console.log(node.show());
		this.inOrder(node.right);
	}
}//中序历遍

BST.prototype.preOrder = function(node) {
	if(!(node === null)) {
		console.log(node.show());
		this.inOrder(node.left);
		this.inOrder(node.right);
	}
}//先序历遍

BST.prototype.postOrder = function(node) {
	if(!(node === null)) {
		this.inOrder(node.left);
		this.inOrder(node.right);
		console.log(node.show());
	}
}//后序历遍

BST.prototype.getMin = function() {
	var current = this.root;
	while(!(current.left === null)) {
		current = current.left;
	}
	return current.data;
}//获取最小值

BST.prototype.getMax = function() {
	var current = this.root;
	while(!(current.right === null)) {
		current = current.right;
	}
	return current.data;
}//获取最大值

BST.prototype.find = function(data) {
	var current = this.root;
	while(current !== null) {
		if(current.data === data) {
			return current.data;
		}else if(data < current.data) {
			current = current.left;
		}else {
			current = current.right;
		}
	}
	return null;
}//查找节点

BST.prototype.getSmallest = function(node) {
	if (node.left == null) {
	  return node;
	}
	else {
	  return this.getSmallest(node.left);
	}
}

//删除一个节点,需要传入一个root节点(根节点)
BST.prototype.remove = function(node, data) {
	if(node === null) {
		return null;
	}

	if(data == node.data) {
		if(node.left === null && node.right === null) {
			return null;
		}
		if(node.left === null) {
			return node.right;
		}
		if(node.right === null) {
			return node.left;
		}
		var tempNode = this.getSmallest(node.right);
		node.data = tempNode.data;
		node.right = remove(node.right, tempNode.data);
		return node;
	}else if(data < node.data) {
		node.left = this.remove(node.left, data);
		return node;
	}else {
		node.right = this.remove(node.right, data);
		return node;
	}
}
var num = new BST();
num.insert(23);
num.insert(45);
num.insert(16);
num.insert(37);
num.insert(3);
num.insert(99);
num.insert(22);
//console.log(num.root);
//num.inOrder(num.root);
//console.log(num.getMin());
//console.log(num.getMax());
num.inOrder(num.root);
console.log(num.remove(num.root,37));
num.inOrder(num.root);
}
</script>
</head>
<body>
</body>
</html>

  

时间: 2024-11-08 17:04:53

二叉树算法的相关文章

JavaScript实现二叉树算法

二叉树的遍历方式 分别为中序遍历(左子树->当前节点->右子树).前序遍历(当前节点->左子树->右子树).后序遍历(左子树->右子树->当前节点).下面使用JavaScript语言实现二叉树的三种遍历算法. 首先构造一个排序二叉树(即满足左子节点比父节点小,右子节点比父节点大的二叉树),然后对其分别进行中序.前序.后序遍历. 排序二叉树结构图如下图所示: 说明: 其中8为根节点(没有父节点的节点),4,.7.13为叶子节点(最后一层上没有子节点的节点),3.10.1.

python环境下使用mysql数据及数据结构和二叉树算法(图)

python环境下使用mysql数据及数据结构和二叉树算法(图):1 python环境下使用mysql2使用的是 pymysql库3 开始-->创建connection-->获取cursor-->操作-->关闭cursor->关闭connection->结束45 代码框架6 import pymysql.cursors7 ###连接数据库8 connection = pymysql.connect(host='127.0.0.1',port=3306,user='roo

js二叉树算法

二叉树(Binary Tree)是n(n>=0)个结点的有限集合,该集合或者为空集(空二叉树),或者由一个根结点和两棵互不相交的.分别称为根结点的左子树和右子树的二叉树组成. 二叉树的特点 每个结点最多有两棵子树,所以二叉树中不存在度大于2的结点.二叉树中每一个节点都是一个对象,每一个数据节点都有三个指针,分别是指向父母.左孩子和右孩子的指针.每一个节点都是通过指针相互连接的.相连指针的关系都是父子关系. 二叉树节点的定义 二叉树节点定义如下: struct BinaryTreeNode { i

史上最简明易懂非递归遍历二叉树算法

巧若拙(欢迎转载,但请注明出处:http://blog.csdn.net/qiaoruozhuo) 遍历二叉树的递归函数是体现了算法之美的高妙算法,思路清晰,代码简洁,读之赏心悦目.代码例如以下: 程序代码: void PreOrderTraverse_R(BiTree BT)//採用递归方式先序遍历二叉树BT { if(BT != NULL) { printf("%c", BT->data);//输出该结点(根结点) PreOrderTraverse_R(BT->lchi

二叉树算法总结

刷了几道二叉树的算法题,基本都可以用递归求出来,在可以使用回溯法的题目中,回溯法的时间开销比递归少. 递归调用分为两类:1.在根节点到叶子节点的路径中找出满足条件的值 2.在任意两个节点之间寻找满足条件的路径 根节点到叶子节点的路径选择 leetcode上有类似的题目, Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number. An example i

二叉树算法小结

= 导航 顶部 概述 准备工作 先序遍历法 中序遍历法 后序遍历法 层次遍历法 测试 总结 顶部 概述 准备工作 先序遍历法 中序遍历法 后序遍历法 层次遍历法 测试 总结 概述 遍历二叉树有前序,中序,后序三大方法算.对于二叉树的三种不同的遍历方式,用递归的方法很容易写出实现代码,对于非递归的遍历算法使用数据结构堆栈作为工具代替递归以节省时空开销,在经过节点是先将其压入栈,要到他第几次从栈中弹出是才访问它,对于前序来说,是一次,对于中序来说是两次,对于后序则是三次.下面介绍下二叉树的几种遍历算

分层遍历二叉树算法

分层遍历二叉树的集中情况 从上而下的打印 vector<vector<int>> printLevel(TreeNode *root) {          vector<vector<int>>  ret;     if(root == NULL) return ret;          queue<TreeNode *> q;     int size;     q.push_back(root);     while(!q.empty()

数据结构-5-平衡二叉树算法原理解析

平衡二叉树定义(AVL):它或者是一颗空树,或者具有以下性质的二叉树:它的左子树和右子树的深度之差的绝对值不超过1,且它的左子树和右子树都是一颗平衡二叉树. 平衡因子(bf):结点的左子树的深度减去右子树的深度,那么显然-1<=bf<=1; 很显然,平衡二叉树是在二叉排序树(BST)上引入的,就是为了解决二叉排序树的不平衡性导致时间复杂度大大下降,那么AVL就保持住了(BST)的最好时间复杂度O(logn),所以每次的插入和删除都要确保二叉树的平衡. 关于书上说的旋转操作的概念,一般人真的看不

java之二叉树算法

创建二叉树类 public class tree { int data; tree left; tree right; public tree(int data, tree left, tree right) { super(); this.data = data; this.left = left; this.right = right; } public tree(int data) { this.data=data; this.left=null; this.right=null; } p