链表 on ZRJ | 学习笔记

Linked List Cycle

Mon, 20 Oct 2014 16:24:57 +0800

所谓拳不离手曲不离口，算法和基础不能丢。

话说三藏师徒四人辞别女儿国，再上西行路，今天来到。。。啊呸，扯远了。。

今天来看这个，https://oj.leetcode.com/problems/linked-list-cycle/，题目是这么说的

Given a linked list, determine if it has a cycle in it.

Follow up: Can you solve it without using extra space?

这题原本是简单，他页面上提供了一个在线的编辑器，带语法高亮和自动补全，我三分钟直接在线写完，一次性提交就编译通过同时 Accepted，想想上次刷 OJ 还是很久之前了，如今依然没有手生，还是很开心的，土豪解法如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 #include <set>
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* curr = head;
        while (curr) {
            if (viewed.find(curr) != viewed.end()) {
                return true;
            }
            viewed.insert(curr);
            curr = curr->next;
        }
        return false;
    }
    std::set<ListNode*> viewed;
};

类和函数是他给好的，我们要做的就是在类里面填空而已。

可以看到，这个解法不论是在时间还是空间上，都是土豪，何止土豪，那是相当土豪。不过，实际项目中，其实这么写是可以的，稳定，不出错，可维护性高。

不过，原题里还有这么一句，Can you solve it without using extra space?，这个很明显就是见功夫的地方了，要抠时间和空间，时间上是没啥可压缩了，至少也要遍历一次，空间上嘛，他要求没有额外空间，怎么搞呢，想了想，想起来之前看书的时候看到这个题，当时说的是，用两个指针，一个每次走一步，一个每次走两步，如果这两个指针遇上了，那么就说明有环，具体写起来，可以这么写：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return false;
            }
            if (slow == fast) {
                return true;
            }
        }
    }
};

又是一次 Accepted，我都怀疑是不是用例太弱了。。

需要注意的是，如果把最后的两个 if 判断对调位置，变成这样

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (slow == fast) {
                return true;
            }
            if (fast == NULL && slow == NULL) {
                return false;
            }
        }
    }
};

那就会导致 WA，具体为什么可以想想，不难想出来。

不过，这个题目还有一个变式，要求找出环的入口节点，题目在这里，https://oj.leetcode.com/problems/linked-list-cycle-ii/，这个题的解法很是有技巧，分析思路可以看到这里，http://blog.reetsee.com/archives/187

我们设链表的无环的部分长度为L1，即有L1个节点，注意，这个L1是包括环的入口节点的。然后让环的长度是L2，这个L2也是包括环的入口节点。这个时候，p1和p2的交点如图所示，交点距离环的入口节点为a（从入口节点沿着行走方向走到交点），即在环的入口节点后面的第a个节点，就是交点，我用红色标记出a。

然后我们来考察一下L1，L2，a，以及n（n是走过的步数，不是走过的节点数，p1一步一个节点，p2一步两个节点）的关系。

忘记说一点了，我们可以明确的是，p1在进入环后，走了不到一圈就在交点处和p2重合，為什麼肯定没有走完一圈？因为p1在进入环的时候，p2和p1之间的距离（沿着行走方向）至多为 L2-1，不可能超过L2-1，因为环的大小也才只有L2 。p2追赶p1，最多只需要走L2-1步，因为每走一步，p1和p2的相对距离减小1，那么p1最多只走了L2-1步，就是最多只经过了L2-1个节点，不可能走完一圈。

现在可以列公式了：

L1+a=n #1 //n是p1走过的节点数 L1+k*L2+a=2*n #2 //2*n这个是p2走过的节点数，其中的k表示p2可能在环里面走了k圈，k>=1 由#2式减去#1式，有：

k*L2 = n #3 同时由#1和#3得到：

L1+a = k*L2 #4 接着由#4就得到了如下式：

L1 = k*L2 – a = (k-1)*L2 + (L-a) 得到这条式子就拨得云开见月明啊有木有，因为(L-a)表示的是交点与环入口的距离（从交点沿着行走方向到环入口），然后(k-1)是>=0的，因为p2在环中至少绕了一圈，这样我们就发现：L1的长度 = 环长度的整数倍 + 交点与环入口的距离

也就是说，p1再走L1步就可以达到环的入口。问题是L1不是已知的，没关系，在表头设置一个p3指针，p3每步前进一个节点。让p1和p3同时走，每次走1步，等p3和p1重合了，就是到了环口的位置了。Problem solved~

