数据结构与算法——链表（1）

最近一直在看《剑指Offer》这本书，现在总结一下对于链表方面的一点认识。

链表的结构很简单，它由指针把若干个结点连成链状结构。链表的基本操作包括：创建、插入结点、删除结点等。链表是一种动态存储结构，在创建链表的时候无需知道链表的长度，当插入一个结点时，我们只需要为新插入的节点分配内存，然后调整指针的指向来确保新插入的结点被链接到链表当中。内存分配不是在创建链表时一次完成的，而是每添加一个结点分配一此内存，由于没有闲置的内存，链表的效率比数组高。单向链表的结构可以如下表示：

struct ListNode
{
	int value;
	ListNode*next;
};

那么往链表的末尾添加一个结点的代码为：

void AddToTail(ListNode** head,int value)
{
	ListNode*pNew=new ListNode();
	pNew->value=value;
	pNew->next=NULL;
	if(*head==NULL)
	{
		*head=pNew;
	}
	else
	{
		ListNode*Node=*head;
		while(Node->next!=NULL)
		{
			Node=Node->next;
		}
		Node->next=pNew;
	}
}

其中其中特别要注意的是函数的第一个参数传入的是指针的指针。这是因为我们在函数中有可能要改变头结点的指向，当我们往一个空链表中插入结点时，新插入的结点就是链表的头指针。此时，会改变头指针的指向，因此必须把头指针pHead参数设为指向指针的指针。补充：编译器会为函数的参数制作一个临时的副本，当指针Phead作为函数参数时，编译器会自动为该指针创建一个副本PHead_,使Phead和Phead_指向同一个数据，在函数中，假若这是一个空的链表，当插入第一个结点时，会在函数的内部为PHead_分配一块内存，但是Phead没有任何改变，任然是一个空指针。

链表侧查找与删除：

void RemoveNode(ListNode** head,int value)
{
	if(head==NULL||*head==NULL)
		return;
	ListNode *ToBeDeleteNode=NULL;//新建节点的时候必须初始化为NULL；
	if((*head)->value==value)
		ToBeDeleteNode=*head;
	else
	{
		ListNode *pNode=*head;//当前检测的节点
		ListNode *pNode_pre=pNode;//当前已经检测过的节点
		while(pNode->value!=value&&pNode->next!=NULL)
		{       pNode_pre=pNode;
				pNode=pNode->next;
		}
		if(pNode->value==value)
		{
			ToBeDeleteNode=pNode;
			pNode_pre->next=pNode->next;//一定要注意这个地方
		}
		else
		{
			cout<<"cannot  find"<<endl;
		}
	}
	if(ToBeDeleteNode!=NULL)
	{
		delete ToBeDeleteNode;
		ToBeDeleteNode=NULL;//删除结点之后，要将指针设为空
	}
}

在涉及链表的删除问题时，一定要注意以下几点：

一、所要删除的结点是不是空的

二、所要删除的结点是不是头结点。

问题一：

求链表中倒数第K个结点。

第一种思路，从头开始遍历整个链表，求取链表的长度n，倒数第K个结点就是从头开始第n-k+1个结点。但是这种方法，需要两次遍历链表，效率不高。

第二种思路，我们可以定义两个指针p_fist和p_second，都指向表头，p_first先走k-1步，然后，p_second从头开始走，当p_fisrst走到末尾的时候，p_second就是倒数第K个结点，这种方法只遍历一次链表，效率高。

//求解链表中倒数K个结点
ListNode* FindKthNode(ListNode*head,int k)
{
	if(head==NULL||k==0)
		return NULL;//检查是否为空链表
	ListNode *pHead=head;
	ListNode *BehindHead=head;
	for(int i=0;i<k-1;i++)
	{
		if(pHead->next!=NULL)//检查K是否大于链表的长度
			pHead=pHead->next;
		else
			return NULL;
	}
	while(pHead->next!=NULL)
	{
		pHead=pHead->next;
		BehindHead=BehindHead->next;//
	}
	return BehindHead;

这里需要注意几个问题，来保证程序的鲁棒性。在函数的入口处添加代码以验证用户的输入是否合法。

一、输入的头指针为空

二、输入的k大于结点总数

三、输入的参数K等于0或小于0，

for(int i=0;i<k-1;i++)

上述循环就会崩溃。

相似的题目：求链表的中间结点，如果链表中结点总数为奇数，返回中间结点；如果链表中结点总数为偶数，返回中间两个结点中的任意一个结点。为了解决这个问题，我们也可以定义两个指针，同时从链表的头结点出发,一个每次走一步，另一个每次走两步，当走的快的指针走到链表的末尾时，走的慢的指针正好在链表的中间。

ListNode* FindMiddle(ListNode*head)
{
	if(head==NULL)
		return NULL;
	if(head->next==NULL)
		return head;
	ListNode *p_first=head;
	ListNode *p_second=head;
	while(p_first->next!=NULL)
	{

		   p_first=p_first->next;
		if(p_first->next!=NULL)
			p_first=p_first->next;
		else
			break;
		p_second=p_second->next;

	}
	return p_second;
}

反转链表：

ListNode* ReverseList(ListNode* head)
{
	if(head==NULL)
		return NULL;
	if(head->next==NULL)
		return head;
	ListNode *pReversedHead=NULL;
	ListNode *pNode=head;
	ListNode *pPrev=NULL;
	while(pNode!=NULL)
	{
		ListNode *next=pNode->next;
		if(next==NULL)//到了最后一个结点，反转之后的头结点
			pReversedHead=pNode;
		pNode->next=pPrev;//当前结点指向前一个结点
		pPrev=pNode;
		pNode=next;
		 
	}
	return pReversedHead;
}

总结了一下要点：

1、三个指针，当前结点的指针、当前结点的前一个结点，当前结点的下一个结点

2、记录当前结点的下一个结点