typedef  int Status;  //Status 是函数返回值类型，其值是函数结果状态代码。

typedef  int ElemType; //ElemType 为可定义的数据类型，此设为int类型

#define MAXSIZE 100  //顺序表可能达到的最大长度

typedef struct {

 ElemType* elem;  //存储空间的基地址

 int length;    //当前长度

}SqList;

Status ListInsert_Sq(SqList &L, int i, ElemType e) {

 //在顺序表L中第i个位置之前插入新的元素e

 //i值的合法范围是1<=i<=L.length+1

 if ((i < 1) || (i > L.length + 1))

  return ERROR;  //i值不合法

 if (L.length == MAXSIZE)

              1                   //当前存储空间已满

 for (int j = L.length - 1; j >= i - 1; j--)

  L.elem[j + 1] = L.elem[j]; //插入位置及之后的元素后移

 L.elem[i - 1] = e;  //将新元素e放入第i个位置

              2                 //表长增1

 return OK;

}

typedef int Status;  //Status 是函数返回值类型，其值是函数结果状态代码。

typedef int ElemType;  //ElemType 为可定义的数据类型，此设为int类型

#define MAXSIZE 100  //顺序表可能达到的最大长度

typedef struct {

 ElemType* elem;  //存储空间的基地址

 int length;    //当前长度

}SqList;

Status ListDelete_Sq(SqList &L, int i) { 

 //在顺序表L中删除第i个元素，并用e返回其值

 //i值的合法范围是1<=i<=L.length

 if ((i < 1) || (i > L.length))

              1                  // i值不合法

 for (int j = i; j <= L.length; j++)

            2                  //被删除元素之后的元素前移

 --L.length;   //表长减1

 return OK;

}

typedef int Status;  //Status 是函数返回值类型，其值是函数结果状态代码。

typedef int ElemType; //ElemType 为可定义的数据类型，此设为int类型

typedef struct LNode

{ ElemType data;   //结点的数据域

 struct LNode* next;  //结点的指针域

}LNode, * LinkList; 

Status ListInsert_L(LinkList& L, int i, ElemType& e) { //单链表的插入

 //在带头结点的单链表L中第i个位置之前插入元素e

 int j;

 LNode* p, * s;

 p = L; j = 0;

 while (p && j < i - 1) { p = p->next; ++j; } //寻找第i-1个结点

 if (!p || j > i - 1) return ERROR;   //i大于表长+1或者小于1

 s = new LNode;       //生成新结点s

    1     //将结点s的数据域置为e

    2     //将结点s插入L中

 p->next = s;

 return OK;

}

typedef int Status;  //Status 是函数返回值类型，其值是函数结果状态代码。

typedef int ElemType; //ElemType 为可定义的数据类型，此设为int类型

typedef struct LNode

{ ElemType data;   //结点的数据域

 struct LNode* next;  //结点的指针域

}LNode, * LinkList; 

Status ListDelete_L(LinkList& L, int i, ElemType& e) { 单链表的删除

 //在带头结点的单链表L中，删除第i个位置，并由e返回值

 LNode* p, * q;

 int j;

 p = L; j = 0;

 while (p->next && j < i - 1) { p = p->next; ++j; }  //寻找第i-1个结点

 if (!(p->next) || j > i - 1)  return ERROR; //i大于表长+1或者小于1

 q = p->next;    //临时保存被删结点的地址以备释放

    1    //改变删除结点前驱结点的指针域

 e = q->data;    //保存删除结点的数据域

    2    //释放删除结点的空间

 return OK;

}

#define OVERFLOW -2

typedef int Status;

typedef int SElemType;

typedef struct StackNode {

 SElemType data;

 struct StackNode  *next;

} StackNode, *LinkStack;

Status Push(LinkStack &S, SElemType e) {

 LinkStack p;

 p = new StackNode; //生成新结点

 if(!p)

 {

  return OVERFLOW;

 }

 p->data = e; //将新结点数据域置为e

    1    //将新结点插入栈顶

   2    //修改栈顶指针为p

return OK;

}

#define OVERFLOW -2

typedef int Status;

typedef int SElemType;

typedef struct StackNode {

 SElemType data;

 struct StackNode  *next;

} StackNode, *LinkStack;

Status Pop(LinkStack &S, SElemType &e) {

 LinkStack p;

 if (S == NULL)

  return ERROR; //栈空

 e = S->data; //将栈顶元素赋给e

 p = S; //用p临时保存栈顶元素空间，以备释放

    1     //修改栈顶指针

    2    //释放原栈顶元素的空间

 return OK;

}

Typedef struct {

         QElemType *base;  //初始化的动态分配存储空间

         int  front;            //头指针   

         int  rear;             //尾指针

}SqQueue; 

Status EnQueue(SqQueue &Q,QElemType e)

{// 插入元素e为Q的新的队尾元素

 if((Q.rear+1)%MAXQSIZE == Q.front)

 {

  return ERROR;//尾指针在循环意义上加1后等于头指针，表明队满

 }

    1     //新元素插入队尾

    2     //队尾指针加1

 return OK;

}

