有环链表及其延伸的问题:
(1)判断是否有环。采用快慢指针的思路,一个指针一次移动一个结点,另一个指针移动两个结点。
如果有环,则进入环后,快指针肯定可以追赶上慢指针,这样就会出现两者相等的情况,从而得出有环,但有一个前提,这个单链表必须有一个以上的结点在环之外才能 判断出入口地址。
(2)怎么来找环的入口问题。
假定环外的长度为 l,相遇时环入口距离相遇处距离为 a,整个环为 x,则有下面的公式。
l + a = (l + a + nx )/2 即 l = nx – a。
这样,让快指针从这个位置开始继续移动,但步进为 1,慢指针从链表头开始移动,下次相遇的位置就是环的入口地址。
(3)找环的长度。
现在已经知道环的入口位置,这样的话,采用快慢指针,再次相遇时快指针多移动的距离就是环的长度。
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
struct node *next;
int data;
}Node;
/*
use insert before to get a link
then modify the tail->next value to local of the circle.
*/
Node *get_circle_link(int length, int local)
{
Node *temp = NULL;
Node *phead = NULL;
Node *tail = NULL;
int i=0;
// 建立一个长度为length的链表,链表的
for(i=0; i<length; i++)
{
/* 建立节点 */
temp = (Node *) malloc( sizeof (Node) );
if(NULL == temp)
{
printf("malloc error");
return NULL;
}
temp->next = NULL;
temp->data = length-i;
/* 采用头插入的方式建立链表 */
// 头节点的建立
if(NULL == phead)
tail = temp;
// 头插入
temp->next = phead;
phead = temp;
}
/* 建立链表中的环 */
// 遍历节点,找到环的起点位置
for(temp = phead,i=1;i< local; i++)
{
temp = temp->next;
}
// 已经建立的链表的尾节点指向环节点的首节点
tail->next = temp;
return phead;
}
/* 链表的打印 */
void link_print(Node* temp)
{
while(temp!=NULL)
{
printf("%p:%d\t",temp,temp->data);
temp=temp->next;
getchar();
}
printf("\n");
}
/* 判断有环链表 */
// 如何判断是否有环?
// 通过建立快慢指针,快指针的速度是慢指针的两倍
// 快慢指针可以相遇时,即为有环;
// 如何得到链表的环节点的首节点数据?
// l:直链长;a:环中相遇的位置;x:环的长度
// 公式 l+a = (l+a+nx)/2 --> l+a = nx
// n=1;l=x-a;
// 相遇后,快慢指针的步长均为1,慢指针回到头开始,快指针继续走;
int get_circle_local(Node *phead)
{
Node *fast = phead;
Node *slow = phead;
while(fast != NULL && fast->next != NULL)
{
fast = fast->next->next;
slow = slow->next;
if(fast == slow)
{
for(slow = phead;slow!=fast;)
{
slow = slow->next;
fast = fast->next;
}
return slow->data;
/* 求出环的大小
fast = fast->next->next;
while(slow!=fast)
{
slow = slow->next;
fast = fast->next->next;
count++;
}
count++;
return count;
*/
}
}
return 0;
}
int main(int argc,char *argv[])
{
Node *phead = NULL;
int local=4;
int number=10;
phead=get_circle_link(number,local);
//link_print(phead);
int ret = 0;
if( (ret = get_circle_local(phead)) >0)
printf("has circle,local is %d\n",local);
else
printf("no circle\n");
//printf("local=%d, ret=%d\n",local,ret);
return 0;
}
问题的延伸:
1. 找出单链表的倒数第 4 个元素。找出单链表的中间元素。建立快慢指针,快指针步长为4,慢指针的步长为1;其实就是判断指向当前节点的顺数第四节点为NULL时,表明当前节点为目标节点;
2. 判断两个单链表是否相交,若两个单链表相交,计算相交点。
遍历其中的一个链表,将此链表的终节点指向当前链表的头节点,即将此链表构成了环,接下来判断另外一个链表是否有环,有环即两个单链表相交。
删除指定的节点
(1)对于非最后一个结点,将要删除结点的下一个结点数据拷贝到要删除结点,删除下一个结点空间
(2)因为最后一个结点没有办法通过上述方法解决,因此只能遍历。找到前向指针再删除
时间复杂度:n-1 : O(1)
1 :O(n)
因 此,总的时间复杂度仍然为 O(1)。
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
struct node *next;
int data;
}Node;
Node *get_link(int length,int local,Node** plocal)
{
Node *temp = NULL;
Node *phead = NULL;
Node *tail = NULL;
int i=0;
for(i=0; i<length; i++)
{
temp = (Node *) malloc( sizeof (Node) );
temp->next = NULL;
temp->data = length-i;
if( phead == NULL) //use insert before
tail = temp;
if(local == length - i) //the del local address
*plocal = temp;
temp->next = phead;
phead = temp;
}
return phead;
}
void link_print(Node* temp)
{
while(temp!=NULL)
{
printf("%d\t",temp->data);
temp=temp->next;
}
printf("\n");
}
Node* del_node(Node* phead, Node* local)
{
if(phead == NULL || local == NULL)
{
printf("arg error\n");return NULL;
}
//(1) last node
if(local->next == NULL)
{
if(phead == local) //only one node
{
free(local);
return NULL;
}
Node *prev = phead;
while(prev != NULL && prev->next != NULL)
{
if(prev->next == local)
{
prev->next = prev->next->next;
free(local);
return phead;
}
prev = prev->next;
}
}
else
{
Node *temp = local->next;
local->data = local->next->data;
local->next = local->next->next;
free(temp);
return phead;
}
}
如何实现单链表的反序输出?
1.将原链表进行反序,再进行遍历输出;需要考虑时间复杂度的问题,翻转一次时间复杂度为O(n),空间复杂度为O(1);
缺点:需要修改原链表的属性,需要考虑并发的问题
2.使用栈的方式,栈的特点是先入后出;
链栈记录每个节点的地址 时间复杂度O(n)
将逐个弹出,输出相应的数据 空间复杂度O(n)
缺点:空间复杂度相对来说较大
3. 使用递归函数模拟栈的使用;
优点:代码简洁
缺点:递归函数的应用容易造成栈内存溢出的危险,效率并不高。
# include <stdio.h>
# include <malloc.h>
# define SIZE 5 //初始定义链表的长度
//定义节点
typedef struct Node
{
int data;
struct Node * pNext;
}NODE, * PNODE;
//定义栈
typedef struct Stack
{
int * base; //栈空间基址
int * top; //指向栈顶有效元素的下一个位置
}Stack;
void traverse(PNODE pHead)
{
printf("遍历链表:");
PNODE p = pHead->pNext;
while(p != NULL)
{
printf("%d ", p->data);
p = p->pNext;
}
printf("\n");
}
/* 反转链表,并遍历 */
// 链表逆序方法二
void reverseTrans_reverse(PNODE pHead)
{
//反向链表的头结点
PNODE pRever = (PNODE)malloc(sizeof(NODE));
pRever->pNext = NULL;
PNODE p = pHead->pNext;
PNODE mid = NULL; //两个临时变量
PNODE pTail;
while(p != NULL)
{
pTail = mid;
mid = p;
p = p->pNext;
mid->pNext = pTail;
}
pRever->pNext = mid;
traverse(pRever);
}
// 链表逆序方法二
void reverseTrans_reverse2(PNODE pHead)
{
PNODE prev = NULL;
PNODE temp = pHead->pNext;
PNODE next = NULL;
while(temp!=NULL)
{
next = temp->pNext;
temp->pNext = prev;
prev = temp;
temp = next;
}
// 遍历节点
while(prev != NULL)
{
printf("%2d",prev->data);
prev = prev->pNext;
}
printf("\n");
}
//根据栈,反向输出链表
void reverseTrans_stack(PNODE pHead)
{
int val;
Stack s = creat_stack(); //创建栈
PNODE p = pHead->pNext;
while(p != NULL)
{
push(s, p->data); //节点从头到尾如入栈
s.top++;
p = p->pNext;
}
while(s.top != s.base) //元素再出栈
{
s.top--;
val = *(s.top);
printf("%d ", val);
}
printf("\n");
}
//创建栈
Stack creat_stack()
{
Stack s;
s.base = (int *)malloc(sizeof(int) * SIZE); //分配栈空间
s.top = s.base;
return s;
}
//元素入栈
void push(Stack s, int val)
{
if((s.top - s.base) > SIZE)
{
printf("栈满!\n");
return;
}
else
{
*(s.top) = val;
//s.top++;
}
}
/* 递归函数实现链表的逆序输出 */
void reverseTrans_Recursion(PNODE pHead)
{
PNODE temp = pHead;
if(NULL != temp->pNext)
{
reverseTrans_Recursion(temp->pNext);
printf("%2d",temp->pNext->data);
}
}
int main(void)
{
int i, len, val=0;
//创建链表
PNODE pHead = (PNODE)malloc(sizeof(NODE)); //头结点
PNODE pTail = pHead; //尾节点
PNODE pNew; //新节点
printf("创建链表的长度为:len = %d\n", SIZE);
len = SIZE;
for(i = 0; i < len; i++)
{
val++;
//创建新节点
pNew = (PNODE)malloc(sizeof(NODE));
pNew->data = val;
pNew->pNext = NULL;
//新节点添加在尾节点后面
pTail->pNext = pNew;
pTail = pNew;
}
//遍历链表
traverse(pHead);
//反向遍历链表, 从头到尾节点入栈,然后再出栈
printf("用栈,反向输出链表:");
reverseTrans_stack(pHead);
//反向遍历链表,反转链表
printf("反转链表:");
reverseTrans_reverse2(pHead);
// 递归,反向输出链表
printf("递归,反向输出链表:");
reverseTrans_Recursion(pHead);
return 0;
}
求出倒数第K个节点的数据
建立两个指针,一个指针先走K-1步,另一指针不动。接下来两个指针的步长均为1,那么当快的那个指针的下一个指针为NULL时,慢指针就是目标的节点。需要考虑的问题包括如下:
1. 传进来的链表的头节点是否有效;
2. K是否有效,K为无符号整型数;
3. 链表的长度是否比K要长,容易造成段错误;
PNODE findKthList(PNODE pHead, unsigned int k) { PNODE fast = pHead; PNODE slow = pHead; if(NULL == pHead || 0 == k) { return NULL; } for(unsigned int i=0; i<k-1; i++) { fast = fast->pNext; if(NULL == fast) { return NULL; } } while(NULL != fast) { fast = fast->pNext; slow = slow->pNext; } return slow; }