数据结构－顺序栈的初始化，入栈，出栈，栈的销毁

 1 #ifndef ____seqstack__
 2 #define ____seqstack__
 3 
 4 #include <stdio.h>
 5 #include <stdlib.h>
 6 
 7 
 8 typedef int datatype;
 9 #define STACKSIZE 100;
10 
11 typedef struct
12 {
13     datatype *top;
14     datatype *base;
15     int stacksize;
16 }stack;
17 
18 int stack_creat(stack *);
19 int stack_isempty(stack *);
20 int stack_setempty(stack *)
21 int stack_push(stack *,int);
22 int stack_pop(stack *,int);
23 int stack_destroy(stack *);
24 int stack_clear(stack *);
25 int stack_getnum(stack *);
26 
27 #endif /* defined(____seqstack__) */
28 
29 
30 
31 
32 
33 #ifndef ____seqstack__
34 #define ____seqstack__
35 
36 #include <stdio.h>
37 #include <stdlib.h>
38 
39 
40 typedef int datatype;
41 #define STACKSIZE 100;
42 
43 typedef struct
44 {
45     datatype *top;
46     datatype *base;
47     int stacksize;
48 }stack;
49 
50 int stack_creat(stack *);
51 int stack_isempty(stack *);
52 int stack_setempty(stack *)
53 int stack_push(stack *,int);
54 int stack_pop(stack *,int);
55 int stack_destroy(stack *);
56 int stack_clear(stack *);
57 int stack_getnum(stack *);
58 
59 #endif /* defined(____seqstack__) */

/*
 顺序栈存储方式，栈是一种特殊的线性表，其操作是线性表操作的特例。栈的顺序存储表示又称顺序栈，它是利用一组地址连续的存储单元一次存放自栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置。
*/
/*
 1.栈中元素采用向量存储。
 2.栈底位置固定不变，可设置在向量两端任意位置。
 3.栈顶用top指针表示，栈顶位置，随着变量不断变化
 */

/*
 栈的初始化，进栈，出栈，栈的销毁，清空栈，获取栈元素个数。
 A 进栈
 1.栈空条件 s->top == base;
 2.栈满条件 s->top == stacksize;
 3.进栈注意条件，s->top+1;
 4.进栈前判断，栈满s->top == stacksize;
 5.栈满容易产生上溢。
 B 出栈
 1.出栈时，s->tao-1
 2.出栈时，判断栈是否为空。
 */
#include "seqstack.h"

//顺序栈的初始化
int stack_creat(stack *stack)
{
    stack->base = (stack *)malloc(sizeof(STACKSIZE * (stack)));
    
    if (!stack->base)
        return -1;
    stack->top = stack->base;
    
    s->stacksize = STACKSIZE;
    
}
//栈判断是否为空
int stack_isempty(stack *stack)
{
    if (stack->top == stack->base)
        return 0;
    else
        return -1;
}
//设置空栈
int stack_setempty(stack *stack)
{
    if (stack->top == stack->base)
        return 0;
    else
    {
        stack->top = stack->base;
        return 0;
    }
}
//入栈
int stack_push(stack *stack,stack *s)
{
    if (stack->top >= stack->base + STACKSIZE)
    {
        //容易造成错误，relloc存在的问题。造成内存泄漏
        stack->base = (stack *)relloc(stack->base,(STACKSIZE + stack->stacksize) * sizeof(stack))
        if (!stack->base)
            return -1;
        stack->top = stack->base;
        stack->stacksize += STACKSIZE;
    }
    *(stack->top) = *s;
    stack->top ++;
    
}
//出栈
int stack_pop(stack *stack,stack *s)
{
    if (stack->top == stack->base)
        return -1;
    *s = *(stack->top);
    return 0;
}
//销毁栈
int stack_destroy(stack *stack)
{
    free(stack->base);
    stack->base = s ->top = NULL;
    stack->stacksize = 0;
    return 0;
}
//栈清空
int stack_clear(stack *stack)
{
    stack->top = stack->base;
    
    return 0;
}
//获得栈的元素数
int stack_getnum(stack *stack)
{
    return stack->top - stack->base;
}

 

 

转载于:https://www.cnblogs.com/lishengying/p/5258142.html