数据结构与算法_链表

链表基本操作函数

VS的打开方式为管理员方式运行，这样能避免很多问题。

**链表框架**

typedef struct LNode//结构体声明不能为匿名
{
	int num;           //数据
	struct LNode* next;//地址  
}LNode,*LinkList;

链表的基本结构，num中存放该结点的数据，next存放下个结点地址的指针。

**链表初始化**

/*初始化*/
LinkList CreatLinkList(int *data,int len)
{
	LinkList head,pre;//head为头结点，pre是保存当前结点的前驱
	LinkList node;//node为新开辟的结点
	node=(LinkList)malloc(sizeof(LinkList));
	head = node;
	head->next = NULL;//头结点不存值，只存地址
	pre = head;
	for (int i = 0; i < len; i++)
	{
		node = (LinkList)malloc(sizeof(LinkList));
		node->num = data[i];
		node->next = NULL;
		pre->next = node;//第一次循环时将结点地址存入头结点的next中
		pre = node;//这两句将当前结点的地址存入上个地址的next中
	}
	return head;
}

定义的函数为LinkList类型，用于返回同样类型的头结点指针，链表通过头结点来调用。
链表的生成过程为用malloc函数开辟地址，开辟新的结点node，给结点node中的num赋值，并且用pre指针存放上个结点node，然后将它的next指向当前结点node，从而实现next中地址的依次存储以及num的赋值。此过程结束后，链表生成，返回头结点用来调用。

**结点的定义方法**

	Linklist p;
	p = (LinkList)malloc(sizeof(LinkList));
	//分配内存（结点先定义再分配内存）
	//单纯的指针如头结点是不用分配数值的，
	//故不用malloc函数分配内存

**插入函数LinkListInsert(LinkList L,int i,LinkList L1);**

void LinkListInsert(LinkList L, int i, LinkList L1)
{
	int k=0;
	while (k < i-1)//循环结束条件：k=i-1时循环结束，指针L
	{			   //指向第i-1个结点
		L = L->next;//链表指针向后遍历
		k++;
	}
	L1->next = L->next;//结点L1指向第i个结点
	L->next = L1;//第i-1个结点指向结点L1
}

在原链表第i个位置插入新结点L1，需要将第i-1个结点找出来，将它的next赋给L1的next，再将它的next指向L1即可，如图：

L1插入前

L1插入后

**删除函数LinkListDelete(LinkList L,int i);**

void LinkListDelete(LinkList L,int i)
{
	int k = 0;		//将第i-1个结点指向第i+1个结点，然后释放掉第i个结点
	while (k < i-1)//循环结束条件：k=i-1时循环结束
	{
		L = L->next;
		k++;
	}
	L->next = L->next->next;
}

删除前
删除后

**链表搜索位置LinkListSearch(LinkList L,int i);**

int LinkListSearch(LinkList L,int i)//返回第i个结点所存数值
{
	int k = 0;
	while (k < i)//循环结束条件：k=i时循环结束
	{
		L = L->next;
		k++;
	}
	return L->num;
}

**链表某个值的删除LinkListDeleteNum(LinkList L,int num);**

void LinkListDeleteNum(LinkList L,int num)
{
	LinkList pre;//定义指针前驱，指向上一个结点
	pre = L;//pre初始指向头结点
	while (L != NULL)
	{
		if (L->num == num)
		{
			pre->next = L->next;
			break;
		}
		pre = L;
		L = L->next;
	}
}

**搜索值并返回位置LinkListSearchNum(LinkList L,int num);**

int LinkListSearchNum(LinkList L,int num)
{
	int k = 0;
	while(L!=NULL)
	{
		if (L->num == num)//判断
			return k;
		L = L->next;//遍历
		k++;
	}
	return NULL;//若链表内查不到值，则返回NULL
}

**链表合并LinkListMerge(LinkList L,LinkList L1);**

void LinkListMerge(LinkList L,LinkList L1)
{
	while (L->next!= NULL)//遍历L，使指针指向链表的最后一个结点
	{
		L = L->next;
	}
	while (L1 != NULL)//遍历L1，使指针指向链表的最后一个结点
	{
		L1 = L1->next;
		L->next = L1;
		L = L->next;
	}
}

**链表反转LinkListReverse(LinkList L);**

LinkList LinkListReverse(LinkList L)
{
	int i=0;
	LinkList head,pre,Lr,L1;//Lr为新链表的单元
	Lr = (LinkList)malloc(sizeof(LinkList));
	head = Lr;//head为新链表的头指针
	L1 = L;//L1为原链表的头指针
	while (L->next != NULL)
	{
		L = L->next;
		i++;
	}
	Lr->next = L;//存入原链表最后一个节点作为起始节点
	Lr = Lr->next;
	pre = L;
	i--;
	while (i)//依次找到剩余的i-1个节点
	{
		L = L1;
		while (L->next != pre)//找到上一个节点
			L = L->next;
		pre = L;
		Lr->next = pre;
		Lr = Lr->next;
		i--;
	}
	Lr->next = NULL;
	return head;
}

**约瑟夫环问题LinkListJoseph(LinkList L,int k);**

LinkList LinkListJoseph(LinkList L,int k)
{
	int i;
	LinkList head;
	head = L->next;
	while (L->next != NULL)//遍历到最后一个节点
		L = L->next;
	L->next = head;//最后一个节点存入第一个节点的地址，成环
	L = head;//指针L指向第一个节点
	while(L->next!=L)//依次删除，剩最后一个节点时结束
	{
		i = k;
		while (i-2>0)//找到第i-1个节点，并删除最后一个
		{
			L = L->next;
			i--;
		}
		L->next = L->next->next;
		L = L->next;
	}
	return L;
}