数据结构(c语言版)

二叉树的前中后序遍历

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 200
typedef int TElemType;
typedef struct BiTNode{
    TElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void createBiTree(BiTree *t)
{
    //先序遍历创建二叉树 
    int e;
    scanf("%d",&e);
    if(e==-1)
        *t=NULL;
    else
    {
        *t=(BiTree)malloc(sizeof(BiTNode));
        (*t)->data=e;
        printf("请输入%d的左子节点的值：",e)
        createBiTree(&(*t)->lchild);
        printf("请输入%d的右子节点的值：",e);
        createBiTree(&(*t)->rchild);
    }
}
void PreOrderTraverse(BiTree t)
{
    //递归先序遍历 
    if(t!=NULL)
    {
        printf("%d",t->data);
        PreOrderTraverse(t->lchild);
        PreOrderTraverse(t->rchild);
    }
}
void InOrderTraverse(BiTree t)
{
    //递归中序遍历 
    if(t!=NULL)
    {
        InOrderTraverse(t->lchild);
        printf("%d",t->data);
        InOrderTraverse(t->rchild);
    }
}
void PostOrderTraverse(BiTree t)
{
    //递归后序遍历
    if(t!=NULL)
    {
        PostOrderTraverse(t->lchild);
        PostOrderTraverse(t->rchild);
        printf("%d",t->data);
    } 
}
void aPreOrderTraverse(BiTree t)
{
    //非递归先序遍历
    BiTree stack[MAXSIZE];
    int top=0;
    if(t==NULL)
        return;
    BiTree p=t;
    while(!(p==NULL&&top==0))
    {
        while(p)
        {
            printf("%d",p->data);//先访问根结点 
            stack[top]=p;//将p入栈 
            top++;
            p=p->lchild;//p指向左孩子 
        }
     

   if(top<=0)return;
        else
        {
            top--;
            p=stack[top];
            p=p->rchild;//p指向右孩子 
        }    
    } 
}
int main()
{
    BiTree t;
    printf("请输入根节点的值：");
    createBiTree(&t);
    printf("递归先序遍历二叉树为：");
    PreOrderTraverse(t);
    printf("\n");
    printf("递归中序遍历二叉树为：");
    InOrderTraverse(t);
    printf("\n");
    printf("递归后序遍历二叉树为：");
    PostOrderTraverse(t);
    printf("\n"); 
    printf("非递归先序遍历二叉树为：");
    aPreOrderTraverse(t);
    printf("\n");
}

代码的运行结果展示如下图

数组的顺序存储的表示和实现

(p93)

 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

typedef int ElemType;

 

#include<malloc.h> /* malloc()等 */

#include<stdio.h> /* EOF(=^Z或F6),NULL */

#include<process.h> /* exit() */

#include<math.h>

#include<stdarg.h> > // 实现变长参数表要包括的头文件，提供宏va_start，va_arg和va_end， */

/* 用于存取变长参数表 */

 

/* 函数结果状态代码 */

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2 

 

 

 

/* --------------------------- 数组的顺序存储表示 ------------------------------*/

 

#define MAX_ARRAY_DIM 8 /* 假设数组维数的最大值为8 */

typedef struct

{

 ElemType *base; /* 数组元素基址，由InitArray分配 */

 int dim; /* 数组维数 */

 int *bounds; /* 数组维界基址，由InitArray分配 */

 int *constants; /* 数组映象函数常量基址，由InitArray分配 */

}Array;

 

/* ------------------------------------------------------------------------------------------*/

 

 

 

/* --------------------------- 顺序存储数组的基本操作(5个) --------------------------*/

 

Status InitArray(Array *A, int dim, ...) // ...表示变长参数表,位于形参表的最后，前面必须至少有一个固定参数

{ /* 若维数dim和各维长度合法，则构造相应的数组A，并返回OK */

 int elemtotal = 1, i; /* elemtotal是元素总值 */

 va_list ap; // 定义ap是变长参数表类型(C语言的数据类型)

 if (dim<1 || dim>MAX_ARRAY_DIM)

  return ERROR;

 (*A).dim = dim;

 (*A).bounds = (int *)malloc(dim * sizeof(int));

 if (!(*A).bounds)

  exit(OVERFLOW);

 va_start(ap, dim); // ap指向固定参数dim后面的实参表

 for (i = 0; i < dim; ++i)

 {

  (*A).bounds[i] = va_arg(ap, int); //依次读取ap所指的实参(以逗号为分隔符)作为int类型实参,ap向后移

  if ((*A).bounds[i] < 0)

   return UNDERFLOW; /* 在math.h中定义为4 */

  elemtotal *= (*A).bounds[i];

 }

 va_end(ap); // 与va_start()配对，结束对变长参数表的读取，ap不再指向变长参数表

 (*A).base = (ElemType *)malloc(elemtotal * sizeof(ElemType));

 if (!(*A).base)

  exit(OVERFLOW);

 (*A).constants = (int *)malloc(dim * sizeof(int));

 if (!(*A).constants)

  exit(OVERFLOW);

 (*A).constants[dim - 1] = 1;

 for (i = dim - 2; i >= 0; --i)

  (*A).constants[i] = (*A).bounds[i + 1] * (*A).constants[i + 1];

 return OK;

}

 

Status DestroyArray(Array *A)

{ /* 销毁数组A */

 if ((*A).base)

 {

  free((*A).base);

  (*A).base = NULL;

 }

 else

  return ERROR;

 if ((*A).bounds)

 {

  free((*A).bounds);

  (*A).bounds = NULL;

 }

 else

  return ERROR;

 if ((*A).constants)

 {

  free((*A).constants);

  (*A).constants = NULL;

 }

 else

  return ERROR;

 return OK;

}

 

Status Locate(Array A, va_list ap, int *off) /* Value()、Assign()调用此函数 */

{ /* 若ap指示的各下标值合法，则求出该元素在A中的相对地址off */

 int i, ind;

 *off = 0;

 for (i = 0; i < A.dim; i++)

 {

  ind = va_arg(ap, int);

  if (ind < 0 || ind >= A.bounds[i])

   return OVERFLOW;

  *off += A.constants[i] * ind;

 }

 return OK;

}

 

Status Value(ElemType *e, Array A, ...) /* 在VC++中，...之前的形参不能是引用类型 */

{ /* ...依次为各维的下标值，若各下标合法，则e被赋值为A的相应的元素值 */

 va_list ap;

 Status result;

 int off;

 va_start(ap, A);

 if ((result = Locate(A, ap, &off)) == OVERFLOW) /* 调用Locate() */

  return result;

 *e = *(A.base + off);

 return OK;

}

 

Status Assign(Array *A, ElemType e, ...)

{ /* ...依次为各维的下标值，若各下标合法，则将e的值赋给A的指定的元素 */

 va_list ap;

 Status result;

 int off;

 va_start(ap, e);

 if ((result = Locate(*A, ap, &off)) == OVERFLOW) /* 调用Locate() */

  return result;

 *((*A).base + off) = e;

 return OK;

}

 

 

/* ------------------------------------------------------------------------------------------*/

 

 

/* 检验以上操作的主程序 */

 

void main()

{

 Array A;

 int i, j, k, *p, dim = 3, bound1 = 3, bound2 = 4, bound3 = 2; /* a[3][4][2]数组 */

 ElemType e, *p1;

 InitArray(&A, dim, bound1, bound2, bound3); /* 构造3＊4＊2的3维数组A */

 p = A.bounds;

 printf("A.bounds=");

 for (i = 0; i < dim; i++) /* 顺序输出A.bounds */

  printf("%d ", *(p + i));

 p = A.constants;

 printf("\nA.constants=");

 for (i = 0; i < dim; i++) /* 顺序输出A.constants */

  printf("%d ", *(p + i));

 printf("\n%d页%d行%d列矩阵元素如下:\n", bound1, bound2, bound3);

 for (i = 0; i < bound1; i++)

 {

  for (j = 0; j < bound2; j++)

  {

   for (k = 0; k < bound3; k++)

   {

    Assign(&A, i * 100 + j * 10 + k, i, j, k); /* 将i*100+j*10+k赋值给A[i][j][k] */

    Value(&e, A, i, j, k); /* 将A[i][j][k]的值赋给e */

    printf("A[%d][%d][%d]=%2d ", i, j, k, e); /* 输出A[i][j][k] */

   }

   printf("\n");

  }

  printf("\n");

 }

 p1 = A.base;

 printf("A.base=\n");

 for (i = 0; i < bound1*bound2*bound3; i++) /* 顺序输出A.base */

 {

  printf("%4d", *(p1 + i));

  if (i % (bound2*bound3) == bound2 * bound3 - 1)

   printf("\n");

 }

 DestroyArray(&A);

}

代码的结果展示如下图