很自然的，写出下面的代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head), *p1(head);
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return NULL;
            }
            if (slow == fast) {
                while (1) {
                    slow = slow->next;
                    p1 = p1->next;
                    if (p1 == slow) {
                        return p1;
                    }
                }
            }
        }
    }
};

但是这样是 WA 的，OJ 很仁慈的把错误说出来了

Input: {1,2}, tail connects to node index 0 Output: tail connects to node index 1 Expected: tail connects to node index 0

也就是说，考虑这种情况：整个链表只有两个节点，并且这两个节点构成一个环，那么上述代码就出错了，打个补丁：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head), *p1(head);
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return NULL;
            }
            if (slow == fast) {
                if (slow == head) {
                    return head;
                }
                while (1) {
                    slow = slow->next;
                    p1 = p1->next;
                    if (p1 == slow) {
                        return p1;
                    }
                }
            }
        }
    }
};

得以 Accepted，而其实，上述的代码，是可以进一步改的，注意到我们外面的那个循环，为了保守起见，是等慢指针遍历到尾，才退出的，其实根本没必要，只要快指针遇到 NULL 了，就可以撤了，如下

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head);
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) {
                ListNode *p(head);
                while (p != slow) {
                    slow = slow->next;
                    p = p->next;
                }
                return p;
            }
        }
        return NULL;
    }
};

-——————————-

2014-11-21 09:43:45 update

另外的一个思路是，每次前进一个节点，就把这个节点的 next 指针指向 head，这样，如果发现在某个节点被处理之前，就已经指向 head，那么就可以知道有环了，而且这个方法还可以天然的找出环的入口，不需要额外空间，缺点是破坏链表，一次处理之后，链表就被破坏的面目全非了。

这个思路尚未经过实际代码验证。

历史评论

wanax (2015-01-20 14:38:47):

真有闲情逸致….

二级指针删除单向链表

Mon, 04 Feb 2013 23:22:29 +0800

今晚在这里看到一篇文章，http://coolshell.cn/articles/8990.html，原文给的是代码片段，本着动手实践的原则，另外顺便复习一下链表，写了下代码

#include <stdio.h>
#include <stdlib.h>

typedef struct _node {
	int n;
	struct _node *next;
} node;

typedef int (* remove_fn)(node const *n);

node *create_link();
void destory_link(node *head);
void print_link(node *head);
int should_remove(node const *n);
node *remove_if(node *head, remove_fn should_remove);
void remove_if2(node **head, remove_fn should_remove);

int main() {
	node *head = create_link();
	print_link(head);
	//head = remove_if(head, should_remove);
	remove_if2(&head, should_remove);
	print_link(head);
	destory_link(head);
	return 0;
}

node *create_link() {
	node *head = malloc(sizeof(node));
	if (head == NULL) {
		printf("malloc head failed\n");
		return NULL;
	}
	head->n = 0;
	head->next = NULL;

	node *pre = head;
	for (int i=1; i<10; i++) {
		node *cur = malloc(sizeof(node));
		if (cur == NULL) {
			printf("malloc node %d failed\n", i);
			return NULL;
		}
		pre->next = cur;
		cur->n = i;
		cur->next = NULL;
		pre = cur;
	}

	return head;
}

void destory_link(node *head) {
	node *cur = head;
	while (cur) {
		node *next = cur->next;
		free(cur);
		cur = next;
	}
}

void print_link(node *head) {
	node *cur = head;
	while (cur) {
		printf("%d\t", cur->n);
		cur = cur->next;
	}
	printf("\n");
}

int should_remove(node const *n) {
	if (n == NULL) {
		return 0;
	}
	return (n->n)%2 == 0;
}

node *remove_if(node *head, remove_fn should_remove) {
	for (node *pre = NULL, *cur = head; cur;) {
		node * const next = cur->next;
		if (should_remove(cur)) {
			if (pre) {
				pre->next= next;
			} else {
				head = next;
			}
			free(cur);
		} else {
			pre = cur;
		}
		cur = next;
	}
	return head;
}

void remove_if2(node **head, remove_fn should_remove) {
	for (node **cur = head; *cur;) {
		node *entry = *cur;
		if (should_remove(entry)) {
			*cur = entry->next;
			free(entry);
		} else {
			cur = &(entry->next);
		}
	}
}

编译运行一下

zrj@zrj-desktop:~/c$ gcc -g -std=gnu99 link.c && ./a.out
0    1    2    3    4    5    6    7    8    9
1    3    5    7    9

其实道理不复杂，自己多读两遍代码就懂了，不得不承认这种写法确实很巧妙，而且就可读性来说，其实也没有下降多少

