顺序栈

顺序链表部分

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

typedef void SeqList;

typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list,SeqListNode* node,int pos);

SeqListNode* SeqList_Get(SeqList* list,int pos);

SeqListNode* SeqList_Delete(SeqList* list,int pos); 

#endif

#include <stdio.h>
#include <malloc.h>
#include "SeqList_V2.h"

typedef unsigned int TSeqListNode;

typedef struct _tag_SeqList{
	int length;
	int capacity;
	TSeqListNode* node;
}TSeqList;

SeqList* SeqList_Create(int capacity)
{
	TSeqList* ret = NULL; 
	if(capacity >= 0)
		ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity);
	if(ret != NULL){
		ret->length = 0;
		ret->capacity = capacity;
		ret->node = (TSeqListNode*)(ret + 1);
	}
	return ret;
}

void SeqList_Destroy(SeqList* list)
{
	free(list);
}

void SeqList_Clear(SeqList* list)
{
	TSeqList* sList = (TSeqList*)list;
	if(sList != NULL){
		sList->length = 0;
	} 
}

int SeqList_Length(SeqList* list)
{
	int ret = -1;
	TSeqList* sList = (TSeqList*)list;
	if(sList != NULL){
		ret = sList->length;
	} 
	return ret;
}

int SeqList_Capacity(SeqList* list)
{
	int ret = -1;
	TSeqList* sList = (TSeqList*)list;
	if(sList != NULL){
		ret = sList->capacity;
	} 
	return ret;
}

int SeqList_Insert(SeqList* list,SeqListNode* node,int pos)
{
	TSeqList* sList = (TSeqList*)list;
	
	int ret = (sList != NULL) && (node != NULL) && (pos >= 0) && (sList->length < sList->capacity);
	int i = 0;
	if(ret){
		if(pos > sList->length){
			pos = sList->length;
		}
		for(i = sList->length;i > pos;i--)
			sList->node[i] = sList->node[i -1];
			
		sList->node[i] = (TSeqListNode)node;//将指针赋值给整数，要类型转换 
		sList->length++;
	}
	return ret;
}

SeqListNode* SeqList_Get(SeqList* list,int pos)
{
	SeqListNode* ret = NULL;
	TSeqList* sList = (TSeqList*)list;
	if((sList != NULL) && (pos >= 0) && (pos < sList->length)){
		ret = (SeqListNode*)(sList->node[pos]);//将整数赋值给指针，也要类型转换,注意运算符的优先级和结合性  
	}
	return ret;
}

SeqListNode* SeqList_Delete(SeqList* list,int pos)
{
	SeqListNode* ret = SeqList_Get(list,pos);
	TSeqList* sList = (TSeqList*)list;
	int i = 0;
	if(ret != NULL){
		for(i = pos + 1;i < sList->length;i++){
			sList->node[i-1] = sList->node[i]; 
		}
		sList->length--;
	}
	 
	return ret;
}

顺序栈部分

#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_Size(SeqStack* stack);

int SeqStack_Capacity(SeqStack* stack);

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

void* SeqStack_Pop(SeqStack* stack);

void* SeqStack_Top(SeqStack* stack);

#endif

#include "SeqList_V2.h"
#include "SeqStack.h"

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_Size(SeqStack* stack)
{
	return SeqList_Length(stack); 
}

int SeqStack_Capacity(SeqStack* stack)
{
	return SeqList_Capacity(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);
}

测试程序

#include <stdio.h>
#include <stdlib.h>
#include "SeqStack.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *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);
    
	return 0;
}