1.普通链表
//头文件
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#ifndef _MY_LINKLIST_H_
#define _MY_LINKLIST_H_
typedef void LinkList;
//typedef void LinkListNode;
typedef struct _tag_LinkListNode
{
struct _tag_LinkListNode* next;
}LinkListNode;
//创建并且返回一个空的线性表
LinkList* LinkList_Create();
//销毁一个线性表
void LinkList_Destroy(LinkList* list);
//将一个线性表list中的所有元素清空, 线性表回到创建时的初始状态
void LinkList_Clear(LinkList* list);
//返回一个线性表list中的所有元素个数
int LinkList_Length(LinkList* list);
//向一个线性表list的pos位置处插入新元素node
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);
//获取一个线性表list的pos位置处的元素
LinkListNode* LinkList_Get(LinkList* list, int pos);
//删除一个线性表list的pos位置处的元素返回值为被删除的元素,NULL表示删除失败
LinkListNode* LinkList_Delete(LinkList* list, int pos);
#endif
//函数实现
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#include"LinkList.h"
typedef struct LinkList
{
LinkListNode header;
int length;
}TLinkList;
//创建并且返回一个空的线性表
LinkList* LinkList_Create()
{
TLinkList *tmp = NULL;
tmp = (TLinkList*)malloc(sizeof(TLinkList));
memset(tmp, 0, sizeof(TLinkList));
tmp->length = 0;
tmp->header.next = NULL;
return tmp;
}
//销毁一个线性表
void LinkList_Destroy(LinkList* list)
{
if (list != NULL)
{
free(list);
list = NULL;
}
return ;
}
//将一个线性表list中的所有元素清空, 线性表回到创建时的初始状态
void LinkList_Clear(LinkList* list)
{
TLinkList *tlist = NULL;
if (list == NULL)
{
return;
}
tlist = (TLinkList *)list;
tlist->length = 0;
tlist->header.next = NULL;
return ;
}
//返回一个线性表list中的所有元素个数
int LinkList_Length(LinkList* list)
{
TLinkList *tlist = NULL;
if (list == NULL)
{
return;
}
tlist = (TLinkList *)list;
return tlist->length;
}
//向一个线性表list的pos位置处插入新元素node
//指针指向谁就把谁的地址给指针
//分清 链表的操作逻辑和 辅助指针变量之间的关系
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
int i = 0, ret = 0;
LinkListNode* current=NULL;
TLinkList *tlist = NULL;
if (list == NULL||node==NULL||pos<0)
{
ret = -1;
printf("Func:LinkList_Insert err%d\t",ret);
return ;
}
tlist = (TLinkList *)list;
current = &(tlist->header);
for (i = 0; i < pos ; i++)
{
current = current->next;
}
//将node的next指向下一个元素的首地址
node->next=current->next;
//将上一个元素的next指向node的首地址
current->next=node;
tlist->length++;
return 0;
}
//获取一个线性表list的pos位置处的元素
LinkListNode* LinkList_Get(LinkList* list, int pos)
{
int i = 0, ret = 0;
LinkListNode* current = NULL;
TLinkList *tlist = NULL;
if (list == NULL || pos<0)
{
ret = 0;
printf("Func:LinkList_Insert err%d\t", ret);
return NULL;
}
tlist = (TLinkList *)list;
current = &(tlist->header);
for (i = 0; i < pos && (current->next != NULL); i++)
{
current = current->next;
}
return current->next;
}
//删除一个线性表list的pos位置处的元素返回值为被删除的元素,NULL表示删除失败
LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
int i = 0, ret = 0;
LinkListNode* current = NULL;
LinkListNode* tmp = NULL;
TLinkList *tlist = NULL;
if (list == NULL || pos<0)
{
ret = -1;
printf("Func:LinkList_Insert err%d\t", ret);
return;
}
tlist = (TLinkList *)list;
current = &(tlist->header);
for (i = 0; i < pos && (current->next != NULL); i++)
{
current = current->next;
}
//将删除元素nodede首地址找出来
tmp = current->next;
//将删除元素node的下一个元素的首地址赋给上一个元素的next
current->next = tmp->next;
tlist->length--;
return tmp;//返回删除元素的地址
}
//测试
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#include"LinkList.h"
typedef struct Teacher
{
LinkListNode node; //第一个结点(必须放在首位)
int age;
char name[64];
}Teacher ;
int main()
{
int len = 0, i = 0,ret=0;
LinkList* list = NULL;
Teacher t1, t2, t3, t4, t5;
t1.age = 31;
t2.age = 32;
t3.age = 33;
t4.age = 34;
t5.age = 35;
list = LinkList_Create();
len = LinkList_Length(list);
//插入
ret = LinkList_Insert(list, (LinkListNode*)&t1, 0);
ret = LinkList_Insert(list, (LinkListNode*)&t2, 0);
ret = LinkList_Insert(list, (LinkListNode*)&t3, 0);
ret = LinkList_Insert(list, (LinkListNode*)&t4, 0);
ret = LinkList_Insert(list, (LinkListNode*)&t5, 3);
//遍历
for (i = 0; i < LinkList_Length(list); i++)
{
Teacher *tmp = (Teacher *)LinkList_Get(list, i);
printf("tmp->age:%d\t",tmp->age);
}
//删除
while (LinkList_Length(list)>0)
{
Teacher *tmp = (Teacher *)LinkList_Delete(list, 0);
printf("tmp->age:%d\t", tmp->age);
}
//销毁
LinkList_Destroy(list);
system("pause");
return 0;
}
/
2.循环链表
//头文件
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#ifndef _MY_CIRCLELIST_H_
#define _MY_CIRCLELIST_H_
typedef void CircleList;
//typedef void CircleListNode;
typedef struct _tag_CircleListNode
{
struct _tag_CircleListNode* next;
}CircleListNode;
//创建
CircleList* CircleList_Create();
//销毁
void CircleList_Destroy(CircleList* list);
//清空
void CircleList_Clear(CircleList* list);
//求长
int CircleList_Length(CircleList* list);
//插入node数据元素到pos位置
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);
//获取pos位置的数据元素
CircleListNode* CircleList_Get(CircleList* list, int pos);
//删除pos位置的数据元素
CircleListNode* CircleList_Delete(CircleList* list, int pos);
//直接删除链表中的某个数据元素
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);
//重置链表中的第一个数据元素
CircleListNode* CircleList_Reset(CircleList* list);
//获取当前游标指向的数据元素
CircleListNode* CircleList_Current(CircleList* list);
//游标移动到下一个数据元素
CircleListNode* CircleList_Next(CircleList* list);
#endif
//函数实现
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#include"CircleList.h"
/*
typedef struct _tag_CircleListNode //结点
{
struct _tag_CircleListNode * next;
}CircleListNode;*/
typedef struct _tag_CircleList //链表
{
CircleListNode header;
CircleListNode* slider; //游标
int length;
}TCircleList;
CircleList* CircleList_Create()
{
TCircleList *list = (TCircleList *)malloc(sizeof(TCircleList));
if (list == NULL)
{
return NULL;
}
list->header.next = NULL;
list->slider = NULL;
list->length = 0;
}
void CircleList_Destroy(CircleList* list)
{
if (list!=NULL)
{
free(list);
list = NULL;
}
return ;
}
void CircleList_Clear(CircleList* list)
{
TCircleList *tmp = NULL;
if (list == NULL)
{
return NULL;
}
tmp = (TCircleList *)list;
tmp->length = 0;
tmp->slider = NULL;
tmp->header.next = NULL;
return ;
}
int CircleList_Length(CircleList* list)
{
TCircleList *tmp = NULL;
if (list == NULL)
{
return NULL;
}
tmp = (TCircleList *)list;
return tmp->length;
}
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
int i = 0;
TCircleList *slist = NULL;
CircleListNode* current = NULL;
if (list == NULL||node==NULL||pos<0)
{
return NULL;
}
slist = (TCircleList *)list;
current = &(slist->header);
for (i = 0; (i < pos) && (current->next != NULL); i++)
{
current = current->next;
}
node->next=current->next;//1
current->next = node;//2
//第一次插入元素
if (slist->length == 0)
{
slist->slider = node;
}
slist->length++;
//头插法的判定和方法
if (current == (CircleListNode*)slist)//头插法,current仍指向头部
{//获取最后一个元素
CircleListNode* last = (TCircleList*)CircleList_Get(slist,slist->length-1);
last->next = current->next;//3
}
return 0;
}
CircleListNode* CircleList_Get(CircleList* list, int pos)
{
TCircleList*slist = NULL;
if (list == NULL || pos < 0)
{
return NULL;
}
slist = (TCircleList*)list;
CircleListNode* current = (CircleListNode*)slist;
for (int i = 0; i < pos; i++)
{
current = current->next;
}
return current->next;
}
CircleListNode* CircleList_Delete(CircleList* list, int pos)
{
TCircleList*slist = (TCircleList*)list;
CircleListNode* ret = NULL;
if ((slist != NULL) && (pos >= 0)&&(slist->length>0))
{
CircleListNode* current = (CircleListNode*)slist;
CircleListNode* last = NULL;
for (int i = 0; i < pos; i++)
{
current = current->next;
}
//删除第一个结点
if (current == (CircleListNode*)slist)
{
last = (CircleListNode*)CircleList_Get(slist,slist->length-1);
}
ret = current->next;
current->next = ret->next;
slist->length--;
//判断链表是否为空
if (last != NULL)
{
slist->header.next = ret->next;
last->next = ret->next;
}
//若删除元素为游标所指元素
if (slist->slider == ret)
{
slist->slider = ret->next;
}
//判断删除元素后,长度是否为0
if (slist->length == 0)
{
slist->header.next = NULL;
slist->slider = NULL;
}
}
return ret;
}
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
{
TCircleList*slist = (TCircleList*)list;
CircleListNode* ret = NULL;
int i = 0;
if (slist!=NULL)
{
CircleListNode* current = (CircleListNode*)slist;
//查找删除元素node在链表中的位置
for ( i = 0; i < slist->length; i++)
{
if (current->next == node)
{
ret = current->next;
break;
}
current = current->next;
}
//找到node,根据i删除
if (ret != NULL)
{
CircleList_Delete(slist, i);
}
}
return ret;
}
CircleListNode* CircleList_Reset(CircleList* list)
{
TCircleList*slist = (TCircleList*)list;
CircleListNode* ret = NULL;
if (slist != NULL)
{
slist->slider = slist->header.next;//游标重新指向头结点
ret = slist->slider;
}
return ret;
}
CircleListNode* CircleList_Current(CircleList* list)
{
TCircleList*slist = (TCircleList*)list;
CircleListNode* ret = NULL;
if (slist != NULL)
{
ret = slist->slider;
}
return ret;
}
CircleListNode* CircleList_Next(CircleList* list)
{
TCircleList*slist = (TCircleList*)list;
CircleListNode* ret = NULL;
if (slist != NULL)
{
ret = slist->slider; //获取当前位置
slist->slider=ret->next; //游标下移
}
return ret;
}
//测试:
//约瑟夫问题求解
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#include"CircleList.h"
typedef struct value
{
CircleListNode circlenode;
int v;
}value;
int main()
{
int i = 0;
CircleList* list = CircleList_Create();
value v1, v2, v3, v4, v5, v6, v7, v8;
v1.v = 1; v2.v = 2; v3.v = 3; v4.v = 4;
v5.v = 5; v6.v = 6; v7.v = 7; v8.v = 8;
CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));
CircleList_Insert(list, (CircleListNode*)&v2, CircleList_Length(list));
CircleList_Insert(list, (CircleListNode*)&v3, CircleList_Length(list));
CircleList_Insert(list, (CircleListNode*)&v4, CircleList_Length(list));
CircleList_Insert(list, (CircleListNode*)&v5, CircleList_Length(list));
CircleList_Insert(list, (CircleListNode*)&v6, CircleList_Length(list));
CircleList_Insert(list, (CircleListNode*)&v7, CircleList_Length(list));
CircleList_Insert(list, (CircleListNode*)&v8, CircleList_Length(list));
//遍历
for (i = 0; i < 2 * CircleList_Length(list); i++)
{
struct value *pv = (struct value *)CircleList_Get(list, i);
printf("%d\n",pv->v);
}
printf("\n");
//游标重置
CircleList_Reset(list);
while (CircleList_Length(list)>0)
{
struct value *pv = NULL;
for (int j = 0; j < 2; j++)
{
CircleList_Next(list);
}
pv=(struct value *)CircleList_Current(list);
printf("%d\n",pv->v);
CircleList_DeleteNode(list, (CircleListNode*)pv);
}
CircleList_Destroy(list);
system("pause");
return 0;
}
/
3.双向链表
//头文件
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#ifndef _MY_DLINKLIST_H_
#define _MY_DLINKLIST_H_
typedef void DLinkList;
//typedef void DLinkListNode;
typedef struct _tag_DLinkListNode
{
struct _tag_DLinkListNode* next;
struct _tag_DLinkListNode* pre;
}DLinkListNode;
//创建
DLinkList* DLinkList_Create();
//销毁
void DLinkList_Destroy(DLinkList* list);
//清空
void DLinkList_Clear(DLinkList* list);
//求长
int DLinkList_Length(DLinkList* list);
//插入node数据元素到pos位置
int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos);
//获取pos位置的数据元素
DLinkListNode* DLinkList_Get(DLinkList* list, int pos);
//删除pos位置的数据元素
DLinkListNode* DLinkList_Delete(DLinkList* list, int pos);
//直接删除链表中的某个数据元素
DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);
//重置链表中的第一个数据元素
DLinkListNode* DLinkList_Reset(DLinkList* list);
//获取当前游标指向的数据元素
DLinkListNode* DLinkList_Current(DLinkList* list);
//游标移动到下一个数据元素
DLinkListNode* DLinkList_Next(DLinkList* list);
//游标移动到上一个数据元素
DLinkListNode* DLinkList_Pre(DLinkList* list);
#endif
//函数实现
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#include"DLinkList.h"
/*结点(.h中已定义)
typedef struct _tag_DLinkListNode
{
struct _tag_DLinkListNode* next;
struct _tag_DLinkListNode* pre;
}DLinkListNode;
*/
typedef struct _tag_DLinkList
{
int length;
DLinkListNode header;
DLinkListNode *slider;
}TDLinkList;
//创建
DLinkList* DLinkList_Create()
{
TDLinkList *dlist = (TDLinkList *)malloc(sizeof(TDLinkList));
if (dlist!=NULL)
{
dlist->length = 0;
dlist->header.next = NULL;
dlist->header.pre = NULL;
dlist->slider = NULL;
}
return dlist;
}
//销毁
void DLinkList_Destroy(DLinkList* list)
{
if (list != NULL)
{
free(list);
list = NULL;
}
return ;
}
//清空
void DLinkList_Clear(DLinkList* list)
{
TDLinkList* dlist = NULL;
if (list == NULL)
{
return ;
}
dlist = (TDLinkList*)list; //可以写为:TDLinkList* dlist=(TDLinkList*)list;
dlist->length = 0;
dlist->header.next = NULL;
dlist->header.pre = NULL;
dlist->slider = NULL;
return ;
}
//求长
int DLinkList_Length(DLinkList* list)
{
TDLinkList* dlist = (TDLinkList*)list;
int ret=0;
if (dlist!=NULL)
{
ret = dlist->length;
}
return ret;
}
//插入node数据元素到pos位置
int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos)
{
int i = 0;
TDLinkList* dlist = (TDLinkList*)list;
//1.判断
if (list==NULL || node==NULL || pos<0)
{
return -1;
}
//2.构建辅助指针
DLinkListNode* current = (DLinkListNode*)dlist;
DLinkListNode* next = NULL;//增加一个辅助指针
for (i = 0; (i < pos) && (current->next != NULL); i++)
{
current = current->next;
}
next = current->next;
//3.插入元素
current->next = node;
node->next = next;异常??????
//插入第一个元素判断和异常处理
if (next!=NULL)
{
next->pre = node;
}
node->pre = current;
if (dlist->length == 0)
{
dlist->slider = node;//当插入第一个元素时处理游标
}
//若在0位置插入需要特殊处理
if (current==(DLinkListNode*) dlist)
{
node->pre = NULL;
}
dlist->length++;
return 0;
}
//获取pos位置的数据元素
DLinkListNode* DLinkList_Get(DLinkList* list, int pos)
{
TDLinkList* dlist = (TDLinkList*)list;
DLinkListNode* ret = NULL;
if ((list != NULL)&&(pos>=0)&&(pos<dlist->length))
{
DLinkListNode *current = (DLinkListNode *)dlist;
for (int i = 0; i < pos && (current->next != NULL); i++)
{
current = current->next;
}
ret = current->next;
}
return ret;
}
//删除pos位置的数据元素
DLinkListNode* DLinkList_Delete(DLinkList* list, int pos)
{
int i = 0;
TDLinkList* dlist = (TDLinkList*)list;
//1.判断
if (list == NULL || pos<0)
{
return NULL;
}
//2.构建辅助指针(3个)
DLinkListNode* current = (DLinkListNode*)dlist;
DLinkListNode* ret = NULL;
DLinkListNode* next = NULL;
for (i = 0; i < pos; i++)
{
current = current->next;
}
ret = current->next; //ret
next = ret->next; //next
//3.删除元素
//1
current->next = next;
//2 插入 第一个元素 被删除
if (next != NULL)
{
next->pre = current;
if (current == (DLinkListNode*)dlist)//第0位置特殊处理
{
next->pre = NULL;
}
}
if (dlist->slider == ret)
{
dlist->slider = next;
}
dlist->length--;
return ret;
}
//直接删除链表中的某个数据元素
DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node)
{
int i = 0;
TDLinkList* dlist = (TDLinkList*)list;
DLinkListNode* ret = NULL;
if (dlist != NULL)
{
DLinkListNode* current = (DLinkListNode*)dlist;
for (i = 0; i < dlist->length; i++)
{
if (current->next == node)
ret = current->next;
break;
}
current = current->next;
if (ret != NULL)
{
DLinkList_Delete(dlist,i);
}
}
return ret;
}
//重置链表中的第一个数据元素
DLinkListNode* DLinkList_Reset(DLinkList* list)
{
TDLinkList* dlist = (TDLinkList*)list;
DLinkListNode* ret = NULL;
if (dlist != NULL)
{
dlist->slider = dlist->header.next;
ret = dlist->slider;
}
return ret;
}
//获取当前游标指向的数据元素
DLinkListNode* DLinkList_Current(DLinkList* list)
{
TDLinkList* dlist = (TDLinkList*)list;
DLinkListNode* ret = NULL;
if (dlist != NULL)
{
ret = dlist->slider;
}
return ret;
}
//游标移动到下一个数据元素
DLinkListNode* DLinkList_Next(DLinkList* list)
{
TDLinkList* dlist = (TDLinkList*)list;
DLinkListNode* ret = NULL;
if ((dlist != NULL)&&(dlist->slider!=NULL))
{
ret = dlist->slider;
dlist->slider = ret->next;
}
return ret;
}
//游标移动到上一个数据元素
DLinkListNode* DLinkList_Pre(DLinkList* list)
{
TDLinkList* dlist = (TDLinkList*)list;
DLinkListNode* ret = NULL;
if ((dlist != NULL) && (dlist->slider != NULL))
{
ret = dlist->slider;
dlist->slider = ret->pre;
}
return ret;
}
//测试
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
#include"DLinkList.h"
typedef struct value
{
DLinkListNode dlinknode;
int v;
}value;
int main()
{
int i = 0;
struct value* pv = NULL;
DLinkList* list = DLinkList_Create();
value v1, v2, v3, v4;
v1.v = 1; v2.v = 2; v3.v = 3; v4.v = 4;
DLinkList_Insert(list, (DLinkListNode*)&v1, DLinkList_Length(list));
DLinkList_Insert(list, (DLinkListNode*)&v2, DLinkList_Length(list));
DLinkList_Insert(list, (DLinkListNode*)&v3, DLinkList_Length(list));
DLinkList_Insert(list, (DLinkListNode*)&v4, DLinkList_Length(list));
for (i = 0; i < DLinkList_Length(list); i++)
{
struct value *pv = (struct value *)DLinkList_Get(list, i);
printf("%d\n", pv->v);
}
printf("\n");
DLinkList_Delete(list,DLinkList_Length(list)-1);
DLinkList_Delete(list,0);
for (i = 0; i < DLinkList_Length(list); i++)
{
struct value *pv = (struct value *)DLinkList_Get(list, i);
printf("%d\n", pv->v);
}
printf("\n");
DLinkList_Reset(list);
DLinkList_Next(list);
pv =(struct value*) DLinkList_Current(list);
printf("%d\n", pv->v);
DLinkList_DeleteNode(list, (DLinkListNode*)pv);
pv = (struct value*) DLinkList_Current(list);
printf("%d\n", pv->v);
DLinkList_Pre(list);
pv = (struct value*) DLinkList_Current(list);
printf("%d\n", pv->v);
printf("%d\n",DLinkList_Length(list));
DLinkList_Destroy(list);
system("pause");
return 0;
}