数据结构C语言实现之二叉树
2007-10-24 11:57:04 来源:WEB开发网 #include <stdio.h>
#include <stdlib.h>
#define STACK_MAX_SIZE 30
#define QUEUE_MAX_SIZE 30
#ifndef elemType
typedef char elemType;
#endif
/************************************************************************/
/* 以下是关于二叉树操作的11个简单算法 */
/************************************************************************/
struct BTreeNode{
elemType data;
struct BTreeNode *left;
struct BTreeNode *right;
};
/* 1.初始化二叉树 */
void initBTree(struct BTreeNode* *bt)
{
*bt = NULL;
return;
}
/* 2.建立二叉树(根据a所指向的二叉树广义表字符串建立) */
void createBTree(struct BTreeNode* *bt, char *a)
{
struct BTreeNode *p;
struct BTreeNode *s[STACK_MAX_SIZE];/* 定义s数组为存储根结点指针的栈使用 */
int top = -1;/* 定义top作为s栈的栈顶指针,初值为-1,表示空栈 */
int k;/* 用k作为处理结点的左子树和右子树,k = 1处理左子树,k = 2处理右子树 */
int i = 0;/* 用i扫描数组a中存储的二叉树广义表字符串,初值为0 */
*bt = NULL;/* 把树根指针置为空,即从空树开始建立二叉树 */
/* 每循环一次处理一个字符,直到扫描到字符串结束符为止 */
while(a[i] != ''){
switch(a[i]){
case ' ':
break; /* 对空格不作任何处理 */
case '(':
if(top == STACK_MAX_SIZE - 1){
printf("栈空间太小! ");
exit(1);
}
top++;
s[top] = p;
k = 1;
break;
case ')':
if(top == -1){
printf("二叉树广义表字符串错误! ");
exit(1);
}
top--;
break;
case ',':
k = 2;
break;
default:
p = malloc(sizeof(struct BTreeNode));
p->data = a[i];
p->left = p->right = NULL;
if(*bt == NULL){
*bt = p;
}else{
if( k == 1){
s[top]->left = p;
}else{
s[top]->right = p;
}
}
}
i++; /* 为扫描下一个字符修改i值 */
}
return;
}
/* 3.检查二叉树是否为空,为空则返回1,否则返回0 */
int emptyBTree(struct BTreeNode *bt)
{
if(bt == NULL){
return 1;
}else{
return 0;
}
}
/* 4.求二叉树深度 */
int BTreeDepth(struct BTreeNode *bt)
{
if(bt == NULL){
return 0; /* 对于空树,返回0结束递归 */
}else{
int dep1 = BTreeDepth(bt->left); /* 计算左子树的深度 */
int dep2 = BTreeDepth(bt->right); /* 计算右子树的深度 */
if(dep1 > dep2){
return dep1 + 1;
}else{
return dep2 + 1;
}
}
}
/* 5.从二叉树中查找值为x的结点,若存在则返回元素存储位置,否则返回空值 */
elemType *findBTree(struct BTreeNode *bt, elemType x)
{
if(bt == NULL){
return NULL;
}else{
if(bt->data == x){
return &(bt->data);
}else{/* 分别向左右子树递归查找 */
elemType *p;
if(p = findBTree(bt->left, x)){
return p;
}
if(p = findBTree(bt->right, x)){
return p;
}
return NULL;
}
}
}
/* 6.输出二叉树(前序遍历) */
void printBTree(struct BTreeNode *bt)
{
/* 树为空时结束递归,否则执行如下操作 */
if(bt != NULL){
printf("%c", bt->data); /* 输出根结点的值 */
if(bt->left != NULL || bt->right != NULL){
printf("(");
printBTree(bt->left);
if(bt->right != NULL){
printf(",");
}
printBTree(bt->right);
printf(")");
}
}
return;
}
/* 7.清除二叉树,使之变为一棵空树 */
void clearBTree(struct BTreeNode* *bt)
{
if(*bt != NULL){
clearBTree(&((*bt)->left));
clearBTree(&((*bt)->right));
free(*bt);
*bt = NULL;
}
return;
}
/* 8.前序遍历 */
void preOrder(struct BTreeNode *bt)
{
if(bt != NULL){
printf("%c ", bt->data); /* 访问根结点 */
preOrder(bt->left); /* 前序遍历左子树 */
preOrder(bt->right); /* 前序遍历右子树 */
}
return;
}
/* 9.前序遍历 */
void inOrder(struct BTreeNode *bt)
{
if(bt != NULL){
inOrder(bt->left); /* 中序遍历左子树 */
printf("%c ", bt->data); /* 访问根结点 */
inOrder(bt->right); /* 中序遍历右子树 */
}
return;
}
/* 10.后序遍历 */
void postOrder(struct BTreeNode *bt)
{
if(bt != NULL){
postOrder(bt->left); /* 后序遍历左子树 */
postOrder(bt->right); /* 后序遍历右子树 */
printf("%c ", bt->data); /* 访问根结点 */
}
return;
}
/* 11.按层遍历 */
void levelOrder(struct BTreeNode *bt)
{
struct BTreeNode *p;
struct BTreeNode *q[QUEUE_MAX_SIZE];
int front = 0, rear = 0;
/* 将树根指针进队 */
if(bt != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = bt;
}
while(front != rear){ /* 队列非空 */
front = (front + 1) % QUEUE_MAX_SIZE; /* 使队首指针指向队首元素 */
p = q[front];
printf("%c ", p->data);
/* 若结点存在左孩子,则左孩子结点指针进队 */
if(p->left != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = p->left;
}
/* 若结点存在右孩子,则右孩子结点指针进队 */
if(p->right != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = p->right;
}
}
return;
}
/************************************************************************/
/*
int main(int argc, char *argv[])
{
struct BTreeNode *bt;/* 指向二叉树根结点的指针 */
char *b; /* 用于存入二叉树广义表的字符串 */
elemType x, *px;
initBTree(&bt);
printf("输入二叉树广义表的字符串: ");
/* scanf("%s", b); */
b = "a(b(c), d(e(f, g), h(, i)))";
createBTree(&bt, b);
if(bt != NULL)
printf(" %c ", bt->data);
printf("以广义表的形式输出: ");
printBTree(bt); /* 以广义表的形式输出二叉树 */
printf(" ");
printf("前序:"); /* 前序遍历 */
preOrder(bt);
printf(" ");
printf("中序:"); /* 中序遍历 */
inOrder(bt);
printf(" ");
printf("后序:"); /* 后序遍历 */
postOrder(bt);
printf(" ");
printf("按层:"); /* 按层遍历 */
levelOrder(bt);
printf(" ");
/* 从二叉树中查找一个元素结点 */
printf("输入一个待查找的字符: ");
scanf(" %c", &x); /* 格式串中的空格跳过空白字符 */
px = findBTree(bt, x);
if(px){
printf("查找成功:%c ", *px);
}else{
printf("查找失败! ");
}
printf("二叉树的深度为:");
printf("%d ", BTreeDepth(bt));
clearBTree(&bt);
return 0;
}
*/
#include<stdio.h>
#defineQUEUE_MAX_SIZE20
#defineSTACK_MAX_SIZE10
typedefintelemType;
#include"BT.c"
/************************************************************************/
/* 以下是关于二叉搜索树操作的4个简单算法 */
/************************************************************************/
/*1.查找*/
/*递归算法*/
elemType*findBSTree1(structBTreeNode*bst,elemTypex)
{
/*树为空则返回NULL*/
if(bst==NULL){
returnNULL;
}else{
if(x==bst->data){
return&(bst->data);
}else{
if(x<bst->data){ /*向左子树查找并直接返回*/
returnfindBSTree1(bst->left,x);
}else{ /*向右子树查找并直接返回*/
returnfindBSTree1(bst->right,x);
}
}
}
}
/*非递归算法*/
elemType*findBSTree2(structBTreeNode*bst,elemTypex)
{
while(bst!=NULL){
if(x==bst->data){
return&(bst->data);
}elseif(x<bst->data){
bst=bst->left;
}else{
bst=bst->right;
}
}
returnNULL;
}
/*2.插入*/
/*递归算法*/
voidinsertBSTree1(structBTreeNode**bst,elemTypex)
{
/*新建一个根结点*/
if(*bst==NULL){
structBTreeNode*p=(structBTreeNode*)malloc(sizeof(structBTreeNode));
p->data=x;
p->left=p->right=NULL;
*bst=p;
return;
}elseif(x<(*bst)->data){ /*向左子树完成插入运算*/
insertBSTree1(&((*bst)->left),x);
}else{ /*向右子树完成插入运算*/
insertBSTree1(&((*bst)->right),x);
}
}
/*非递归算法*/
voidinsertBSTree2(structBTreeNode**bst,elemTypex)
{
structBTreeNode*p;
structBTreeNode*t=*bst,*parent=NULL;
/*为待插入的元素查找插入位置*/
while(t!=NULL){
parent=t;
if(x<t->data){
t=t->left;
}else{
t=t->right;
}
}
/*建立值为x,左右指针域为空的新结点*/
p=(structBTreeNode*)malloc(sizeof(structBTreeNode));
p->data=x;
p->left=p->right=NULL;
/*将新结点链接到指针为空的位置*/
if(parent==NULL){
*bst=p; /*作为根结点插入*/
}elseif(x<parent->data){ /*链接到左指针域*/
parent->left=p;
}else{
parent->right=p;
}
return;
}
/*3.建立*/
voidcreateBSTree(structBTreeNode**bst,elemTypea[],intn)
{
inti;
*bst=NULL;
for(i=0;i<n;i++){
insertBSTree1(bst,a[i]);
}
return;
}
/*4.删除值为x的结点,成功返回1,失败返回0*/
intdeleteBSTree(structBTreeNode**bst,elemTypex)
{
structBTreeNode*temp=*bst;
if(*bst==NULL){
return0;
}
if(x<(*bst)->data){
returndeleteBSTree(&((*bst)->left),x); /*向左子树递归*/
}
if(x>(*bst)->data){
returndeleteBSTree(&((*bst)->right),x); /*向右子树递归*/
}
/*待删除的元素等于树根结点值且左子树为空,将右子树作为整个树并返回1*/
if((*bst)->left==NULL){
*bst=(*bst)->right;
free(temp);
return1;
}
/*待删除的元素等于树根结点值且右子树为空,将左子树作为整个树并返回1*/
if((*bst)->right==NULL){
*bst=(*bst)->left;
free(temp);
return1;
}else{
/*中序前驱结点为空时,把左孩子结点值赋给树根结点,然后从左子树中删除根结点*/
if((*bst)->left->right==NULL){
(*bst)->data=(*bst)->left->data;
returndeleteBSTree(&((*bst)->left),(*bst)->data);
}else{ /*定位到中序前驱结点,把该结点值赋给树根结点,然后从以中序前驱结点为根的
树上删除根结点*/
structBTreeNode*p1=*bst,*p2=p1->left;
while(p2->right!=NULL){
p1=p2;
p2=p2->right;
}
(*bst)->data=p2->data;
returndeleteBSTree(&(p1->right),p2->data);
}
}
}
/************************************************************************/
intmain(intargc,char*argv[])
{
intx,*px;
elemTypea[10]={30,50,20,40,25,70,54,23,80,92};
structBTreeNode*bst=NULL;
createBSTree(&bst,a,10);
printf("建立的二叉搜索树的广义表形式为: ");
printBTree(bst);
printf(" ");
printf("中序遍历: ");
inOrder(bst);
printf(" ");
printf("输入待查找元素的值:");
scanf("%d",&x);
if(px=findBSTree1(bst,x)){
printf("查找成功!得到的x为:%d ",*px);
}else{
printf("查找失败! ");
}
printf("输入待插入的元素值:");
scanf("%d",&x);
insertBSTree1(&bst,x);
printf("输入待删除元素值:");
scanf("%d",&x);
if(deleteBSTree(&bst,x)){
printf("1 ");
}else{
printf("0 ");
}
printf("进行相应操作后的中序遍历为: ");
inOrder(bst);
printf(" ");
printf("操作后的二叉搜索树的广义表的形式为: ");
printBTree(bst);
printf(" ");
clearBTree(&bst);
return0;
}
更多精彩
赞助商链接