栈操作 数组实现 链表实现

一、数组实现

/*************************************************************************
 > File Name: arrayStack.h
 > Author:  jinshaohui
 > Mail:    jinshaohui789@163.com
 > Time:    18-10-12
 > Desc:    
 ************************************************************************/

#ifndef ARRAY_STACJ_H
#define ARRAY_STACJ_H

typedef struct _array_stack
{
    int size;/*栈的大小*/
    int pos;/*当前存储元素的个数，即栈顶元素下表*/
    int *array;/*数据存储区*/
}stArrayStack;

#define arrayStack_size(arrayStack) (arrayStack->size)
#define arrayStack_is_empty(arrayStack) (arrayStack->pos == -1)
#define arrayStack_is_full(arrayStack)  (arrayStack->pos == (arrayStack->size-1))

#endif

/*************************************************************************
 > File Name: arrayStack.c
 > Author:  jinshaohui
 > Mail:    jinshaohui789@163.com
 > Time:    18-10-12
 > Desc:   数组实现顺序栈 
 ************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"./arrayStack.h"

/*创建并初始化顺序栈*/
stArrayStack * arrayStack_create(int size)
{
    stArrayStack *parrStack = NULL;

    parrStack = (stArrayStack *)malloc(sizeof(stArrayStack));
    if (parrStack == NULL)
    {
        return NULL;
    }
    
    parrStack->size = size;
    parrStack->pos = -1;
    parrStack->array = (int *)malloc(sizeof(int)*size);
    if(parrStack->array == NULL)
    {
        free(parrStack);
        return NULL;
    }

    return parrStack;
}
/*销毁顺序栈*/
void arrayStack_destory(stArrayStack * parrStack)
{
    if(parrStack == NULL)
    {
        return;
    }

    if (parrStack->array != NULL)
    {
        free(parrStack->array);
    }

    free(parrStack);
    return;
}
/*出栈*/
int arrayStack_pop(stArrayStack *parrStack)
{
    int data = 0;

    if(arrayStack_is_empty(parrStack))
    {
        return -1;
    }
    data = parrStack->array[parrStack->pos];
    parrStack->pos--;

    return data;
}
/*入栈*/
int arrayStack_push(stArrayStack *parrStack,int data)
{
    if(arrayStack_is_full(parrStack))
    {
        return -1;
    }

    parrStack->pos++;
    parrStack->array[parrStack->pos] = data;

    return 0;
}

int arrayStack_push_new(stArrayStack*parrStack,int data)
{
    int *ptmp = NULL;

    /*如果栈不满，直接插入*/
    if(!arrayStack_is_full(parrStack))
    {
        return arrayStack_push(parrStack,data);
    }

    /*如果栈已经满，申请内存*/
    ptmp = (int *)malloc(2*parrStack->size*sizeof(int));
    if (ptmp == NULL)
    {
        return -1;
    }

    memcpy(ptmp,parrStack->array,parrStack->size*sizeof(int));

    free(parrStack->array);

    parrStack->array = ptmp;
    parrStack->size = 2*parrStack->size;
    parrStack->pos++;
    parrStack->array[parrStack->pos] = data;

    return ;
}

void arrayStack_dump(stArrayStack *parrStack)
{
    int i = 0;

    if (arrayStack_is_empty(parrStack))
    {
        printf("\r\n arrayStack is empty.");
        return;
    }
    printf("\r\narrayStack size = %d,pos= %d,",
            parrStack->size,parrStack->pos);
    for(i = 0; i <= parrStack->pos; i++)
    {
        printf("\r\narry[%d] = %d",i,parrStack->array[i]);
    }
}

int main()
{
    int i = 0;
    int ret = 0;
    stArrayStack * parrStack = NULL;

    printf("\r\n create size = 4 arrayStack.");

    parrStack = arrayStack_create(4);
    if (parrStack == NULL)
    {
        printf("\r\n create size = 4 arrayStack faided.");
        return 0;
    }

    for (i = 0; i < 5; i++)
    {
        ret = arrayStack_push(parrStack,i);
        if(ret != 0)
        {
            printf("\r\n push size = %d arrayStack faided.",i);

        }
    }
    arrayStack_dump(parrStack);
        
    ret = arrayStack_push_new(parrStack,4);
    if(ret != 0)
    {
            printf("\r\n push size = %d arrayStack faided.",4);
    }
    arrayStack_dump(parrStack);

    arrayStack_destory(parrStack);
    
    return;
}
二、链表实现

/*************************************************************************
 > File Name: linklist_stack.h
 > Author:  jinshaohui
 > Mail:    jinshaohui789@163.com
 > Time:    18-10-12
 > Desc:    
 ************************************************************************/

#ifndef STACK_LINK_LIST_H
#define STACK_LINK_LIST_H

typedef struct _linkliststack
{
    int data;
    struct _linkliststack *next;
}linklist_stack;

#define stack_is_empty(liststack) (liststack->next == NULL)

#endif

/*************************************************************************
 > File Name: linklist_stack.c
 > Author:  jinshaohui
 > Mail:    jinshaohui789@163.com
 > Time:    18-10-12
 > Desc:    
 ************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include "./linklist_stack.h"

linklist_stack * stack_create()
{
    linklist_stack * stack = NULL;

    stack = (linklist_stack *)malloc(sizeof(linklist_stack));
    if (stack == NULL)
    {
        return NULL;
    }

    stack->next = NULL;

    return stack;
}

void stack_destory(linklist_stack* stack)
{
    linklist_stack * ptmp = NULL;

    while(!stack_is_empty(stack))
    {
        ptmp = stack->next;
        stack->next = stack->next->next;

        free(ptmp);
    }

    free(stack);

    return;
}

int stack_push(linklist_stack *stack,int data)
{
    linklist_stack * ptmp = NULL;

    ptmp = (linklist_stack *)malloc(sizeof(linklist_stack));
    if (ptmp == NULL)
    {
        return -1;
    }

    ptmp->data = data;
    ptmp->next = stack->next;
    stack->next = ptmp;

    return 0;
}

int stack_pop(linklist_stack*stack,int *data)
{
    linklist_stack *ptmp = NULL;
    if (data == NULL)
    {
        return -1;
    }
    if(stack_is_empty(stack))
    {
        return -1;        
    }
    *data = stack->next->data;
    ptmp = stack->next;
    stack->next = ptmp->next;
    free(ptmp);

    return 0;
}

void stack_dump(linklist_stack *stack)
{
    linklist_stack * ptmp = stack->next;
    
    while(ptmp != NULL)
    {
        printf("\r\n data = %d",ptmp->data);
        ptmp = ptmp->next;
    }
    return;
}

int main()
{
    int i = 0;
    int ret = 0;
    int data = 0;
    linklist_stack * stack = NULL;

    stack = stack_create();
    if (stack == NULL)
    {
        printf("\r\n stack create falied.");
        return 0;            
    }
    
    for (i = 0; i < 4; i++)
    {
        ret = stack_push(stack,i);
        if(ret != 0)
        {
            printf("\r\n stack push %d falied.",i);
        }
    }

    stack_dump(stack);

    for (i = 0; i < 5; i++)
    {
        ret = stack_pop(stack,&data);
        if(ret != 0)
        {
            printf("\r\n stack pop%d falied.", i);
        }
        else
        {
            printf("\r\n data = %d,",data);
        }
    }

    stack_destory(stack);

    return 0;

}