二叉树实现

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <stack>
#include <queue>

using namespace std;

template <typename T>
struct node {
	struct node *ln; 
	struct node *rn; 
	struct node *pn; 
	T val;
};

template <typename T>
class MyBST {
private:
	struct node<T> *root;

private:
	void pre_walk_recv(struct node<T> *root);
	void in_walk_recv(struct node<T> *root);
	void post_walk_recv(struct node<T> *root);
	struct node<T>* minimum_internal(struct node<T> *root);
	struct node<T>* maximum_internal(struct node<T> *root);

public:
	MyBST();
	void pre_walk();
	void in_walk();
	void post_walk();
	void pre_walk_iter();
	void in_walk_iter();
	void post_walk_iter();
	void dfs_walk();
	void dfs_order_walk();
	void insert(T val);
	int minimum();
	int maximum();
	struct node<T>* search(int val);
	struct node<T>* predecessor(struct node<T> *n);
	struct node<T>* successor(struct node<T> *n);
	void remove(struct node<T> *n);
};

template <typename T>
void MyBST<T>::pre_walk_recv(struct node<T> *root)
{
	if(root == NULL)
		return;
	printf("%d ", root->val);
	pre_walk_recv(root->ln);
	pre_walk_recv(root->rn);
}

template <typename T>
void MyBST<T>::in_walk_recv(struct node<T> *root)
{
	if(root == NULL)
		return;
	in_walk_recv(root->ln);
	printf("%d ", root->val);
	in_walk_recv(root->rn);
}

template <typename T>
void MyBST<T>::post_walk_recv(struct node<T> *root)
{
	if(root == NULL)
		return;
	post_walk_recv(root->ln);
	post_walk_recv(root->rn);
	printf("%d ", root->val);
}

template <typename T>
MyBST<T>::MyBST()
{
	root = NULL;
}

template <typename T>
void MyBST<T>::pre_walk()
{
	pre_walk_recv(root);
	printf("\n");
}

template <typename T>
void MyBST<T>::in_walk()
{
	in_walk_recv(root);
	printf("\n");
}

template <typename T>
void MyBST<T>::post_walk()
{
	post_walk_recv(root);
	printf("\n");
}

template <typename T>
void MyBST<T>::insert(T val)
{
	struct node<T> *n = (struct node<T> *)malloc(sizeof(struct node<T>));
	n->ln = NULL;
	n->rn = NULL;
	n->pn = NULL;
	n->val = val;

	if(root == NULL) {
		root = n;
		return;
	}

	struct node<T> *tmp = root;
	while(tmp != NULL) {
		if(n->val <= tmp->val) {
			if(tmp->ln == NULL) {
				tmp->ln = n;
				n->pn = tmp;
				return;
			}
			else {
				tmp = tmp->ln;
			}
		}
		else {
			if(tmp->rn == NULL) {
				tmp->rn = n;
				n->pn = tmp;
				return;
			}
			else {
				tmp = tmp->rn;
			}
		}
	}
}

template <typename T>
struct node<T>* MyBST<T>::minimum_internal(struct node<T> *root)
{
	struct node<T> *tmp = root;
	while(tmp->ln != NULL)
		tmp = tmp->ln;
	return tmp;
}

template <typename T>
struct node<T>* MyBST<T>::maximum_internal(struct node<T> *root)
{
	struct node<T> *tmp = root;
	while(tmp->rn != NULL)
		tmp = tmp->rn;
	return tmp;
}

template <typename T>
int MyBST<T>::minimum()
{
	return minimum_internal(root)->val;
}

template <typename T>
int MyBST<T>::maximum()
{
	return maximum_internal(root)->val;
}

template <typename T>
struct node<T>* MyBST<T>::search(int val)
{
	struct node<T> *tmp = root;
	while(tmp != NULL) {
		if(tmp->val == val)
			break;
		if(val < tmp->val)
			tmp = tmp->ln;
		else
			tmp = tmp->rn;
	}
	return tmp;
}

template <typename T>
struct node<T>* MyBST<T>::predecessor(struct node<T> *n)
{
	if(n->ln != NULL)
		return maximum_internal(n->ln); 

	struct node<T> *pred = n->pn;
	while(pred!=NULL && pred->ln==n) {
		n = pred;
		pred = pred->pn;
	}

	return pred;
}

template <typename T>
struct node<T>* MyBST<T>::successor(struct node<T> *n)
{
	if(n->rn != NULL)
		return minimum_internal(n->rn);

	struct node<T> *pred = n->pn;
	while(pred!=NULL && pred->rn==n) {
		n  = pred;
		pred = pred->pn;
	}

	return pred;
}

