二叉树 c

最新推荐文章于 2024-10-17 23:18:04 发布

原创最新推荐文章于 2024-10-17 23:18:04 发布 · 215 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #二叉树

数据结构专栏收录该内容

19 篇文章

订阅专栏

本文详细介绍了一种基本的数据结构——二叉树的创建过程及其遍历方法，并提供了递归和非递归两种方式实现中序遍历的具体代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/* ds.h */
/* Some pre define */
#ifndef _HS_H
#define _HS_H

#include <string.h>
#include <ctype.h>
#include <sys/malloc.h>
#include <stdio.h>
#include <stdlib.h>

/* State code */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW 0

typedef int Status;
typedef int Boolean;

#endif

// binaryTree0.c

#include "ds.h"
#include <stdio.h>

#define STACK_INIT_SIZE 10 // initial stack size
#define STACKINCREMENT 4

typedef int TElemType;

typedef struct BiTNode{
  TElemType data;
  struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

typedef BiTree SElemType;

// stack data structure
// prepare for traverse without recursion
typedef struct SqStack{
  SElemType *base;
  SElemType *top;
  int stacksize;
}SqStack;

Status visit(TElemType e){
  printf("%d ", e);
  return OK;
}

Status InitBiTree(BiTree *T){
  *T = NULL;
  return OK;
}

// preorder scanf
// -1 to stop
void CreateBiTree(BiTree *T){
  TElemType data;
  scanf("%d", &data);
  if(data == -1)
    *T = NULL;
  else{
    *T = (BiTree)malloc(sizeof(BiTNode));
    if(!*T)exit(OVERFLOW);
    (*T)->data = data;
    CreateBiTree(&(*T)->lchild);
    CreateBiTree(&(*T)->rchild);
  }
}

// return 1, for empty BiTree
// 0, for nonempty
Status BiTreeEmpty(BiTree T){
  return(T == NULL);
}

// return BiTree depth
int BiTreeDepth(BiTree T){
  int i, j;
  if(!T)return 0;
  else{
    i = BiTreeDepth(T->lchild);
    j = BiTreeDepth(T->rchild);
    return i>j?(i+1):(j+1);
  }
}

// print BiTree
void printBiTree(BiTree T, int depth){
  if(T){
    printf("%d", T->data);
    if(T->lchild){
      printf("\n");
      printf("%*.s-", depth+1, "");
      printBiTree(T->lchild, depth+1);
    }
    if(T->rchild){
      printf("\n");
      printf("%*.s-", depth+1, "");
      printBiTree(T->rchild, depth+1);
    }
  }else{
    return;
  }
}

// post order traverse BiTree
void PostOrderTraverse(BiTree T, Status(* Visit)(TElemType)){
  if(T){
    PostOrderTraverse(T->lchild, Visit);
    PostOrderTraverse(T->rchild, Visit);
    Visit(T->data);
  }
}

// In order traverse BiTree
void InOrderTraverse(BiTree T, Status(* Visit)(TElemType)){
  if(T){
    InOrderTraverse(T->lchild, Visit);
    Visit(T->data);
    InOrderTraverse(T->rchild, Visit);
  }
}

// Pre order traverse BiTree
void PreOrderTraverse(BiTree T, Status(* Visit)(TElemType)){
  if(T){
    Visit(T->data);
    PreOrderTraverse(T->lchild, Visit);
    PreOrderTraverse(T->rchild, Visit);
  }
}

// stack initializer
int InitStack(SqStack *s){
  (*s).base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
  if(!(*s).base)exit(OVERFLOW);
  (*s).top = (*s).base;
  (*s).stacksize = STACK_INIT_SIZE;
  return OK;
}

// return 1, if stack is empty
// retunr 0, otherwise
Status StackEmpty(SqStack s){
  return (s.top == s.base);
}

// pop ops
Status Pop(SqStack *s, SElemType *e){
  if(s->top == s->base)return ERROR;
  else{
    // printf("test\n");
    s->top--;
    *e = *s->top;
    // printf("%d", (*e)->data);
    return OK;
  }
}

// push ops
Status Push(SqStack *s, SElemType e){
  if(s->top - s->base >= s->stacksize){
    // if stack is full
    s->base = (SElemType *)realloc((s->base), (s->stacksize + STACKINCREMENT) * sizeof(SElemType));
    if(!s->base)exit(OVERFLOW);
    s->top = s->base + s->stacksize;
    s->stacksize += STACKINCREMENT;
  }
  *(s->top) = e;
  // printf("test: %d", e->data);
  s->top++;
  return OK;
}


// In order traverse, without recursion
// using stack
Status InOrderTraverse1(BiTree T, Status(* Visit)(TElemType)){
  SqStack s;
  InitStack(&s);
  // printf("Initial stack.\n");
  while(T || !StackEmpty(s)){
    if(T){
      // push root, traverse left child
      // printf("Push \n");
      Push(&s, T);
      T = T->lchild;
    }else{
      // printf("Pop\n");
      Pop(&s, &T);
      if(!Visit(T->data))
        return ERROR;
      T = T->rchild;
    }
  }
  printf("\n");
  return OK;
}


int main(){
  BiTree T;
  InitBiTree(&T);
  CreateBiTree(&T);
  printBiTree(T, 1);
  printf("\n");

  printf("In order traverse(recursion) \n");
  InOrderTraverse(T, visit);
  printf("\n");

  printf("In order traverse(stack) \n");
  InOrderTraverse1(T, visit);
  printf("\n");
}

Junr:tree junr$ ./a.out 
1 2 -1 -1 3 4 -1 -1 -1
1
  -2
  -3
   -4
In order traverse(recursion) 
2 1 4 3 
In order traverse(stack) 
2 1 4 3