初入栈学习（一）

# include<stdio.h>
# include<stdlib.h>
# define STACK_INIT_SIZE 5 //初始化栈大小
# define STACKINCREMENT 2  //每次realloc增量


typedef int DataType;


typedef struct SqStack{
    DataType *base;
    DataType *top;
    int stack_size;
}SqStack;
//初始化一个空栈，构造成功返回true，否则
//返回false,参数是已经声明的但还未初始化
//的栈
bool init_stack(SqStack *stack){
// 传入的参数为指针，必须判空
    if(stack==NULL) exit(-1);
    stack->base=(DataType*)malloc(sizeof(DataType)*STACK_INIT_SIZE);
    if(stack->base == NULL) exit(-1);
//初始化空栈
    stack->top=stack->base;
//初始化可用容量STACK_INIT_SIZE
    stack->stack_size = STACK_INIT_SIZE;


    return true;


}
//判断栈是否为空
// 返回值true(1) 栈为空 false(0) 栈非空
bool stack_is_empty(SqStack *stack){
//指针作为参数必须判空
    if(stack ==NULL) exit(-1);
//栈必须初始化
    if(stack->base ==NULL) exit(-1);
    if(stack->base == stack->top)
        return true;
    else
        return false;


}
//返回栈中元素的个数,也是栈的长度
int stack_length(SqStack *stack){
//指针作为参数必须判空
    if(stack == NULL) exit(-1);
//同类型指针相减表示为两个指针之间的元素个数
    int length = (stack->top - stack->base);
    return length;


}
// 压栈，使其成为栈顶元素
//返回值：把数据data成功压入栈中 返回true(1),否则返回false(0)
bool stack_push(SqStack *stack,DataType *data){


    if(stack == NULL || data == NULL) exit(-1);
    if((stack->top - stack->base) >= stack->stack_size){
// realloc()
        stack->base=(DataType*)realloc(stack->base,sizeof(DataType)*(stack->stack_size + STACKINCREMENT));
       if(stack->base == NULL) exit(-1);//内存分配异常
// 栈顶元素重新指向原来栈顶元素的下一位
       stack->top=stack->base+stack->stack_size;
//重新分配内存后,栈的容量改变
       stack->stack_size+=STACKINCREMENT;
    }
//先将数据data压栈,top指针做偏移
    *stack->top=*data;
    ++stack->top;
    return true;
}
//若栈不为空,则删除栈顶元素 s.pop()
//返回值:删除成功返回true(1) 否则返回flase(0)
bool stack_pop(SqStack *stack,DataType *data){


    if(stack == NULL || data == NULL) exit(-1);
//栈没有初始化,不能删除栈顶元素
    if(stack->base == NULL ) return false;
//栈为空
    if(stack->base == stack->top)
        return false;
    else{
        --stack->top;
        *data=*stack->top;//取栈顶元素
    }


    return true;
}


//返回栈顶元素 s.top()


bool stack_top(SqStack *stack,DataType *data){
    if(stack == NULL || data == NULL ) exit(-1);
    if(stack->base == stack->top)
        return false;
    else{
        *data=*(stack->top-1);
        return true;
    }


}










bool stack_traverse(SqStack *stack ){


    if(stack == NULL ) return false;
    if(stack->base == stack ->top)
        return false;
    else{
        //设置一个指向元素的临时指针变量,用来遍历整个栈
        DataType *pdata=stack->top;
        while(pdata!=stack->base){
//注意这里我定义的是DataTye 是int 所以格式控制用%d
                 --pdata;
            printf("%d\n",*pdata);
        }
         return true;
    }


}
//清除栈中的元素,执行此操作后,栈stack为空栈
//返回值 true(1)栈已为空false(0)清空异常
bool clear_stack(SqStack *stack){
    if(stack ==NULL) exit(-1);
    if(stack->base ==NULL) return false;
    stack->top=stack->base;
    return true;
}


bool destroy_stack(SqStack *stack){
    if(stack == NULL ) exit(-1);
//free()   
    free(stack->base);
//将指针置空,防止野指针  
    stack->base=NULL;
    stack->top=NULL;
    stack->stack_size=0;


    return true;
}












