栈的实现(顺序结构&&链式结构)

在写栈的基本操作的时候要注意的地方：有些函数为了实现某种功能，须要对栈的指针进行移动。而此时我们并不想让其对原本的栈进行修改，所以不能传入指针，而要传入栈的副本

因此，在这个学习进程中学习到：传参数要养成加const的习惯，如果此时编写的函数不希望它对原本的函数进行修改，则加上const。

如果此时你不小心函数中对传入的const指针进行了修改，编译器就会报错！从而达到提醒的目的。

#include<iostream>
#include<stdio.h>
#include<stdlib.h>

using namespace std;

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INIT_SIZE 10
#define SIZE_INCREASEMENT 10

typedef int Elemtype;
typedef int Status;

/*构建栈的结构体*/
typedef struct _myStack
{
    Elemtype* top;
    Elemtype* base;
    int size;
}myStack;

/*栈的初始化*/
Status initStack(myStack* stack)
{
    stack->base = (Elemtype*)malloc(INIT_SIZE*sizeof(Elemtype));
    if (!stack->base)
    {
        return ERROR;
    }
    stack->top = stack->base;
    stack->size = INIT_SIZE;
    return OK;
}
/*销毁栈*/
Status destroyStack(myStack* stack)
{
    free(stack->base);
    stack->base = NULL;
    stack->top = NULL;
    stack->size = 0;
    return OK;
}
/*清空栈*/
Status clearStack(myStack* stack)
{
    stack->top = stack->base;
    stack->size = 0;
    return OK;
}
/*判断栈是否为为空*/
Status isEmpty(const myStack* stack)
{
    if (stack->base == stack->top)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

/*获取栈的长度*/
int getLength(const myStack* stack)
{
    return (stack->top-stack->base);
}

/*获取栈顶的数据*/
//注意到获取栈的数据我们要对top指针进行操作，然而事实上我们并不想改变原有的栈的top指针的位置
//所以，这里获取栈顶的数据函数，传入的参数不应该为指针！！！！！
Elemtype getTop(myStack stack)
{
    if (stack.base == stack.top)
    {
        printf("当前栈没有存放数据");
        return ERROR;
    }
    else
    {
        return *(--stack.top);
    }
}

/*压栈*/
Status push(myStack* stack, Elemtype target)
{
    //压栈的时候要防止栈溢出
    if ((stack->top - stack->base) / sizeof(Elemtype) >= (stack->size))
    {
        stack->base = (Elemtype*)realloc(stack->base, (stack->size + SIZE_INCREASEMENT)*sizeof(Elemtype));
        if (!stack->base)
        {
            return ERROR;
        }
        stack->top = stack->base + stack->size;
        stack->size += SIZE_INCREASEMENT;
    }
    *(stack->top) = target;
    ++(stack->top);
    return OK;
}

/*退栈*/
Elemtype pop(myStack* stack)
{
    if (stack->top == stack->base)
    {
        return ERROR;
    }
    else
    {
        --stack->top;
        return *(stack->top);
    }
}

/*遍历栈*/
//这里需要注意的也是不能传指针参数的问题
//因为函数内部须要对指针进行移动以进行遍历
//而我们并不希望这个函数对原本的指针进行改变！！
Status traverseStack(myStack stack)
{
    while (stack.top > stack.base)
    {
        printf("%d ", *stack.base);
        ++stack.base;
    }
    return OK;
}

/*主函数*/
int main()
{
    myStack stack;
    if (initStack(&stack))
    {
        printf("init success\n");
    }

    if (isEmpty(&stack))
    {
        printf("stack is empty\n");
    }

    for (int i = 0; i < 10; i++)
    {
        push(&stack, i+1);
    }

    printf("the top element in the stack is %d\n", getTop(stack));
    printf("the length of stack is %d\n", getLength(&stack));
    printf("now the element be poped from stack is %d\n", pop(&stack));

    traverseStack(stack);

    if (destroyStack(&stack))
    {
        printf("\ndestroy stack success\n");
    }
}

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<malloc.h>

using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef int Elemtype;
typedef int Status;

//==================================
//           栈的链式实现
//==================================
typedef struct _stackNode
{
    Elemtype data;
    struct _stackNode* pNext;
}stackNode;

typedef struct _stackPtr
{
    //stackNode* base;
    stackNode* top;
    //int size;
}stackPtr;

/*栈的初始化*/
Status initStack(stackPtr* sPtr)
{
    sPtr->top = (stackNode*)malloc(sizeof(stackNode));
    if (!sPtr)
    {
        return ERROR;
    }
    //sPtr->base = sPtr->top;
    sPtr->top->pNext= NULL;
    return OK;
}
/*销毁栈*/
Status destroyStack(stackPtr* sPtr)
{
    //stackNode* ptr=sPtr->top;
    stackNode* ptr;
    while (sPtr->top)
    {
        ptr = sPtr->top->pNext;
        free(sPtr->top);
        sPtr->top = ptr;
    }
    return OK;
}
/*清除栈*/
Status clearStack(stackPtr* sPtr)
{
    destroyStack(sPtr);
    initStack(sPtr);
    return OK;
}
/*判断是否为空*/
Status isEmpty(stackPtr* sPtr)
{
    if (sPtr->top->pNext)
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}
/*获取长度*/
int getLength(stackPtr sPtr)
{
    stackNode* ptr;
    int count = 0;
    while (sPtr.top->pNext)
    {
        ++count;
        ptr = sPtr.top->pNext;
        sPtr.top = ptr;
    }
    return count;
}
/*获取栈顶的元素*/
Elemtype getTop(stackPtr* sPtr)
{
    if (sPtr->top==NULL)
    {
        return ERROR;
    }
    else
    {
        return sPtr->top->data;
    }
}
/*压栈*/
Status push(stackPtr* sPtr, Elemtype target)
{
    stackNode* newNode = (stackNode*)malloc(sizeof(_stackNode));
    if (!newNode)
    {
        return ERROR;
    }
    //新结点数据初始化
    newNode->data = target;
    newNode->pNext= sPtr->top;
    sPtr->top = newNode;

    return OK;
}
/*退栈*/
Elemtype pop(stackPtr* sPtr)
{
    stackNode* ptr;
    if (NULL == sPtr->top)
    {
        return ERROR;
    }
    int returnElem = sPtr->top->data;
    ptr = sPtr->top->pNext;
    free(sPtr->top);
    sPtr->top = ptr;
    return returnElem;
}
/*遍历*/
Status traverseStack(stackPtr* sPtr)
{
    while (sPtr->top->pNext)
    {
        printf("%d ", sPtr->top->data);
        sPtr->top = sPtr->top->pNext;
    }
    return OK;
}

int main()
{
    stackPtr myLinkStack;
    if (initStack(&myLinkStack))
    {
        printf("init success\n");
    }

    for (int i = 0; i < 10; i++)
    {
        push(&myLinkStack, i);
    }

    printf("%d", myLinkStack.top->pNext->data);
    printf("the top element in the stack is %d\n", getTop(&myLinkStack));
    printf("now the element be poped from stack is %d\n", pop(&myLinkStack));
    printf("the length of stack is %d\n", getLength(myLinkStack));
    traverseStack(&myLinkStack);

    return 0;
}