測試框架
#include"Stack.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"SeqList.h"
///*創建列表*/
//SeqStack * List_Create(int capacity);
///*釋放列表*/
//void List_Destory(SeqStack* stack);
///*清空列表 回到初始狀態*/
//void List_Clear(SeqStack* stack);
///*獲取鏈表的長度*/
//int Stack_Push(SeqStack* stack, void* item);
//
//void* Stack_Pop(SeqStack* stack);
//void* Stack_Top(SeqStack* stack);
//int Stack_Size(SeqStack* stack);
//int Stack_Capacity(SeqStack* stack);
void main()
{
int i = 0;
int a[10];
SeqStack * stack= List_Create(10);
if (stack == NULL)
{
return;
}
//壓棧
for ( i = 0; i < 5; i++)
{
a[i] = i + 1;
Stack_Push(stack,&a[i]);
}
printf("Capacity:%d\n",Stack_Capacity(stack));
printf("Stack_Lenght:%d\n", Stack_Size(stack));
printf("Top:%d\n", *((int*)(Stack_Top(stack))));
while (Stack_Size(stack)>0)
{
int tmp = *((int*)(Stack_Pop(stack)));
printf("tmp:%d\n",tmp);
}
printf("\n");
system("pause");
}
兩個頭文件 SeqList.h 和 Stack.h
Stack.h
#pragma once
#ifdef _MYLIST_H_
#define _MYLIST_H_
#endif // _MYSEQLIST_H_
typedef void SeqStack;
/*創建列表*/
SeqStack * List_Create(int capacity);
/*釋放列表*/
void List_Destory(SeqStack* stack);
/*清空列表 回到初始狀態*/
void List_Clear(SeqStack* stack);
//入棧
int Stack_Push(SeqStack* stack, void* item);
//出棧,即刪除棧頂元素
void* Stack_Pop(SeqStack* stack);
//獲取棧頂元素
void* Stack_Top(SeqStack* stack);
/*獲取鏈表的長度*/
int Stack_Size(SeqStack* stack);
//棧的容量
int Stack_Capacity(SeqStack* stack);
SeqList.h
#pragma once
#ifdef _MYSEQLIST_H_
#define _MYSEQLIST_H_
#endif // _MYSEQLIST_H_
//線性鏈表的順序存儲
//void指針表示未知類型的指針,可以將任意類型的指針直接賦值給void指針,好比是C#、Java中的object引用,可以把任意 類型的對象賦值給它。但把void類型賦值給特定類型的指針時,就需要進行強制轉換,因爲C++爲類型語言,儘可能保證類型安全,如果使用了強制類型轉 換,編譯器就認爲程序員知道他(她)在幹什麼,程序也應該負起這樣做的責任。
typedef void Seqlist;
typedef void SeqListNode;
Seqlist * List_Create1(int capacity);
void List_Destory1(Seqlist* list);
void List_Clear1(Seqlist* list);
int List_Length1(Seqlist* list);
int List_Capacity1(Seqlist* list);
SeqListNode* List_Get1(Seqlist* list, int pos);
int List_Inster1(Seqlist* list, SeqListNode* node, int pos);
SeqListNode* List_Delete1(Seqlist* list,int pos);
頭文件的實現
#include"SeqList.h"
#include<stdio.h>
#include<stdlib.h>
using namespace std;
struct TSeqList
{
int length;
int capacity;
unsigned int **node;
};
/*創建鏈表併爲鏈表分配空間*/
Seqlist* List_Create1(int capacity)
{
TSeqList* tmp = NULL;
tmp = (TSeqList*)malloc(sizeof(TSeqList));
if (tmp==NULL)
{
return NULL;
}
tmp->node =(unsigned int**)malloc(sizeof(unsigned int*)*capacity);
tmp->length = 0;
tmp->capacity = capacity;
return tmp;
}
/*銷燬鏈表並釋放鏈表的內存空間*/
void List_Destory1(Seqlist* list)
{
TSeqList* tlist = NULL;
if (list==NULL)
{
printf("List_Destory() err:");
return;
}
tlist = (TSeqList*)list;
if (tlist->node!=NULL)
{
free(tlist->node);
}
if (tlist->length!=0)
{
free(tlist);
}
return ;
}
/*清空鏈表,回到初始鏈表的狀態*/
void List_Clear1(Seqlist* list)
{
TSeqList* tlist = NULL;
if (list==NULL)
{
printf("List_Clear() err:");
return;
}
tlist = (TSeqList*)list;
tlist->length = 0;
return ;
}
/*鏈表長度大小*/
int List_Length1(Seqlist* list)
{
TSeqList* tlist = NULL;
if (list==NULL)
{
printf("List_Length() err:");
return -1;
}
tlist = (TSeqList*)list;
return tlist->length;
}
/*鏈表大小獲取*/
int List_Capacity1(Seqlist* list)
{
TSeqList* tlist = NULL;
if (list==NULL)
{
printf("List_Capacity() err:");
return -1;
}
tlist = (TSeqList*)list;
return tlist->capacity;
}
/*元素獲取*/
SeqListNode* List_Get1(Seqlist* list, int pos)
{
TSeqList* tlist = NULL;
if (list == NULL||pos<0)
{
printf("List_Get() err:");
return NULL;
}
tlist = (TSeqList*)list;
return tlist->node[pos];
}
/*元素插入*/
int List_Inster1(Seqlist* list, SeqListNode* node, int pos)
{
TSeqList* tlist = NULL;
if (list == NULL || pos<0||node==NULL)
{
printf("List_Inster() err:");
return -1;
}
int i = 0;
SeqListNode* ret = NULL;
tlist = (TSeqList*)list;
//判斷是不是鏈表中已經滿了
if (tlist->length==tlist->capacity)
{
printf("List_Inster() err: yiman");
return -2;
}
//容錯修正,比如 6歌長度 容量爲20,用戶在10位置插入,則進行容錯
if (pos>=tlist->length)
{
pos = tlist->length;
}
//數據元素後移 頭插法
for ( i = tlist->length; i > pos; i--)
{
tlist->node[i] = tlist->node[i-1];
}
//插入元素
tlist->node[i] = (unsigned int *)node;
tlist->length++;
return 0;
}
/*元素刪除*/
SeqListNode* List_Delete1(Seqlist* list, int pos)
{
TSeqList* tlist = NULL;
if (list==NULL||pos<0)
{
printf("List_Delete() err: ");
return NULL;
}
tlist = (TSeqList*)list;
SeqListNode* ret = NULL;
ret = tlist->node[pos];
int i = 0;
for ( i =pos+1; i <tlist->length; i++)
{
tlist->node[i - 1] = tlist->node[i];
}
tlist->length--;
return ret;
}
Stack.cpp
#include"Stack.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"SeqList.h"
/*創建列表 c創建棧相當於創建線性表*/
SeqStack * List_Create(int capacity)
{
return List_Create1(capacity);
}
/*釋放列表 銷燬棧相當於銷燬線性表*/
void List_Destory(SeqStack* stack)
{
return List_Destory1(stack);
}
/*清空列表 回到初始狀態 請空棧相當於清空線性表*/
void List_Clear(SeqStack* stack)
{
return List_Clear1(stack);
}
/*向棧中壓入元素,相當於向鏈表的尾部插入元素*/
int Stack_Push(SeqStack* stack, void* item)
{
return List_Inster1(stack, item, List_Length1(stack));//尾部插入,尾插法
}
//從棧中彈出元素,相當於從鏈表的尾部拿出元素
void* Stack_Pop(SeqStack* stack)
{
return List_Delete1(stack,List_Length1(stack)-1);
}
//獲取棧頂元素,相當於獲取鏈表的尾部元素
void* Stack_Top(SeqStack* stack)
{
return List_Get1(stack,List_Length1(stack)-1);
}
//獲取棧的大小,相當於獲取鏈表的實際長度
int Stack_Size(SeqStack* stack)
{
return List_Length1(stack);
}
//獲取棧的容量 相當於獲取線性表的容量
int Stack_Capacity(SeqStack* stack)
{
return List_Capacity1(stack);
}