int main(){


    SqStack stack;
    SqStack *pstack1=&stack;
    SqStack *pstack2=NULL;
    bool is_init=false;
    is_init=init_stack(pstack1);
    // 初始化成功 is_init==1
    printf("init_stack =is_init is %d\n",is_init);
    printf("\n");


    bool is_empty=false;
    //因为只是初始化栈，并未向栈中压入元素，所以栈为空
    //栈空 返回1
    is_empty=stack_is_empty(pstack1);
    printf("stack_is_empty =is_empty is %d\n",is_empty);
    printf("\n");


    int length = stack_length(pstack1);
    printf("stack_length =length is %d\n",length);
    printf("\n");


    bool is_push=false;
    DataType data[]={1,2,3,4,5,6,7};


    stack_push(pstack1,&data[0]);
    //声明一个top_data 用来显示压入栈和弹出栈的数据
    DataType top_data;
    stack_top(pstack1,&top_data);
    printf("这次压入栈中的元素为 %d\n",top_data);


    length=stack_length(pstack1);
    printf("当前栈中元素的个数(栈的长度) %d\n",length);
    printf("\n");


    stack_push(pstack1,&data[1]);
    stack_top(pstack1,&top_data);
    printf("这次压入栈中的元素为 %d\n",top_data);


    length=stack_length(pstack1);
    printf("当前栈中元素的个数(栈的长度) %d\n",length);
    printf("\n");


    stack_push(pstack1,&data[2]);
    stack_top(pstack1,&top_data);
    printf("这次压入栈中的元素为 %d\n",top_data);


    length=stack_length(pstack1);
    printf("当前栈中元素的个数(栈的长度) %d\n",length);
    printf("\n");


    stack_push(pstack1,&data[3]);
    stack_top(pstack1,&top_data);
    printf("这次压入栈中的元素为 %d\n",top_data);


    length=stack_length(pstack1);
    printf("当前栈中元素的个数(栈的长度) %d\n",length);
    printf("\n");


    stack_push(pstack1,&data[4]);
    stack_top(pstack1,&top_data);
    printf("这次压入栈中的元素为 %d\n",top_data);


    length=stack_length(pstack1);
    printf("当前栈中元素的个数(栈的长度) %d\n",length);
    printf("\n");
    //重新分配内存
    stack_push(pstack1,&data[5]);
    stack_top(pstack1,&top_data);
    printf("这次压入栈中的元素为 %d\n",top_data);


    length=stack_length(pstack1);
    printf("当前栈中元素的个数(栈的长度) %d\n",length);
    printf("\n");
    //栈满
    stack_push(pstack1,&data[6]);
    stack_top(pstack1,&top_data);
    printf("这次压入栈中的元素为 %d\n",top_data);


    length=stack_length(pstack1);
    printf("当前栈中元素的个数(栈的长度) %d\n",length);
    printf("\n");




    stack_push(pstack1,&data[0]);
    // 再分配内存STACKINCREMENT 并将元素1压入栈 ，
    //此时顺序栈的容量为
    //STACK_INIT_SIZE（5）+STACKINCREMENT(2)+ STACKINCREMENT(2) == 9,
    //已用内存空间为 8，栈未满
    stack_top(pstack1,&top_data);
    printf("这次压入的栈中元素为：%d\n",top_data);


    length = stack_length(pstack1);//定义一个int 变量来记录 当前栈的长度也就是栈中的元素数
    printf("当前栈中元素的个数(栈的长度) %d\n",length);
    printf("\n");


    //因为栈已经初始化了,并且向栈中压入元素，所以栈非空
    //重新判断下栈是否为空
    is_empty=false;
    is_empty=stack_is_empty(pstack1);
    printf("stack_is_empty =is_empty is %d\n\n",is_empty);


    //从栈底到栈顶遍历栈中元素，并输出栈中的每个元素
    bool is_traverse =false;
    printf("显示栈:\n");
    is_traverse=stack_traverse(pstack1);
    printf("遍历是否成功？ %d\n\n",is_traverse);
    //若果栈不为空,
    //声明一个top_data 用来显示删除的栈顶元素
    bool is_pop;
    DataType pop_data;
    printf("删除元素的顺序依次是:\n");
    while(pstack1->top != pstack1->base){
    is_pop=stack_pop(pstack1,&pop_data);
    printf("%d   删除成功？:%d\n",pop_data,is_pop);
    }
    printf("\n");


    bool is_clear=false;
    is_clear=clear_stack(pstack1);
    printf("栈是否被清空？:%d\n",is_clear);
    printf("判断栈是否为空栈? :%d\n",stack_is_empty(pstack1));
    //测试删除空栈
    is_pop=stack_pop(pstack1,&pop_data);
    printf("空栈是否能够成功删除？：%d\n",is_pop);


//可进行摧毁栈操作执行此操作后，栈stack不再存在，
//栈的其它操作都不能进行，
//除非调用 init_stack（stack）重新生成一个新栈






    return 0;

}

#include<stack>




定义栈如下：


stack<int> stk;


栈的基本操作：




s.empty()               如果栈为空返回true，否则返回false  
s.size()                返回栈中元素的个数  
s.pop()                 删除栈顶元素但不返回其值  
s.top()                 返回栈顶的元素，但不删除该元素  
s.push()                在栈顶压入新元素  




队列的头文件


#include<queue>




 
定义队列如下：


queue<int> q;
队列的几种基本操作：
q.empty()               如果队列为空返回true，否则返回false  
q.size()                返回队列中元素的个数  
q.pop()                 删除队列首元素但不返回其值  
q.front()               返回队首元素的值，但不删除该元素  
q.push()                在队尾压入新元素  
q.back()                返回队列尾元素的值，但不删除该元素  

//参考自http://blog.csdn.net/tianxiaolu1175/article/details/47833593