线性表的链式存储

ukston_C

于 2018-06-30 09:05:25 发布

阅读量337

点赞数 1

分类专栏：数据结构文章标签：线性表的链式存储

本文链接：https://blog.csdn.net/ukston_C/article/details/80863849

版权

数据结构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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;
}

ukston_C

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
线性表的链式存储

//头文件#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{ s...
复制链接

扫一扫