template <typename T>
void MyBST<T>::remove(struct node<T> *n)
{
	struct node<T> *tmp;

	// if one of children is NULL
	if(n->ln==NULL || n->rn==NULL) {
		if(n->ln == NULL)
			tmp = n->rn;
		else
			tmp = n->ln;

		if(n != root) {
			struct node<T> *pn = n->pn;
			if(pn->ln == n)
				pn->ln = tmp;
			else
				pn->rn = tmp;
			if(tmp != NULL)
				tmp->pn = pn;
		} else {
			root = tmp;
			if(tmp != NULL)
				root->pn = NULL;
		}
		free(n);
		return;
	}

	// if both children are not NULL
	tmp = minimum_internal(n->rn);
	n->val = tmp->val;
	if(tmp == tmp->pn->ln)
		tmp->pn->ln = tmp->rn;
	else
		tmp->pn->rn = tmp->rn;
	if(tmp->rn != NULL)
		tmp->rn->pn = tmp->pn;
	free(tmp);

	return;
}

template <typename T>
void MyBST<T>::pre_walk_iter()
{
	struct node<T> *tmp = root;
	stack< struct node<T>* > stk;	

	while(1) {
		while(tmp != NULL) {
			printf("%d ", tmp->val);
			if(tmp->rn != NULL)
				stk.push(tmp);
			tmp = tmp->ln;
		}

		if(!stk.empty()) {
			tmp = stk.top()->rn;
			stk.pop();
		} else {
			break;
		}
	}

	printf("\n");
}

template <typename T>
void MyBST<T>::in_walk_iter()
{
	struct node<T>* tmp = root;
	stack< struct node<T>* > stk;

	while(1) {
		while(tmp != NULL) {
			stk.push(tmp);
			tmp = tmp->ln;
		}

		if(!stk.empty()) {
			printf("%d ", stk.top()->val);
			tmp = stk.top()->rn;
			stk.pop();
		} else {
			break;
		}
	}

	printf("\n");
}

template <typename T>
void MyBST<T>::post_walk_iter()
{
	struct node<T> *tmp = root;
	stack< struct node<T>* > stk;
	stack<T> ot;

	while(1) {
		while(tmp != NULL) {
			ot.push(tmp->val);
			stk.push(tmp);
			tmp = tmp->rn;
		}

		if(!stk.empty()) {
			tmp = stk.top()->ln;
			stk.pop();
		} else {
			break;
		}
	}

	while(!ot.empty()) {
		printf("%d ", ot.top());
		ot.pop();
	}
	printf("\n");
}

template <typename T>
void MyBST<T>::dfs_walk()
{
	struct node<T> *tmp = root;
	queue< struct node<T>* > q;
	q.push(tmp);

	while(!q.empty()) {
		tmp = q.front();
		q.pop();
		printf("%d ", tmp->val);
		if(tmp->ln != NULL)
			q.push(tmp->ln);
		if(tmp->rn != NULL)
			q.push(tmp->rn);
	}

	printf("\n");
}

template <typename T>
void MyBST<T>::dfs_order_walk()
{
	struct node<T> *tmp = root;
	queue< struct node<T>* > q1;
	queue<int> q2;
	q1.push(tmp);
	q2.push(0);
	int cd = 0;

	while(!q1.empty()) {
		tmp = q1.front();
		if(q2.front() > cd) {
			printf("\n");
			cd++;
		}
		q1.pop();
		q2.pop();
		printf("%d ", tmp->val);
		if(tmp->ln != NULL) {
			q1.push(tmp->ln);
			q2.push(cd+1);
		}
		if(tmp->rn != NULL) {
			q1.push(tmp->rn);
			q2.push(cd+1);
		}
	}

	printf("\n");
}

int main(int argc, char **argv)
{
	MyBST<int> mb;

	mb.insert(10);
	mb.insert(5);
	mb.insert(17);
	mb.insert(4);
	mb.insert(8);
	mb.insert(22);
	mb.insert(6);
	mb.insert(9);
	mb.insert(20);
	mb.insert(7);
	mb.insert(15);
	mb.insert(16);

	printf("RECV:\n");
	mb.pre_walk();
	mb.in_walk();
	mb.post_walk();
	printf("ITER:\n");
	mb.pre_walk_iter();
	mb.in_walk_iter();
	mb.post_walk_iter();
	printf("DFS:\n");
	mb.dfs_walk();
	printf("ORDER:\n");
	mb.dfs_order_walk();

	printf("minimum: %d\n", mb.minimum());
	printf("maximum: %d\n", mb.maximum());

	int target = 4;
	struct node<int> *tmp = mb.search(target);
	printf("search for %d is %d\n", target, tmp->val);
	struct node<int> *pred = mb.predecessor(tmp);
	struct node<int> *succ = mb.successor(tmp);
	printf("pred: %d\n", pred==NULL?-999:pred->val);
	printf("succ: %d\n", succ==NULL?-999:succ->val);

	mb.remove(tmp);

	//target = 16;
	//tmp = mb.search(target);
	//printf("search for %d is %d\n", target, tmp->val);
	//
	//mb.remove(tmp);

	mb.pre_walk();
	mb.in_walk();
	mb.post_walk();

	return 0;
}