Typedef struct {

         QElemType *base;  //初始化的动态分配存储空间

         int  front;            //头指针   

         int  rear;             //尾指针

}SqQueue;  

Status DeQueue(SqQueue &Q, QElemType &e) {

//删除Q的队头元素，用e返回其值

 if (Q.front == Q.rear)

  return ERROR;  //队空

    1    //保存队头元素

    2    //队头指针加1

 return OK;

}

#define ERROR 0

#define OVERFLOW -2

typedef int QElemType;

typedef int Status;

typedef struct QNode{

 QElemType data;

 QNode *next;

}QNode,*QueuePtr;

typedef struct{

 QueuePtr front;

 QueuePtr rear;

}LinkQueue;

Status EnQueue(LinkQueue &Q,QElemType e)

{ // 插入元素e为Q的新的队尾元素

 QNode *p = new QNode;

 if(p == NULL)

 { return OVERFLOW;// 存储分配失败

 }

 p->data = e;

 p->next = NULL;

    1     //将新结点插入到队尾

    2    // 修改队尾指针

 return OK;

}

#define ERROR 0

#define OVERFLOW -2

typedef int QElemType;

typedef int Status;

typedef struct QNode{

 QElemType data;

 QNode *next;

}QNode,*QueuePtr;

typedef struct{

 QueuePtr front;

 QueuePtr rear;

}LinkQueue;

Status DeQueue(LinkQueue &Q,QElemType &e)

{//删除Q的队头元素，用e返回其值，并返回OK

 if(Q.front == Q.rear)

 { return ERROR; //若队列空，则返回 ERROR

 }

 QNode *p = Q.front->next;//p指向队头元素

    1    //e保存队头元素的值

    2    //修改头指针

 if(Q.rear == p)

 { Q.rear = Q.front;//最后一个元素被删，队尾指针指向头结点

 }

 delete p;

 return OK;

}

 char data;

 struct BiNode *lchild,*rchild;

}BiTNode,*BiTree;

void InOrderTraverse(BiTree T)

{  

 //中序遍历二叉树T的递归算法

 if(T){

    1    

  cout << T->data;

    2    

 }

}

{ char data;      //结点数据域

 struct BiNode *lchild,*rchild; //左右孩子指针

}BiTNode,*BiTree;

void CreateBiTree(BiTree &T)

{ //按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T

 char ch;

 cin >> ch;

 if(ch=='#')  T=NULL;  //递归结束，建空树

 else{       

  T=   1     //生成根结点

  T->data=ch;    

     2     //递归创建左子树

  CreateBiTree(T->rchild); //递归创建右子树

 }       //else

} 

{ char data;      //结点数据域

 struct BiNode *lchild,*rchild; //左右孩子指针

}BiTNode,*BiTree;

int Depth(BiTree T)

{  int m,n;

 if(T == NULL ) return 0;        //如果是空树，深度为0，递归结束

 else 

 { m=Depth(T->lchild);   //递归计算左子树的深度记为m

  n=Depth(T->rchild);   //递归计算右子树的深度记为n

  if(m>n)    1    ;  

  else   2    ;

 }

}

{ char data;      //结点数据域

 struct BiNode *lchild,*rchild; //左右孩子指针

}BiTNode,*BiTree;

int LeafNodeCount(BiTree T)

{   if(T==NULL)

            return 0; //如果是空树，则叶子结点个数为 0

     else if(   1    )

            return 1; //判断结点是否是叶子结点，若是则返回 1

     else

            return    2    ;

}

#define MAXSIZE 100

#define OK 1;

typedef struct{

 int key;//关键字域

}ElemType;

typedef struct{

 ElemType *R;

 int length;

}SSTable;

int Search_Bin(SSTable ST,int key) {

   // 在有序表ST中折半查找其关键字等于key的数据元素。若找到，则函数值为

   // 该元素在表中的位置，否则为0

   int low=1,high=ST.length;     //置查找区间初值

   int  mid;

   while(low<=high) {

      1    ;

      if (key==ST.R[mid].key)  return mid;  //找到待查元素

      else if (   2    )  high = mid -1; //继续在前一子表进行查找

      else  low =mid +1;              //继续在后一子表进行查找

   }//while

   return 0;         //表中不存在待查元素

}// Search_Bin

#define MAXSIZE 100

#define OK 1;

typedef struct{

 int key;//关键字域

}ElemType;

typedef struct{

 ElemType *R;

 int length;

}SSTable;

int Search_Bin(SSTable ST,int key) {

   // 在有序表ST中折半查找其关键字等于key的数据元素。若找到，则函数值为

   // 该元素在表中的位置，否则为0

   int low=1,high=ST.length;     //置查找区间初值

   int  mid;

   while(low<=high) {

      1    ;

      if (key==ST.R[mid].key)  return mid;  //找到待查元素

      else if (   2    )  high = mid -1; //继续在前一子表进行查找

      else  low =mid +1;              //继续在后一子表进行查找

   }//while

   return 0;         //表中不存在待查元素

}// Search_Bin