数据结构学习之堆栈（顺序存储）

【摘要】在计算机领域，堆栈是一个不容忽视的概念，堆栈是两种数据结构。堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。在单片机应用中，堆栈是个特殊的存储区，主要功能是暂时存放数据和地址，通常用来保护断点和现场。要点：堆，队列优先,先进先出[1] 。栈，先进后出(First-In/Last-Out)。

其实，堆栈的属性主要表现在下面两个方面：
（1）堆栈的数据是先入后出
（2）堆栈的长度取决于栈顶的高度

1、顺序存储（连续内存）

（1） 设计堆栈节点

typedef struct _STACK_NODE
{
    int* pData;
	int length;//栈的长度
	int top;//栈顶指针的位置
}STACK_NODE;

（2）创建堆栈

STACK_NODE* alloca_stack(int number)
{
    STACK_NODE* pStackNode = NULL;
    if(0 == number)
	    return NULL;
	
    pStackNode = (STACK_NODE*)malloc(sizeof(STACK_NODE));
    assert(NULL != pStackNode);
    memset(pStackNode, 0, sizeof(STACK_NODE));
	
    pStackNode->pData = (int*)malloc(sizeof(int) * number);
    if(NULL == pStackNode->pData){
	    free(pStackNode);
	    pStackNode = NULL;
        return NULL;
    }
	
    memset(pStackNode->pData, 0, sizeof(int) * number);
    pStackNode-> length = number;
    pStackNode-> top= 0;
    return pStackNode;
}

（3）释放堆栈

STATUS free_stack(const STACK_NODE* pStackNode)
{
    if(NULL == pStackNode)
        return FALSE;
	
    assert(NULL != pStackNode->pData);	
		
    free(pStackNode->pData);
    free((void*)pStackNode);
    return TRUE;
}

（4）堆栈压入数据

STATUS stack_push(STACK_NODE* pStackNode, int value)
{
    if(NULL == pStackNode)
        return FALSE;
		
    if(pStackNode->length == pStackNode->top)
        return FALSE;
		
    pStackNode->pData[pStackNode->top ++] = value;
    return TRUE;
}

（5）堆栈弹出数据

STATUS stack_pop(STACK_NODE* pStackNode, int* value)
{
    if(NULL == pStackNode || NULL == value)
        return FALSE;
		
    if(0 == pStackNode->top)
        return FALSE;
		
    *value = pStackNode->pData[-- pStackNode->top];
    return TRUE;
}

（6）统计当前堆栈中包含多少数据

int count_stack_number(const STACK_NODE* pStackNode)
{
    return pStackNode->top;
}

全部代码如下：

//顺序存储
//Written by ZP1015
//2015.10.20

#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

struct  STACK_NODE
{
    int* pData;/*数组，长度为StackLenMax*/
    int top;//栈顶指针的位置
    int StackLenMax;
};

struct STACK_NODE* alloc_stack(int StackSize)
{
     
    if(StackSize <= 0)
        return NULL;
	
	struct STACK_NODE* pStackNode = NULL;
	
    pStackNode = (struct STACK_NODE*)malloc(sizeof(struct STACK_NODE));
    if(NULL == pStackNode) {
		return NULL;
    }
	
    memset(pStackNode, 0, sizeof(struct STACK_NODE));

    pStackNode->pData = (int *)malloc(sizeof(int)*StackSize);
    if(NULL == pStackNode->pData){
		goto malloc_failed;
    }
	
	printf("%d\n",pStackNode->pData);
	
    memset(pStackNode->pData, 0, sizeof(int) * StackSize);
    pStackNode->top= -1; /*初始化从0开始*/
	pStackNode->StackLenMax = StackSize;
	
    return pStackNode;

malloc_failed:
	free(pStackNode);
	return NULL;
}

int free_stack(struct STACK_NODE* pStackNode)
{
    if(NULL == pStackNode)
        return -1;

    if(NULL == pStackNode->pData) {
		free(pStackNode);
		return -1;
	}
	printf("%d\n",pStackNode->pData);
	printf("[%d] %d\n",__LINE__,pStackNode->pData[2]);
    free(pStackNode->pData);
    free(pStackNode);
	
    return 0;
}

int stack_push(struct STACK_NODE* pStackNode, int value)
{
	/*1.异常处理*/
    if(NULL == pStackNode)
        return -1;
	if(NULL == pStackNode->pData) {
		return -1;
	}
	
	/*2.栈满，不能压入元素*/
    if(pStackNode->top == pStackNode->StackLenMax-1)
        return -1;
	printf("%d\n",pStackNode->top);
    pStackNode->pData[++pStackNode->top] = value;

    return 0;
}

int stack_pop(struct STACK_NODE* pStackNode, int* value)
{
    if(NULL == pStackNode || NULL == value)
        return -1;

    if(-1 == pStackNode->top)
        return -1;

    *value = pStackNode->pData[pStackNode->top--];
	
    return 0;
}

int count_stack_number(struct STACK_NODE* pStackNode)
{
    return (pStackNode->top+1);
}

void print_stack_node(struct STACK_NODE *pStackNode) 
{
	/*1.输入的参数有误*/
    if(NULL == pStackNode) {
		printf("[%d] pStackNode is illegal! \n",__LINE__);
		return;
    }
	/*2.输入的链式堆栈为空*/
	if(-1 == pStackNode->top) {
		printf("[%d] pStackNode is empty!\n",__LINE__);
		return ;
	}
	
	struct STACK_NODE *pStackNodeTemp = pStackNode;
	int count = 0;
	
	while(count <= pStackNode->top) {
		printf("%d ",pStackNodeTemp->pData[count]);
		count++;;
	}
	printf("\n");
}


int main()
{
	struct STACK_NODE *pStackNode;
	pStackNode = alloc_stack(20);
	int i = 0;
	for (i = 0;i<10;i++) {
		stack_push(pStackNode,i);
	}
	print_stack_node(pStackNode);


	free_stack(pStackNode);

	getchar();
	getchar();
	
	return 0;
}