ADT Stack 链表与数组实现

讲三种栈的实现
栈的数组实现，栈的链表实现，用C++STL类中的Stack

一个好的ADT，调用例程是应该不需要知道内部实现，所以Sqstack和Linkstack中实现的各种操作，调用方法将会是相同的。

第一种
栈的数组实现

#include<iostream>
#include<cstdio>
#include<cstdlib>

using namespace std;

#define EmptyTOS  -1
#define MaxStackSize  100        //栈的大小

typedef int ElementType;        ElementType这里我们选用int
//想想define 和 typedef的区别

typedef struct Sqstack
{
    int capacity;       //容量
    int TopofStack;       //栈顶
    ElementType *array;     
}*Stack;

//声明部分
Stack CreateStack( int MaxElements );     //创建栈
void MakeEmpty( Stack S );    //初始化
bool IsEmpty( Stack S );       //判断栈空
bool IsFull( Stack S );       //判断栈满
void Push( ElementType x, Stack S );        //入栈
void DisposeStack( Stack S );      //释放栈
ElementType Top( Stack S );       //看栈顶
ElementType Pop( Stack S );     //出栈

//Calling Function CallTest
int main()
{
    Stack myStack = CreateStack(5);
    MakeEmpty(myStack);

    if(IsEmpty(myStack))
        cout << "myStack is empty" << endl;
    if(!IsFull(myStack))
        cout << "myStack is not full" << endl;

    Push(2, myStack);
    Push(43, myStack);
    Push(23, myStack);

    cout << Top(myStack) << endl;
    cout << Pop(myStack) << endl;
    cout << Top(myStack) << endl;

    if(!IsEmpty(myStack))
        cout << "myStack is not empty" << endl;

    Push(2, myStack);
    Push(2, myStack);
    Push(2, myStack);

    if(IsFull(myStack))
        cout << "myStack is full" << endl;

    DisposeStack(myStack);

    return 0;
}

/**
 * 创建栈
 * 参数：int
 * 返回值：Stack 栈的指针
 * 功能：创建一个新栈，并且返回指向新栈的指针
 */
Stack CreateStack( int MaxElements )
{
    if( MaxElements > MaxStackSize )
    {
        cout << "Stack size if too small" << endl;
        return NULL;
    }

    Stack S = (Stack)malloc(sizeof(Sqstack));

    S->array = (ElementType*)malloc(sizeof(ElementType) * MaxElements);
    S->capacity = MaxElements;
    MakeEmpty(S);

    return S;
}

/**
 * 使新栈变空
 * 参数：栈的指针
 * 返回值：空
 * 功能：初始化一个新栈
 **/

void MakeEmpty( Stack S )
{
    S->TopofStack = EmptyTOS;
}

/**
 * 参数：栈的指针
 * 返回值：bool类型
 * 功能：判断一个栈是否为空
 **/
bool IsEmpty( Stack S )
{
    return S->TopofStack == EmptyTOS;
}

/**
 * 参数：栈的指针
 * 返回值：bool类型
 * 功能：判断栈是否满
 **/
bool IsFull( Stack S )
{
    return (S->TopofStack == S->capacity - 1);
}

/**
 * 参数：入栈元素， 栈的指针
 * 无返回值
 * 功能：就入栈呗
 **/
void Push( ElementType x, Stack S )
{
    if(IsFull(S))
        cout << "Full Stack" << endl;
    else
    {
        S->array[++S->TopofStack] = x;
    }
}

/**
 * 参数：栈的指针
 * 返回值：无
 * 功能：释放栈
 **/
void DisposeStack( Stack S )
{
    if(S != NULL)
    {
        free(S->array);
        free(S);
    }
}

/**
 * 参数：栈的指针
 * 返回值：栈顶元素
 * 功能：读取栈顶元素但不出栈
 **/
ElementType Top( Stack S )
{
    if(IsEmpty(S))
    {
        cout << "Stack is empty" << endl;
        return 0;
    }
    else
    {
        return S->array[S->TopofStack];
    }
    
}

/**
 * 参数：栈的指针
 * 返回值：栈顶元素
 * 功能：返回栈顶元素并且出栈
 **/
ElementType Pop( Stack S )
{
    if(IsEmpty(S))
    {
        cout << "Stack is empty" << endl;
        return 0;
    }
    else
    {
        return S->array[S->TopofStack--];
    }
    
}

第二种 栈的链表实现

#include<iostream>
#include<cstdio>
#include<cstdlib>

using namespace std;

typedef int ElementType;

typedef struct Linkstack
{
    ElementType Element;
    Linkstack* next;
}*Stack;

//声明部分
Stack CreateStack( int MaxElements );     //创建栈
bool IsEmpty( Stack S );       //判断栈空
void Push( ElementType x, Stack S );        //入栈
void DisposeStack( Stack S );      //释放栈
ElementType Top( Stack S );       //看栈顶
ElementType Pop( Stack S );     //出栈

//Calling Function CallTest
int main()
{
    Stack myStack = CreateStack(5);

    if(IsEmpty(myStack))
        cout << "myStack is empty" << endl;

    Push(2, myStack);
    Push(43, myStack);
    Push(23, myStack);

    cout << Top(myStack) << endl;
    cout << Pop(myStack) << endl;
    cout << Top(myStack) << endl;

    if(!IsEmpty(myStack))
        cout << "myStack is not empty" << endl;

    Push(2, myStack);
    Push(2, myStack);
    Push(2, myStack);


    DisposeStack(myStack);

    system("pause");

    return 0;
}

/**
 * 创建栈
 * 参数：int
 * 返回值：Stack 栈的指针
 * 功能：创建一个新栈，并且返回指向新栈的指针
 */
Stack CreateStack( int MaxElements )
{
    Stack S = (Stack)malloc(sizeof(Linkstack));

    S->next = NULL;     //初始化

    return S;
}

/**
 * 参数：栈的指针
 * 返回值：bool类型
 * 功能：判断一个栈是否为空
 **/
bool IsEmpty( Stack S )
{
    return S->next == NULL;
}

/**
 * 参数：入栈元素， 栈的指针
 * 无返回值
 * 功能：就入栈呗
 **/
void Push( ElementType x, Stack S )
{
    Stack temp = (Stack)malloc(sizeof(Linkstack));

    temp->Element = x;
    temp->next = S->next;
    S->next = temp;
}

/**
 * 参数：栈的指针
 * 返回值：无
 * 功能：释放栈
 **/
void DisposeStack( Stack S )
{
    while(S->next != NULL)
    {
        Stack temp = (Stack)malloc(sizeof(Linkstack));
        temp->next = S->next;
        S->next = S->next->next;
        free(temp->next);
        free(temp);
    }
    free(S);
}

/**
 * 参数：栈的指针
 * 返回值：栈顶元素
 * 功能：读取栈顶元素但不出栈
 **/
ElementType Top( Stack S )
{
    if(IsEmpty(S))
    {
        cout << "Stack is empty" << endl;
        return 0;
    }
    else
    {
        return S->next->Element;
    }
    
}

/**
 * 参数：栈的指针
 * 返回值：栈顶元素
 * 功能：返回栈顶元素并且出栈
 **/
ElementType Pop( Stack S )
{
    if(IsEmpty(S))
    {
        cout << "Stack is empty" << endl;
        return 0;
    }
    else
    {
        ElementType num = S->next->Element;
        Stack temp = (Stack)malloc(sizeof(Linkstack));
        temp->next = S->next;
        S->next = S->next->next;
        free(temp->next);
        free(temp);

        return num;
    }
    
}

第三种放下一篇，C++STL中的stack应该是最常用的了