數據結構C語言實現之二叉樹

#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; /* 把樹根指針置為空，即從空樹開始建立二叉樹 */
 /* 每循環一次處理一個字符，直到掃描到字符串結束符\0為止 */
 while(a[i] != '\0'){
     switch(a[i]){
         case ' ':
    break;  /* 對空格不作任何處理 */
   case '(':
    if(top == STACK_MAX_SIZE - 1){
        printf("棧空間太小！\n");
     exit(1);
    }
    top++;
    s[top] = p;
    k = 1;
    break;
         case ')':
    if(top == -1){
        printf("二叉樹廣義表字符串錯誤!\n");
     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("輸入二叉樹廣義表的字符串：\n");
 /* scanf("%s", b); */
 b = "a(b(c), d(e(f, g), h(, i)))";
 createBTree(&bt, b);
 if(bt != NULL)
 printf(" %c ", bt->data);
 printf("以廣義表的形式輸出：\n");
 printBTree(bt);   /* 以廣義表的形式輸出二叉樹 */
 printf("\n");
 printf("前序：");  /* 前序遍歷 */
 preOrder(bt);
 printf("\n");
 printf("中序：");  /* 中序遍歷 */
 inOrder(bt);
 printf("\n");
 printf("後序：");  /* 後序遍歷 */
 postOrder(bt);
 printf("\n");
 printf("按層：");  /* 按層遍歷 */
 levelOrder(bt);
 printf("\n");
 /* 從二叉樹中查找一個元素結點 */
 printf("輸入一個待查找的字符：\n");
 scanf(" %c", &x);  /* 格式串中的空格跳過空白字符 */
 px = findBTree(bt, x);
 if(px){
     printf("查找成功：%c\n", *px);
 }else{
     printf("查找失敗！\n");
 }
 printf("二叉樹的深度為：");
 printf("%d\n", BTreeDepth(bt));
 clearBTree(&bt);
 return 0;
}
*/

#include <stdio.h>
#define QUEUE_MAX_SIZE 20
#define STACK_MAX_SIZE 10
typedef int elemType;
#include "BT.c"
/************************************************************************/
/*                    以下是關於二叉搜索樹操作的4個簡單算法               */
/************************************************************************/
/* 1.查找 */
/* 遞歸算法 */
elemType *findBSTree1(struct BTreeNode *bst, elemType x)
{
    /* 樹為空則返回NULL */
    if (bst == NULL){
        return NULL;
    }else{
        if (x == bst->data){
            return &(bst->data);
        }else{
            if (x < bst->data){    /* 向左子樹查找並直接返回 */
                return findBSTree1(bst->left, x);
            }else{        /* 向右子樹查找並直接返回 */
                return findBSTree1(bst->right, x);
            }
        }
    }
}
/* 非遞歸算法 */
elemType *findBSTree2(struct BTreeNode *bst, elemType x)
{
    while (bst != NULL){
        if (x == bst->data){
            return &(bst->data);
        }else if (x < bst->data){
            bst = bst->left;
        }else{
            bst = bst->right;
        }
    }
    return NULL;
}

/* 2.插入 */
/* 遞歸算法 */
void insertBSTree1(struct BTreeNode* *bst, elemType x)
{
    /* 新建一個根結點 */
    if (*bst == NULL){
        struct BTreeNode *p = (struct BTreeNode *)malloc(sizeof(struct BTreeNode));
        p->data = x;
        p->left = p->right = NULL;
        *bst = p;
        return;
    }else if (x < (*bst)->data){        /* 向左子樹完成插入運算 */
        insertBSTree1(&((*bst)->left), x);
    }else{        /* 向右子樹完成插入運算 */
        insertBSTree1(&((*bst)->right), x);
    }
}
/* 非遞歸算法 */
void insertBSTree2(struct BTreeNode* *bst, elemType x)
{
    struct BTreeNode *p;
    struct BTreeNode *t = *bst, *parent = NULL;
    /* 為待插入的元素查找插入位置 */
    while (t != NULL){
        parent = t;
        if (x < t->data){
            t = t->left;
        }else{
            t = t->right;
        }
    }
    /* 建立值為x，左右指針域為空的新結點 */
    p = (struct BTreeNode *)malloc(sizeof(struct BTreeNode));
    p->data = x;
    p->left = p->right = NULL;
    /* 將新結點鏈接到指針為空的位置 */
    if (parent == NULL){
        *bst = p;        /* 作為根結點插入 */
    }else if (x < parent->data){        /* 鏈接到左指針域 */
       parent->left = p;
    }else{
        parent->right = p;
    }
    return;
}

/* 3.建立 */
void createBSTree(struct BTreeNode* *bst, elemType a[], int n)
{
    int i;
    *bst = NULL;
    for (i = 0; i < n; i++){
        insertBSTree1(bst, a[i]);
    }
    return;
}

/* 4.刪除值為x的結點，成功返回1,失敗返回0 */
int deleteBSTree(struct BTreeNode* *bst, elemType x)
{
    struct BTreeNode *temp = *bst;
    if (*bst == NULL){
        return 0;
    }
    if (x < (*bst)->data){
        return deleteBSTree(&((*bst)->left), x);        /* 向左子樹遞歸 */
    }
    if (x > (*bst)->data){
        return deleteBSTree(&((*bst)->right), x);    /* 向右子樹遞歸 */
    }
    /* 待刪除的元素等於樹根結點值且左子樹為空，將右子樹作為整個樹並返回1 */
    if ((*bst)->left == NULL){
        *bst = (*bst)->right;
        free(temp);
        return 1;
    }
    /* 待刪除的元素等於樹根結點值且右子樹為空，將左子樹作為整個樹並返回1 */
    if ((*bst)->right == NULL){
        *bst = (*bst)->left;
        free(temp);
        return 1;
    }else{
        /* 中序前驅結點為空時，把左孩子結點值賦給樹根結點，然後從左子樹中刪除根結點 */
        if ((*bst)->left->right == NULL){
            (*bst)->data = (*bst)->left->data;
            return deleteBSTree(&((*bst)->left), (*bst)->data);
        }else{    /* 定位到中序前驅結點，把該結點值賦給樹根結點，然後從以中序前驅結點為根的
                   樹上刪除根結點*/
            struct BTreeNode *p1 = *bst, *p2 = p1->left;
            while (p2->right != NULL){
                p1 = p2;
                p2 = p2->right;
            }
            (*bst)->data = p2->data;
            return deleteBSTree(&(p1->right), p2->data);
        }
    }
}

/************************************************************************/
int main(int argc, char *argv[])
{
    int x, *px;
    elemType a[10] = {30, 50, 20, 40, 25, 70, 54, 23, 80, 92};
    struct BTreeNode *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);
    return 0;
}