时间： 2024-09-20 16:52:21

二叉树实现的相关文章

C#实现二叉树的遍历

C#实现二叉树的前序.中序.后序遍历. public class BinaryTreeNode { int value; BinaryTreeNode left; BinaryTreeNode right; /// <summary> /// 前序遍历 /// </summary> /// <param name="tree">&l

简介遍历二叉树就是按照某种顺序,将树中的结点都枚举一遍,且每个结点仅仅访问一次.因为树不是线性的结构,遍历不像线性表那样简单,因此他的遍历需要特点的算法来完成. 从某种角度讲,对二叉树的遍历就是将树形结构转换为线性结构的操作. 二叉树的遍历方法主要有如下几种: 先序遍历:先访问root结点,再先序遍历左子树,再先序遍历右子树. 中序遍历:先中序遍历左子树,再访问root结点,再中序遍历右子树. 后序遍历:先后序遍历左子树,再后序遍历右子树,再访问root结点. 层遍历:从上到下,从左到右,一层

按之字形顺序打印二叉树

题目描述请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ class Solution { public: vector<vect

【数据算法】Java实现二叉树存储以及遍历

二叉树在java中我们使用数组的形式保存原数据,这个数组作为二叉树的数据来源,后续对数组中的数据进行节点化操作. 步骤就是原数据:数组节点化数据:定义 Node节点对象存储节点对象:通过LinkedList保存Node节点对象在操作过程中我们需要将当前结点和前一节点.后一节点进行关系绑定 package tree; import java.util.LinkedList; import java.util.List; /** * 功能:把一个数组的值存入二叉树中,然后进行3种方式的遍历 *

二叉树的后序遍历（暴力版）小白菜oj 1034

给出二叉树的前序遍历和中序遍历,求二叉树的后序遍历-- 作为一个搜索蒟蒻,我真的没有办法很和谐的A掉,但估计过几天就会写有关这个题的和谐的解法--但只是估计-- 下面讲述我的超暴力解法-- 首先,先由前序遍历得到一个父亲节点,然后再由中序遍历得到这个父亲节点的左子树和右子树中的元素(中序遍历中,该点的左边的所有点,都在它的左子树,右边的都在它的右子树,子树中的根节点是在这些节点的前序遍历中排名最靠前的),然后递归建树,之后在递归求后序遍历即可. 但这个方法有两个比较--&￥--&的问题:1

二叉树的序列化和反序列化

http://blog.csdn.net/qq_27703417/article/details/70958692 先序遍历二叉树,如果遇到空节点,就在str的末尾加上"#!","#"表示这个节点为空,节点值不存在,当然你也可以用其他的特殊字符,"!"表示一个值的结束.如果遇到不为空的节点,假设节点值为3,就在str的末尾加上"3!".现在请你实现树的先序序列化. 先序遍历 import java.util.*; //使用递归

【二叉树】二叉树基础

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

二叉树的深度

输入一棵二叉树,求该树的深度.从根结点到叶结点依次经过的结点(含根.叶结点)形成树的一条路径,最长路径的长度为树的深度. 思路:使用递归的方法分别计算左右子树的深度 public class Solution { public int TreeDepth(TreeNode pRoot){ return pRoot == null? 0 : Math.max(TreeDepth(pRoot.left),TreeDepth(pRoot.right)) + 1; } }

226反转二叉树 Invert Binary Tree

Invert a binary tree. 4 / 2 7 / \ / 1 3 6 9 to 4 / 7 2 / \ / 9 6 3 1 Trivia:This problem was inspired by this original tweet by Max Howell: Google: 90% of our engineers use the software you wrote (Homebrew), but you can't invert a binary tree on a wh

树、二叉树、森林的转换

树转换为二叉树 (1)加线.在所有兄弟结点之间加一条连线. (2)去线.树中的每个结点,只保留它与第一个孩子结点的连线,删除它与其它孩子结点之间的连线. (3)层次调整.以树的根节点为轴心,将整棵树顺时针旋转一定角度,使之结构层次分明.(注意第一个孩子是结点的左孩子,兄弟转换过来的孩子是结点的右孩子) 森林转换为二叉树 (1)把每棵树转换为二叉树. (2)第一棵二叉树不动,从第二棵二叉树开始,依次把后一棵二叉树的根结点作为前一棵二叉树的根结点的右孩子,用线连接起来. 二叉树转换为树是树转换为二