栈，链栈，队，链队，树的代码

Stack:

#include<stdio.h>

 

#define maxSIZE 10

#define OK 1

#define ERROR 0

 

struct Node{

    int data[maxSIZE];

    int top;

}SqStack;

 

int InitStack(SqStack *s)

{

    s->top = -1;

   

    return OK;

}

 

intPushStack(SqStack *s,int e)

{

    if(s->top == maxSIZE - 1)

    {

        return ERROR;

    }

    s->top++;

    s->data[s->top] = e;

    return OK;

}

intPullStack(SqStack *s,int *e)

{

    if(s->top == -1)

    {

        return ERROR;

    }

    *e = s->data[s->top];

    s->top--;

 

    return OK;

}

 

intStackLength(SqStack s)

{

    return s.top+1;

}

 

int main()

{

    Sqstack s;

    return 0;

}

LinkStack:

#include<stdio.h>

#include<stdlib.h>

 

#define ERROR 0

#define OK 1

 

typedef structStackNode{

    int data;

    struct StackNode *next;

}Node,*NodePtr;

 

typedef struct{

    NodePtr top;

    int count;

}LinkStack;

 

intInitStack(LinkStack *s)

{

    s->top == (NodePtr)malloc(sizeof(Node));

    if(s->top == NULL)

    {

returnERROR;

    }

    s->top = NULL;

    s->count = 0;

  

    return OK;

}

 

int Push(LinkStack*s,int e)

{

    NodePtr p;

 

    p = (NodePtr)malloc(sizeof(Node));

    p->data = e;

    p->next = s->top;

    s->top = p;

    s->count++;

    

    return OK;  

}

 

int Pop(LinkStack*s,int *e)

{

    NodePtr p;

 

    *e = s->top->data;

    s->count--;

    p = s->top;

    s->top = p->next;

    free(p);

    p = NULL;

   

    return OK;

}

 

intClearStack(LinkStack *s)

{

    NodePtr p,q;

 

    p = s->top;

    while(p != NULL)

    {

        q = p;

        p = p->next;

        free(q);

    }   

    q = NULL;

    s->top = p;

    s->count = 0;

 

    return OK;       

}

 

int Print(LinkStack*s)

{

    NodePtr p;

   

    p = s->top;

    while(p != NULL)

    {

        printf("%d\n",p->data);

        p = p->next;

    }   

 

    return OK;

}

 

int main()

{

    LinkStack s;

    int i;

    int num;

 

    if(InitStack(&s) == OK)

    {

        for(i=1; i<11; i++)

        {

            Push(&s,i);

        }

    }

    Print(&s);

 

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

    {

        Pop(&s,&num);

        //pirintf("%d\n",num);

    }   

    Print(&s);

 

    return 0;

}

Queue:

#include<stdio.h>

 

#define QueueMax 11

#define OK 1

#define ERROR 0

 

typedef struct Node{

    int data[QueueMax];

    int front;

    int rear;

}Que;

 

int InitQueue(Que*Q)

{

    Q->front = 0;

    Q->rear = 0;

 

    return OK;

}

 

int EnQueue(Que*Q,int e)

{

    if((Q->rear + 1)%QueueMax ==Q->front)

    {

        return ERROR;

    }

    Q->data[Q->rear] = e;

    Q->rear = (Q->rear + 1) % QueueMax;

 

    return OK;

}

 

int OutQueue(Que*Q,int *e)

{

    if(Q->front == Q->rear)

    {

returnERROR;

    }

    *e = Q->data[Q->front];

    Q->front = (Q->front + 1) % QueueMax;

 

    return OK;

}

 

int LengthQueue(Que*Q)

{

    return ((Q->rear - Q->front +QueueMax) % QueueMax);

}

 

int Print(Que Q)

{

    int len;

    int i,j;

   

    len = LengthQueue(&Q);

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

    {

        Q.front = Q.front % QueueMax;

printf("%d\n",Q.data[Q.front++]);

    }

 

    return OK;

}

 

