WEB开发网
开发学院软件开发数据结构 数据结构C语言实现之二叉树 阅读

数据结构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 // /*以下是关于

  #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;
   }

Tags:数据结构 实现

编辑录入:爽爽 [复制链接] [打 印]
赞助商链接