05单链表的简单实现与测试

/*
*ListList.h
*/
#ifndef LINKLIST_H
#define LINKLIST_H

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//让用户的数据包含这个结构体
typedef struct _LinkNode{
	struct LinkNode *next;
}LinkNode;
//链表结构体
typedef struct _List{
	LinkNode head;
	int size;
}List;
//初始化，建立一个新的链表
int InitList(List **list);
//线性表已经存在，销毁线性表
void DestroyList(List **list);
//线性表L已经存在，将线性表置为空表
void ClearList(List *list);
//线性表已存在，若线性表为空，返回0，否则返回-1
int ListEmpty(const List list);
//线性表已存在，返回线性表的元素个数
int ListLength(const List *list);
//线性表已存在，1≤i≤ListLength(list); 将线性表中的第pos个位置的元素返回给
int GetElem(const List *list, const int pos, void **elem);
//线性表已存在,在线性表中的第pos个位置插入
void ListInsert(const List *list, int pos, void *elem);
//线性表已存在，删除线性表中的第pos个位置元素，并用elem返回其值
void ListDelete(const List *list, int pos, void **elem);
//遍历
void ListForeach(const List *list, void(*foreach)(void*));

#endif

/*
*ListList.c
*/

#include "LinkList.h"

//初始化成功返回0，失败返回-1
int InitList(List **list)
{
	*list = (List*)malloc(sizeof(List));
	if (NULL == list){
		return -1;
	}
	(*list)->head.next = NULL;
	(*list)->size = 0;
	return 0;
}

void DestroyList(List **list)
{
	if (NULL != *list){
		free(*list);
		*list = NULL;
	}
}

void ClearList(List *list)
{
	if (NULL != list){
		list->head.next = NULL;
		list->size = 0;
	}
}

//线性表L已存在，若线性表为空，返回0，否则返回-1,传入参数错误返回-2
int ListEmpty(const List *list)
{
	if (NULL != list){
		return -2;
	}
	if (0 != list->size){
		return -1;
	}
	return list->size;
}

//获取元素个数，出错返回-1
int ListLength(const List *list)
{
	if (NULL == list){
		return -1;
	}
	List *mylist = (List*)list;
	return mylist->size;
}

//根据位置获取值
int GetElem(const List *list, const int pos, void **elem)
{
	if (NULL == list){
		return -1;
	}
	const List *mylist = list;
	if ((mylist->size - 1) < pos || pos < 0){
		return -1;
	}
	LinkNode *pCur = &(mylist->head);
	for (int i = 0; i < pos; i++){
		pCur = pCur->next;
	}
	*elem = pCur->next;
	return 0;
}

void ListInsert(const List *list, int pos, void *elem)
{
	//传入参数判断
	if (NULL == list || NULL == elem){
		return;
	}
	List *mylist = (List*)list;
	if (mylist->size < pos  || pos < 0){
		pos = mylist->size;
	}
	//找到pos位置结点的前一个结点
	LinkNode *pCur = &(mylist->head);
	for (int i = 0; i < pos; i++){
		pCur = pCur->next;
	}
	//将新结点插入链表
	((LinkNode*)elem)->next = pCur->next;
	pCur->next = (LinkNode*)elem;
	mylist->size++;
}

void ListDelete(const List *list, int pos, void **elem)
{
	if (NULL == list){
		return;
	}
	List *mylist = list;
	if (0 == mylist->size){
		return;
	}
	if (mylist->size < pos || pos < 0){
		return;
	}
	LinkNode *pCur = &(mylist->head);
	for (int i = 0; i < pos; i++){
		pCur = pCur->next;
	}
	//缓存待删除的结点
	LinkNode *pDel = pCur->next;
	//重新建立前驱后继关系
	pCur->next = pDel->next;
	mylist->size--;
	*elem = pDel;
}

void ListForeach(const List *list, void(*foreach)(void*))
{
	if (NULL == list || NULL == foreach){
		return;
	}
	List *mylist = (List*)list;
	LinkNode *pCur = mylist->head.next;
	while (NULL != pCur){
		foreach(pCur);
		pCur = pCur->next;
	}
}

/*
*test.c
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "LinkList.h"

//用户的数据,用户的数据结构体的第一个成员必须包含规则的数据
typedef struct Maker{
	LinkNode node;
	char name[64];
	int age;
}Maker;

//测试输出函数
void myPrint(void *data)
{
	Maker *maker = (Maker*)data;
	printf("name: %s, age:%d\n", maker->name, maker->age);
}

int main()
{
	Maker p1 = { NULL, "aaa1", 18 };
	Maker p2 = { NULL, "aaa2", 19 };
	Maker p3 = { NULL, "aaa3", 20 };
	Maker p4 = { NULL, "aaa4", 21 };
	Maker p5 = { NULL, "aaa5", 22 };
	List *list;
	//初始化链表测试
	if (InitList(&list) != 0){
		printf("初始化链表失败\n");
		return -1;
	}
	//将数据插入链表
	ListInsert(list, 0, (LinkNode *)&p1);//用户的寻址范围缩小
	ListInsert(list, 0, (LinkNode *)&p2);
	ListInsert(list, 0, (LinkNode *)&p3);
	ListInsert(list, 0, (LinkNode *)&p4);
	ListInsert(list, 0, (LinkNode *)&p5);
	//遍历测试
	ListForeach(list, myPrint);
	//指定位置获取元素测试
	Maker *m;
	if (-1 != GetElem(list, 2, &m)){
		printf("m->name:%s,m->age:%d\n", m->name, m->age);
	}
	//获取链表个数测试
	printf("size:%d\n", ListLength(list));
	DestroyList(&list);
	system("pause");
	return 0;
}