棧的定義
1， 棧是一種特殊的線性表
2，棧僅能線上性表的一端進行操作
3，棧頂(Top)： 允許操作的一端 允許操作的一端
4，棧底(Bottom)： ,不允許操作的一端 不允許操作的一端

這裡我做出了 棧的順序實現 和 鏈式實現，分別如下：

=========================================華麗麗的分割線==========================================================

棧的順序實現：

首先，我們要弄明白的是，棧本質上就是線性表，是一種特殊的線性表，只是只能在一端進行操作罷了，故而很多操作線性表是很類似的。因此，我們可以將之前寫的  

標頭檔案：

#ifndef _SEQSTACK_H_
#define _SEQSTACK_H_

typedef void SeqStack;

SeqStack* SeqStack_Create(int capacity);

void SeqStack_Destroy(SeqStack* stack);

void SeqStack_Clear(SeqStack* stack);

int SeqStack_Push(SeqStack* stack, void* item);

void* SeqStack_Pop(SeqStack* stack);

void* SeqStack_Top(SeqStack* stack);

int SeqStack_Size(SeqStack* stack);

int SeqStack_Capacity(SeqStack* stack);

#endif
 

// 棧.cpp : 定義控制檯應用程式的入口點。
//

#include "stdafx.h"
#include <malloc.h>
#include <stdlib.h>
#include "SeqStack.h"
#include "SeqList.h"



int _tmain(int argc, _TCHAR* argv[])
{
	 SeqStack* stack = SeqStack_Create(20);
    int a[10];
    int i = 0;
    
    for(i=0; i<10; i++)
    {
        a[i] = i;
        
        SeqStack_Push(stack, a + i);
    }
    
    printf("Top: %d\n", *(int*)SeqStack_Top(stack));
    printf("Capacity: %d\n", SeqStack_Capacity(stack));
    printf("Length: %d\n", SeqStack_Size(stack));
    
    while( SeqStack_Size(stack) > 0 )
    {
        printf("Pop: %d\n", *(int*)SeqStack_Pop(stack));
    }
    
    SeqStack_Destroy(stack);
	system("pause");
	return 0;
}
//建立棧
SeqStack* SeqStack_Create(int capacity)
{
    return SeqList_Create(capacity);
}
//銷燬
void SeqStack_Destroy(SeqStack* stack)
{
    SeqList_Destroy(stack);
}
//清空
void SeqStack_Clear(SeqStack* stack)
{
    SeqList_Clear(stack);
}
//壓棧
int SeqStack_Push(SeqStack* stack, void* item)
{
    return SeqList_Insert(stack, item, SeqList_Length(stack));
}
//彈棧
void* SeqStack_Pop(SeqStack* stack)
{
    return SeqList_Delete(stack, SeqList_Length(stack) - 1);
}
//獲得棧頂
void* SeqStack_Top(SeqStack* stack)
{
    return SeqList_Get(stack, SeqList_Length(stack) - 1);
}
//棧的大小
int SeqStack_Size(SeqStack* stack)
{
    return SeqList_Length(stack);
}
//順序棧的總大小
int SeqStack_Capacity(SeqStack* stack)
{
    return SeqList_Capacity(stack);
}
 

Top: 9
Capacity: 20
Length: 10
Pop: 9
Pop: 8
Pop: 7
Pop: 6
Pop: 5
Pop: 4
Pop: 3
Pop: 2
Pop: 1
Pop: 0
請按任意鍵繼續. . .

棧的鏈式實現：

     同棧的順序實現一樣，棧的鏈式實現本質上其實就是單鏈表的形式，也只是在一頭操作罷了，因此我們這裡亦採用程式碼複用的方法，具體程式碼請參閱：。

標頭檔案：

#ifndef _LINKSTACK_H_
#define _LINKSTACK_H_

typedef void LinkStack;

LinkStack* LinkStack_Create();

void LinkStack_Destroy(LinkStack* stack);

void LinkStack_Clear(LinkStack* stack);

int LinkStack_Push(LinkStack* stack, void* item);

void* LinkStack_Pop(LinkStack* stack);

void* LinkStack_Top(LinkStack* stack);

int LinkStack_Size(LinkStack* stack);

#endif

#include "stdafx.h"
#include "LinkList.h"
#include "LinkStack.h"
#include <malloc.h>
#include <stdlib.h>



int main(int argc, char *argv[]) 
{
    LinkStack* stack = LinkStack_Create();
    int a[10];
    int i = 0;
    
    for(i=0; i<10; i++)
    {
        a[i] = i;
        
        LinkStack_Push(stack, a + i);
    }
    
    printf("Top: %d\n", *(int*)LinkStack_Top(stack));
    printf("Length: %d\n", LinkStack_Size(stack));
    
    while( LinkStack_Size(stack) > 0 )
    {
        printf("Pop: %d\n", *(int*)LinkStack_Pop(stack));
    }
    
    LinkStack_Destroy(stack);
	system("pause");
	return 0;
}


typedef struct _tag_LinkStackNode
{
    LinkListNode header;
    void* item;
} TLinkStackNode;
//建立
LinkStack* LinkStack_Create()
{
    return LinkList_Create();
}

//銷燬
void LinkStack_Destroy(LinkStack* stack)
{
    LinkStack_Clear(stack);
    LinkList_Destroy(stack);
}

//清空
void LinkStack_Clear(LinkStack* stack)
{
    while( LinkStack_Size(stack) > 0 )
    {
        LinkStack_Pop(stack);
    }
}


//壓棧
int LinkStack_Push(LinkStack* stack, void* item)
{
    TLinkStackNode* node = (TLinkStackNode*)malloc(sizeof(TLinkStackNode));
    int ret = (node != NULL) && (item != NULL);
    
    if( ret )
    {
        node->item = item;
        
        ret  = LinkList_Insert(stack, (LinkListNode*)node, 0);
    }
    
    if( !ret )
    {
        free(node);
    }
    
    return ret;
}

//出棧
void* LinkStack_Pop(LinkStack* stack)
{
    TLinkStackNode* node = (TLinkStackNode*)LinkList_Delete(stack, 0);
    void* ret = NULL;
    
    if( node != NULL )
    {
        ret = node->item;
        
        free(node);
    }
    
    return ret;
}

//獲得棧頂
void* LinkStack_Top(LinkStack* stack)
{
    TLinkStackNode* node = (TLinkStackNode*)LinkList_Get(stack, 0);
    void* ret = NULL;
    
    if( node != NULL )
    {
        ret = node->item;
    }
    
    return ret;
}

//獲得棧的大小
int LinkStack_Size(LinkStack* stack)
{
    return LinkList_Length(stack);
}

執行結果：

Top: 9
Length: 10
Pop: 9
Pop: 8
Pop: 7
Pop: 6
Pop: 5
Pop: 4
Pop: 3
Pop: 2
Pop: 1
Pop: 0
請按任意鍵繼續. . .

如有錯誤，望不吝指出~