栈及链栈常用函数

头文件：

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_

#define FAILURE 1000000
#define SUCCESS 1000001

typedef int ElemType;
struct node 
{
    ElemType data;
    struct node *next;
};
typedef struct node Node;
typedef Node *LinkNode;


struct stack
{
    LinkNode top;
    int count;
};
typedef struct stack Stack;

#endif

利用栈排序：

#include 
#include "LinkStack.h"

#define MAXSIZE 10

int main()
{
    int ret,i;
   int a[MAXSIZE] = {0};
    Stack *num,*tmp;

    if(StackInit(&num) != SUCCESS || StackInit(&tmp) != SUCCESS)
    {
        printf("Init Failure!\n");
    }

    printf("Please Input 10 Numbers :\n");

    for(i = 0; i < MAXSIZE; i++)
    {
        scanf("%d",&a[i]);
    }

    for(i = 0; i < MAXSIZE; i++)
    {
        if(StackLength(num) == 0)
        {
            PUSH(num,a[i]);
        }

        else
        {
            while (a[i] < GetTop(num) && StackLength(num) != 0 )
            {
                PUSH(tmp,Pop(num));
            }
            PUSH(num,a[i]);

            while(StackLength(tmp) != 0)
            {
                PUSH(num,Pop(tmp));
            }
        }
    }

    for(i = 0; i < MAXSIZE; i ++)
    {
        printf("%d ",Pop(num));
    }
    printf("\n");
    return 0;
}

链栈子函数及主函数：

#include <stdio.h>
#include "LinkStack.h"
#include <stdlib.h>


int StackInit(Stack **S)
{
    (*S) = (Stack *)malloc(sizeof(Node));
    if(NULL == (*S))
    {
        return FAILURE;
    }
    (*S)->top = NULL;
    (*S)->count = 0;

    return SUCCESS;
}

int PUSH(Stack *S,ElemType e)
{
    Node *p = (Node *)malloc(sizeof(Node));
    if(NULL == p)
    {
        return FAILURE;
    }
    p->data = e;
    p->next = S->top;
    S->top = p;
    S->count++;

    return SUCCESS;
}

int StackLength(Stack *S)
{
    return (S->count);
}

int GetTop(Stack *S)
{
    if(NULL == S->top)
    {
        return FAILURE;
    }


   // return SUCCESS;
   return (S->top->data);
}

int Pop(Stack *S)
{
    int e;
    if(NULL == S->top)
    {
        return FAILURE;
    }

    LinkNode p = S->top;
    S->top = p->next;
    e = p->data;
    free(p);
    S->count--;

    return e;
}


int StackClear(Stack *S)
{
    LinkNode p;

    while (S->top)
    {
        p = S->top;
        S->top = p->next;
        free(p);
        S->count--;
    }
    return SUCCESS;
}



int Destroy(Stack **S)
{
    if(NULL == (*S))
    {
        return FAILURE;
    }
    free(*S);
    *S = NULL;

    return SUCCESS;
}

#include 
#include "LinkStack.h"

int main()
{
    int ret,i;
    Stack *s;
    ElemType e;

    ret = StackInit(&s);
    if(FAILURE == ret)
    {
        printf("Init Failure!\n");
    }
    else
    {
        printf("Init Success!\n");
    }

    for(i = 0; i < 5; i++)
    {
        e = i + 1;
        ret = PUSH(s,e);
        if(FAILURE == ret)
        {
            printf("Push Failure!\n");
        }
        else
        {
            printf("Push %d Success!\n",e);
        }
    }
    printf("Length is %d!\n",StackLength(s));

    ret = GetTop(s,&e);
    if(FAILURE == ret)
    {
        printf("GetTop Failure!\n");
    }
    else 
    {
        printf("Top is %d!\n",e);
    }

    for(i = 0; i < 2; i++)
    {
        ret = Pop(s,&e);
        if(FAILURE == ret)
        {
            printf("Pop Failure!\n");
        }
        else printf("Pop %d Success!\n",e);
    }



    ret = StackClear(s);
    if(FAILURE == ret)
    {
        printf("Clear Failure!\n");
    }
    else 
    {
        printf("Clear Success!\n");
    }


    ret = GetTop(s,&e);
    if(FAILURE == ret)
    {
        printf("GetTop Failure!\n");
    }
    else 
    {
        printf("Top is %d!\n",e);
    }

    ret = Destroy(&s);
    if(FAILURE == ret)
    {
        printf("Destroy Failure!\n");
    }
    else 
    {
        printf("Destroy Success!\n");
    }

    printf("%p\n",s);
    return 0;
}