链表的反转

Sat, 08 Sep 2012 12:19:13 +0800

今天上午自己写了一个链表的反转

#include <stdio.h>
#include <stdlib.h>

typedef struct _node
{
	int n;
	_node *next;
} node;

int create_link(node **phead)
{
	int x = 0;
	printf("input nums, press Ctrl+Z(win) or Ctrl+D(linux) to endn");
	if (scanf("%d", &x) <= 0)
	{
		return 0;
	}
	*phead = (node *)malloc(sizeof(node));
	if ( ! *phead)
	{
		return 1;
	}
	(*phead)->n = x;
	(*phead)->next = NULL;
	node *now = *phead;
	while (scanf("%d", &x) == 1)
	{
		node *new_node = (node *)malloc(sizeof(node));
		if ( ! new_node)
		{
			// TO-DO: free memory
			return 1;
		}
		new_node->n = x;
		new_node->next = NULL;
		now->next = new_node;
		now = new_node;
	}
	return 0;
}

void print_link(node *head)
{
	node *now = head;
	while (now)
	{
		printf("%d", now->n);
		if (now->next)
		{
			printf(" -> ");
		}
		now = now->next;
	}
	printf("n");
}

void delete_link(node **head)
{
	node *now = *head;
	while (now)
	{
		node *tmp = now->next;
		free(now);
		now = tmp;
	}
	*head = NULL;
}

void reverse_link(node **phead)
{
	node *pre = *phead;
	node *curr = pre->next;
	if ( ! curr)
	{
		// 只有一个节点
		return;
	}
	node *next = curr->next;
	pre->next = NULL;
	while (1)
	{
		curr->next = pre;
		if (next)
		{
			pre = curr;
			curr = next;
			next = next->next;
		}
		else
		{
			break;
		}
	}
	*phead = curr;
}

int main()
{
	node *head = NULL;
	create_link(&head);
	print_link(head);
	reverse_link(&head);
	print_link(head);
	delete_link(&head);
	return 0;
}

输入输出

input nums, press Ctrl+Z(win) or Ctrl+D(linux) to end
3 1 2 4 0
^Z
3 -> 1 -> 2 -> 4 -> 0
0 -> 4 -> 2 -> 1 -> 3

==================================================

2012-09-08 12:39:03 update 参考这里 http://blog.csdn.net/rerli/article/details/19038，反转函数有更简单的写法

void reverse_link(node **phead)
{
	node *pre = NULL;
	node *curr = *phead;
	node *next = NULL;
	while (curr)
	{
		next = curr->next;
		curr->next = pre;
		pre = curr;
		curr = next;
	}
	*phead = pre;
}

================================================

参考这里，http://blog.csdn.net/rerli/article/details/19039，写了链表的插入排序

void insert_sort(node **phead)
{
	node *head = *phead;
	// 把 head 的下一节点保存起来
	node *first = head->next;
	// 断开 head，使其成为初始的有序链表
	head->next = NULL;
	while (first)
	{
		node *p, *q, *t;
		// 找到插入点
		for (t=first, q=head; q && q->n < t->n; p=q, q=q->next);
		// 把 first 节点从无序链表中断开
		first = first->next;

		if (q == head)
		{
			// 插入在头结点之前
			head = t;
		}
		else
		{
			// p 是 q 的前驱
			p->next = t;
		}
		t->next = q;
	}
	*phead = head;
}

======================================================

2012-09-08 15:02:07 update 相比于传二维指针，可以使用 c++ 的写法，传引用，这样可读性会高很多

int create_link(node *&head)
{
	int x = 0;
	printf("input nums, press Ctrl+Z(win) or Ctrl+D(linux) to endn");
	if (scanf("%d", &x) <= 0)
	{
		return 0;
	}
	head = (node *)malloc(sizeof(node));
	if ( ! head)
	{
		return 1;
	}
	head->n = x;
	head->next = NULL;
	node *now = head;
	while (scanf("%d", &x) == 1)
	{
		node *new_node = (node *)malloc(sizeof(node));
		if ( ! new_node)
		{
			// TO-DO: free memory
			return 1;
		}
		new_node->n = x;
		new_node->next = NULL;
		now->next = new_node;
		now = new_node;
	}
	return 0;
}

调用的时候改成

int main()
{
	node *head = NULL;
	create_link(head);
	print_link(head);
	reverse_link(&head);
	print_link(head);
	insert_sort(&head);
	print_link(head);
	delete_link(&head);
	return 0;
}