点击这里给我发消息 点击这里给我发消息

数据结构C语言实现系列——二叉树

添加时间:2013-12-7
    相关阅读: 链接 C语言
副标题#e#
 #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;
  }

 

#p#副标题#e#

 /* 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;
   }
  }
  }

 

#p#副标题#e#

 /* 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;
  }

 

#p#副标题#e#

 /* 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;
  }
  */

 

#p#副标题#e#


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

#p#副标题#e#

 /*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;
  }

相关数据结构C语言实现系列——二叉树

咨询热线:020-85648757 85648755 85648616 0755-27912581 客服:020-85648756 0755-27912581 业务传真:020-32579052
广州市网景网络科技有限公司 Copyright◎2003-2008 Veelink.com. All Rights Reserved.
广州商务地址:广东省广州市黄埔大道中203号(海景园区)海景花园C栋501室
= 深圳商务地址:深圳市宝源路华丰宝源大厦606
研发中心:广东广州市天河软件园海景园区 粤ICP备05103322号 工商注册