顺序链表的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 = 0;
    TSeqList *temp = NULL;   //创建临时指针变量remp
 
    temp = (TSeqList *)malloc((sizeof(TSeqList)));  //分配内存
    //异常处理
    if (temp == NULL)
    {
        ret = -1;
        cout << "SeqList_Create Err!" << endl;
        return NULL;
    }
    memset(temp, 0, sizeof(TSeqList));  // 快速填充为0
 
    //为所有节点分配内存空间 （*容量）
    temp->node = (unsigned int **)malloc(sizeof(unsigned int *) * capacity);
 
 
    if (temp->node == NULL)
    {
        ret = -2;
        cout << "SeqList_Create Err!  (malloc..)" << endl;
        return NULL;
    }
 
 
    temp->capacity = capacity;
    temp->length = 0;
    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 = 0;
    return;
}
 
 
//返回一个线性表的长度
int SeqList_Length(SeqList*    list)
{
    TSeqList *tlist = NULL; 
    //异常处理
    if(list == NULL)
    {
        cout << "Length Err, list == NULL" << endl;
        return -1;
    }
 
    tlist = (TSeqList *)list;
    return tlist->length;
}
 
 
//返回线性表的容量
int SeqList_Capacity(SeqList* list)
{
    TSeqList *tlist = NULL; 
    //异常处理
    if(list == NULL)
    {
        cout << "Capacity Err, list == NULL" << endl;
        return -1;
    }
    tlist = (TSeqList *)list;
 
    return tlist->capacity;
}
 
 
//在POS位置插入一个节点
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
    int i = 0;
    int ret = 0;
    TSeqList *tlist = NULL; 
 
    //异常处理
    if(list == NULL || node == NULL || pos<0)
    {
        cout << "Insert Err, (list == NULL || node == NULL || pos<0)" << endl;
        ret = -1;
        return ret;
    }
    tlist = (TSeqList *)list;
 
    //判断是否满了
    if (tlist->length >= tlist->capacity)
    {
        cout << "满了" << endl;
        ret = -2;
        return ret;
    }
    //容错修正 如果插入的pos位置大于链表长度 并且此时容量未满
    if (pos >= tlist->length)  /////////
    {
        pos = tlist->length;
    }
 
    //位置后移并储存
    for(i = tlist->length; i > pos; i--)
    {
        tlist->node[i] = tlist->node[i-1];
    }
    //将node[i]改为node
    tlist->node[i] = (unsigned int*) node;
    tlist->length++;
    return 0;
 
}
 
 
//获取节点信息
SeqListNode* SeqList_Get(SeqList* list, int pos)
{
    TSeqList *tlist = NULL; 
    //异常处理
    if(list == NULL || pos < 0)
    {
        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 = 0;
    //异常处理
    if(list == NULL || pos < 0)
    {
        cout << "Delete Err" << endl;
        return NULL ;
    }
    tlist = (TSeqList *)list;
    //将POS位置的node地址给临时ret指针变量
    ret = (SeqListNode*)tlist->node[pos];
    //pos 位置后的元素往前移动
    for(int i = pos + 1; i < tlist->length; i++)
    {
        tlist->node[i - 1] = 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[64];
 
}teacher;
 
 
int main0()
{
    int ret = 0;
    int i = 0;
    //创建顺序链表
    SeqList* list = NULL;
    list = SeqList_Create(10);
 
    teacher t1,t2,t3,t4,t5;
 
    t1.age = 31;
    t2.age = 32;
    t3.age = 33;
    t4.age = 34;
    t5.age = 35;
    //头插法插入元素
    ret = SeqList_Insert(list, (SeqListNode*) &t1, 9);  //测试容错
    ret = SeqList_Insert(list, (SeqListNode*) &t3, 0);
    ret = SeqList_Insert(list, (SeqListNode*) &t4, 0);
    ret = SeqList_Insert(list, (SeqListNode*) &t5, 0);
    //遍历元素并显示age
    for (;i < SeqList_Length(list); i++)
    {
        teacher* temp = (teacher*) SeqList_Get(list, i);
        if (temp == NULL)
        {
            return 1;
        }
        //cout << "temp->age: " << ((teacher* )SeqList_Get(list, i))->age << endl;
        cout << "temp->age: " << temp->age << endl;
    }
    cout << endl;
    //删除 并显示删除结果
    int m = 1;
    while (SeqList_Length(list) > 0)
    {
        teacher *t = NULL;
        t = (teacher*)SeqList_Delete(list, 0);
        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 0;
}