int main()

{

    Que s;

    int i;

    int num;

    int len;

 

    if(InitQueue(&s) == OK)

    {

        for(i=1; i<11; i++)

        {

    EnQueue(&s,i);

        }

        Print(s);

    }

    len = LengthQueue(&s);

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

    {     

        OutQueue(&s,&num);

        printf("%d\n",num);

    }

  

    return 0;

}

LinkQueue:

#include<stdio.h>

#include<stdlib.h>

 

#define OK 1

#define ERROR 0

 

typedef structQNode{

    int data;

    struct QNode *next;

}QNode, *QueuePtr;

 

typedef struct{

    QueuePtr front,rear;

}LinkQueue;

 

intInitQueue(LinkQueue *Q)

{

    QueuePtr p;

 

    Q->front =(QueuePtr)malloc(sizeof(QNode));

    if(Q->front == NULL)

    {

returnERROR;

    }

    Q->front->next = NULL;

    Q->front->data = 0;

    Q->rear = Q->front;

 

    return OK;

}

 

intEnQueue(LinkQueue *Q,int e)

{

    QueuePtr s;

 

    s = (QueuePtr)malloc(sizeof(QNode));

    if(s == NULL)

    {

returnERROR;

    }

    s->next = NULL;

    s->data = e;

    Q->rear->next = s;

    Q->rear = s;

 

    return OK;

}

 

intDeQueue(LinkQueue *Q,int *e)

{

    QueuePtr p;

 

    if(Q->front == Q->rear)

    {

returnERROR;

    }

    p = Q->front->next;

    *e = p->data;

    Q->front->next = p->next;

    if(Q->rear == p)

    {

Q->rear= Q->front;

    }

    free(p);

    p =NULL;

   

    return OK;

}

 

int Print(LinkQueueQ)

{

    QueuePtr p; 

 

    if(Q.front == Q.rear)

    {

         returnERROR;

    }

    p = Q.front->next;

    while(p != NULL)

    {

printf("%d,",p->data);

        p = p->next;

    }

    printf("\n");

 

    return OK;

}

 

int main()

{

    LinkQueue s;

    int a[10],i;

    int num;

 

    if(InitQueue(&s) == OK)

    {

for(i=1;i<11; i++)

        {

   EnQueue(&s,i);        

        }

        Print(s);

        DeQueue(&s,&num);

        printf("num == %d\n",num);

        Print(s);

    }

    return 0;

}

Tree:

#include<stdio.h>

#include<stdlib.h>

 

#define OK 1

#define ERROR 0

 

typedef struct Node{

    char data;

    struct Node *lchild;

    struct Node *rchild;

}Tree,*TreePtr;

 

voidCreateTree(TreePtr *T)

{

    char a;

 

    scanf("%c",&a);

    if('#' == a)

    {

       (*T) = NULL;

        return ;

    }

    (*T) = (TreePtr)malloc(sizeof(Tree));

    (*T)->data = a;

    CreateTree(&(*T)->lchild);

    CreateTree(&(*T)->rchild);

}

 

voidMidOrderPrint(TreePtr T)

{

    if(T == NULL)

    {

return;

    }   

    MidOrderPrint(T->lchild);

    printf("%c",T->data);

    MidOrderPrint(T->rchild);

 

    return ;

}

 

intAfterOrderPrint(TreePtr T)

{

    if(NULL == T)

    {

returnERROR;

    }   

    AfterOrderPrint(T);

    printf("%c",T->data);

    AfterOrderPrint(T);

 

    return OK;

}

 

int main()

{

    TreePtr T;   

 

    printf("please input preorderdata:\n");

    CreateTree(&T);

  

    printf("MidOrderPrint:");

    MidOrderPrint(T);

    printf("\n");

  

    printf("AfterOrderPrint:\n");

    AfterOrderPrint(T);

    printf("\n");

   

    return 0;

}