顺序链表的C风格实现

 //头文件
 #ifndef _SEQLIST_H_
 #define _SEQLIST_H_
 //定义数据类型
 typedef void SeqList;
 typedef void SeqListNode;  

 //顺序链表的生成
 SeqList* SeqList_Create(int capacity);
 //顺序链表的删除
 void SeqList_Destory(SeqList* list);
 //顺序链表的清空
 void SeqList_Clear(SeqList* list);
 //返回链表长度
 int SeqList_Length(SeqList* list);
 //返回链表容量
 int SeqList_Capacity(SeqList* list);
 //在POS位置插入节点
 int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
 //获取POS位置的节点信息
 SeqListNode* SeqList_Get(SeqList* list, int pos);
 //删除POS位置的节点信息
 SeqListNode* SeqList_Delete(SeqList* list, int pos);  

 #endif

 //Cpp

 #include "seqList.h"
 #include <iostream>
 using namespace std;
 //定义一个链表头
 typedef struct _tag_SeqList
 {
     int length;
     int capacity;
     unsigned int **node; //       使用**防止数据丢失
 }TSeqList;

 //创建一个线性表
 SeqList* SeqList_Create(int capacity)
 {
     int ret = ;
     TSeqList *temp = NULL;   //创建临时指针变量remp

     temp = (TSeqList *)malloc((sizeof(TSeqList)));  //分配内存
     //异常处理
     if (temp == NULL)
     {
         ret = -;
         cout << "SeqList_Create Err!" << endl;
         return NULL;
     }
     memset(temp, , sizeof(TSeqList));  // 快速填充为0

     //为所有节点分配内存空间 （*容量）
     temp->node = (unsigned int **)malloc(sizeof(unsigned int *) * capacity);

     if (temp->node == NULL)
     {
         ret = -;
         cout << "SeqList_Create Err!  (malloc..)" << endl;
         return NULL;
     }

     temp->capacity = capacity;
     temp->length = ;
     return temp;
 }

 //删除(释放)一个线性表
 void SeqList_Destory(SeqList* list)
 {
     TSeqList *tlist = NULL;
     //判断是否为空
     if(list == NULL)
     {
         cout << "Destory Err" << endl;
         return ;
     }
     tlist = (TSeqList *)list;
     //先释放node内存 再释放List内存
     if (tlist->node != NULL)
     {
         free(tlist->node);
     }
     free(tlist);

     return;
 }

 //清空一个线性表
 void SeqList_Clear(SeqList* list)
 {
     TSeqList *tlist = NULL;
     if(list == NULL)
     {
         cout << "Clear Err " << endl;
         return ;
     }
     //直接将链表的长度重置为0
     tlist = (TSeqList *)list;
     tlist->length = ;
     return;
 }

 //返回一个线性表的长度
 int SeqList_Length(SeqList*    list)
 {
     TSeqList *tlist = NULL;
     //异常处理
     if(list == NULL)
     {
         cout << "Length Err, list == NULL" << endl;
         return -;
     }

     tlist = (TSeqList *)list;
     return tlist->length;
 }

 //返回线性表的容量
 int SeqList_Capacity(SeqList* list)
 {
     TSeqList *tlist = NULL;
     //异常处理
     if(list == NULL)
     {
         cout << "Capacity Err, list == NULL" << endl;
         return -;
     }
     tlist = (TSeqList *)list;

     return tlist->capacity;
 }

 //在POS位置插入一个节点
 int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
 {
     int i = ;
     int ret = ;
     TSeqList *tlist = NULL; 

     //异常处理
     if(list == NULL || node == NULL || pos<)
     {
         cout << "Insert Err, (list == NULL || node == NULL || pos<0)" << endl;
         ret = -;
         return ret;
     }
     tlist = (TSeqList *)list;

     //判断是否满了
     if (tlist->length >= tlist->capacity)
     {
         cout << "满了" << endl;
         ret = -;
         return ret;
     }
     //容错修正 如果插入的pos位置大于链表长度 并且此时容量未满
     if (pos >= tlist->length)  /////////
     {
         pos = tlist->length;
     }

     //位置后移并储存
     for(i = tlist->length; i > pos; i--)
     {
         tlist->node[i] = tlist->node[i-];
     }
     //将node[i]改为node
     tlist->node[i] = (unsigned int*) node;
     tlist->length++;
     return ;

 }

 //获取节点信息
 SeqListNode* SeqList_Get(SeqList* list, int pos)
 {
     TSeqList *tlist = NULL;
     //异常处理
     if(list == NULL || pos < )
     {
         cout << "SeqList_Get Err, list == NULL" << endl;
         return NULL ;
     }
     tlist = (TSeqList *)list;
     //强制类型转换
     return (SeqListNode*)tlist->node[pos];
 }

 //删除一个节点
 SeqListNode* SeqList_Delete(SeqList* list, int pos)
 {
     TSeqList *tlist = NULL;
     SeqListNode* ret = ;
     //异常处理
     if(list == NULL || pos < )
     {
         cout << "Delete Err" << endl;
         return NULL ;
     }
     tlist = (TSeqList *)list;
     //将POS位置的node地址给临时ret指针变量
     ret = (SeqListNode*)tlist->node[pos];
     //pos 位置后的元素往前移动
     for(int i = pos + ; i < tlist->length; i++)
     {
         tlist->node[i - ] = tlist->node[i];
     }
     tlist->length--;
     //返回删除的元素
     return ret;
 }

测试代码:

 #include "User.h"
 #include "seqList.h"
 #include <iostream>

 using namespace std;
 //定义一个结构体
 typedef struct Teacher
 {
     int age;
     char name[];

 }teacher;

 int main0()
 {
     int ret = ;
     int i = ;
     //创建顺序链表
     SeqList* list = NULL;
     list = SeqList_Create();

     teacher t1,t2,t3,t4,t5;

     t1.age = ;
     t2.age = ;
     t3.age = ;
     t4.age = ;
     t5.age = ;
     //头插法插入元素
     ret = SeqList_Insert(list, (SeqListNode*) &t1, );  //测试容错
     ret = SeqList_Insert(list, (SeqListNode*) &t3, );
     ret = SeqList_Insert(list, (SeqListNode*) &t4, );
     ret = SeqList_Insert(list, (SeqListNode*) &t5, );
     //遍历元素并显示age
     for (;i < SeqList_Length(list); i++)
     {
         teacher* temp = (teacher*) SeqList_Get(list, i);
         if (temp == NULL)
         {
             return ;
         }
         //cout << "temp->age: " << ((teacher* )SeqList_Get(list, i))->age << endl;
         cout << "temp->age: " << temp->age << endl;
     }
     cout << endl;
     //删除 并显示删除结果
     int m = ;
     while (SeqList_Length(list) > )
     {
         teacher *t = NULL;
         t = (teacher*)SeqList_Delete(list, );
         cout << "第" << m << "次头删的数据" << endl;
         cout << "t->age" << t->age << endl;
         m++;
         cout << endl;
     }

     //每次遍历删除头部后的链表
     /*int m = 1;
     while (SeqList_Length(list) > 0)
     {
         SeqList_Delete(list, 0);
         cout << "第" << m << "次头删的结果" << endl;
         for (i = 0;i < SeqList_Length(list); i++)
         {
             teacher* temp = (teacher*) SeqList_Get(list, i);
             //cout << "temp->age: " << ((teacher* )SeqList_Get(list, i))->age << endl;
             cout << "temp->age: " << temp->age << endl;
         }
         m++;
         cout << endl;
     }
 */
     system("pause");
     return ;
 }