面试算法之链表操作集锦

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/anonymalias/article/details/11020477

链表操作在面试过程中也是很重要的一部分,因为它和二叉树一样都涉及到大量指针的操作,而且链表本身很灵活,很考查编程功底,所以是很值得考的地方。下面是本文所要用到链表节点的定义:

template <typename Type>
struct ListNode{
    Type data;
    ListNode *next;
};
链表的创建可以采用下面的代码,采用尾插法进行链表的创建,返回的链表没有头节点:

/**
 * Create a list, without head node
 */
template <typename Type>
ListNode<Type> *CreatList(Type *data, int len)
{
	if(data == NULL || len <= 0)
		return NULL;

	ListNode<Type> *head, *last;

	head = new ListNode<Type>;
	last = head;

	for (int i = 0; i < len; ++i)
	{
		last->next = new ListNode<Type>;
		last->next->data = data[i];
		last = last->next;
	}

	last->next = NULL;

	last = head;
	head = head->next;

	delete last;

	return head;
}

1.单链表的逆序打印

单链表的逆序打印就是重表尾开始依次往前打印,直到表头截止,所以可以将链表逆置,然后顺序打印,但这是一种劳民伤财的做法,不仅容易出错,而且还破坏了链表的结构。这里可以采用额外的空间,来保存顺序遍历的节点,在遍历完后,就可以将该辅助空间的值逆序输出,下面是采用stack实现的代码:

/**
 * reversely print the list
 * method 1: use the stack
 */
template <typename Type>
void ReversePrintList_1(const ListNode<Type> *head)
{
	if(head == NULL)
		return;

	stack<Type> nodeStack;
	while (head)
	{
		nodeStack.push(head->data);
		head = head->next;
	}

	while(!nodeStack.empty())
	{
		cout<<nodeStack.top()<<" ";
		nodeStack.pop();
	}
	cout<<endl;
}
我们知道代码中,递归和栈很多时候可以相互转化,而且通过递归实现的代码会更加简洁。下面是通过递归的方式,来实现上面的功能,代码如下:

/**
 * reversely print the list
 * method 2: recursively
 */
template <typename Type>
void ReversePrintList_2(const ListNode<Type> *head)
{
	if(head == NULL)
		return;

	ReversePrintList_2(head->next);
	cout<<head->data<<" ";
}

2.单链表的逆置

在前面单链表的逆序打印中,有一种方法就是把单链表逆置后,再顺序打印。单链表的逆置最高效的方法,就是顺序扫描链表,然后依次逆置,代码如下:

/**
 * reverse the list
 * method 1:sequential scanning 
 */
template <typename Type>
ListNode<Type> * ReverseList_1(ListNode<Type> *head)
{
	if(head == NULL)
		return NULL;

	ListNode<Type> *pre = NULL;

	while (head)
	{
		ListNode<Type> *nextNode= head->next;
		head->next = pre;
		pre = head;
		head = nextNode;
	}

	return pre;
}
同样可以通过递归的方式来进行逆置,递归的思想就是:将已经逆置的链表的最后一个节点返回,并把当前节点添到该节点的后面,单面如下:

/**
 * reverse the list
 * method 2: recursion
 */
template <typename Type>
ListNode<Type> * ReverseList_2(ListNode<Type> *head)
{
	if(head == NULL)
		return NULL;

	ListNode<Type> *newHead;
	SubReverseList_2(head, newHead);

	return newHead;
}

template <typename Type>
ListNode<Type> * SubReverseList_2(ListNode<Type> *head, ListNode<Type> *&newHead)
{
	if (head->next == NULL)
	{
		newHead = head;
		return head;
	}

	ListNode<Type> *post = SubReverseList_2(head->next, newHead);
	post->next = head;
	head->next = NULL;

	return head;
}

3.在O(1)时间删除链表节点

题目是:在一个单链表中,通过节点的指针,在O(1)时间删除该节点。该题是一个投机取巧的方法,就是将要删除的节点用下一个节点覆盖,然后删除下一个节点就可以了。但如果该节点时尾节点,O(1)的时间是不成立的。代码如下:

/**
 * delete a node from list
 */
template <typename Type>
ListNode<Type> * DeleteNode(ListNode<Type> *head, ListNode<Type> *node)
{
	if(head == NULL || node == NULL)
		return head;

	//only have one node
	if (node == head && node->next == NULL)
	{
		delete head;
		return NULL;
	}

	//node counts > 1, and delete the tail node
	if (node->next == NULL)
	{
		ListNode<Type> *pre = head;

		while (pre->next != node)
			pre = pre->next;

		delete node;
		pre->next = NULL;

		return head;
	}

	//other node
	ListNode<Type> *delNode = node->next;
	node->data = delNode->data;
	node->next = delNode->next;

	delete delNode;

	return head;
}

4.链表中的倒数第k个节点

求单链表的倒数第k个节点,其实是一个很简单的问题,最容易想到的是下面三种方法:

  • 遍历一遍节点统计链表的长度,然后计算出倒数第k个节点在链表中顺序的位置。
  • 可以通过stack来保存链表顺序扫描的节点,然后弹出第k个节点。
  • 可以通过递归来实现。

但上面的方法都需要扫描链表超过一次或者是需要O(n)的辅助空间,如果要求只能扫描一遍链表,且是辅助空间为O(1),那么怎么解决呢。这里有一个很巧妙的方法:用两个指针p1,p2,初始都指向第一个节点,指针p1首先向后移动k-1个节点,然后两个指针一起向后移动,直到p1指向尾节点,那么p2所指向的就是倒数第k个节点,代码如下:

/**
 * return the last k node from list, 1 =< k <= list length
 */
template <typename Type>
const ListNode<Type> * LastKNode(const ListNode<Type> *head, int k)
{
	if(head == NULL || k < 1)
		return NULL;

	const ListNode<Type> *ahead, *after;
	after = ahead = head;

	for (int i = 0; i < k - 1; ++i)
	{
		//the list length less than k
		if(ahead->next == NULL)
			return NULL;

		ahead = ahead->next;
	}

	while (ahead->next != NULL)
	{
		ahead = ahead->next;
		after = after->next;
	}

	return after;
}

5.合并两个排序的链表

将两个排序的单链表合并成一个链表,方法很简单,这里首先创建一个头节点,将合并的链表链接在其后面,以简化代码。代码如下:

/**
 * merge two sorted list
 */
template <typename Type>
ListNode<Type> * MergeTwoSortedList(ListNode<Type> *H1, ListNode<Type> *H2)
{
    if (H1 == NULL)
        return H2;
    if (H2 == NULL)
        return H1;

    ListNode<Type> *head, *last;

    head = new ListNode<Type>;
    last = head;

    while (H1 != NULL && H2 != NULL)
    {
		if (H1->data <= H2->data)
		{
			last->next = H1;
			last = H1;
			H1 = H1->next;
		} 
		else
		{
			last->next = H2;
			last = H2;
			H2 = H2->next;
		}
    }

    if (H1 != NULL)
        last->next = H1;
    else if (H2 != NULL)
        last->next = H2;

    H1 = head->next;
    delete head;

    return H1;
}

6.求两个单链表的第一个公共结点

如果两个单链表有公共结点,那么它们组成的形状一定是“Y”形的。求它们的第一个公共结点,可以有几种解法。

  • 最暴力的解法就是从一个链表的开头,把每个结点依次与另一个链表的所有结点进行依次比较,直到找到第一个公共结点为止,这种解法那叫一个暴力,时间复杂度为O(n^2),面试官肯定会鄙视的。
  • 采用stack辅助空间,分别将两个链表的各个结点依次入两个栈中,然后从两个栈中弹出结点,直到结点的内容不同为止,上一个结点就是所求。这种做法需要O(n)的辅助空间,估计也不是面试官最想要的。
  • 采用对齐的方法。计算两个链表的长度l1,l2,分别用两个指针p1,p2指向两个链表的头,然后将较长链表的p1(假设为p1)向后移动l2 - l1个结点,然后再同时向后移动p1,p2,直到p1 = p2。这种方法才是面试官最想要的,具体代码实现如下:

/**
 * Find the first common node
 */
template <typename Type>
ListNode<Type> * Find1stCommonNode(ListNode<Type> *h1, ListNode<Type> *h2)
{
	if(h1 == NULL || h2 == NULL)
		return NULL;

	int len1, len2;

	len1 = GetListLength(h1);
	len2 = GetListLength(h2);

	if (len1 > len2)
	{
		for (int i = 0;i < len1 - len2; ++i)
			h1 = h1->next;
	}
	else
	{
		for (int i = 0;i < len2 - len1; ++i)
			h2 = h2->next;
	}

	while (h1 && h1 != h2)
	{
		h1 = h1->next;
		h2 = h2->next;
	}

	return h1;
}

template <typename Type>
int GetListLength(const ListNode<Type> *head)
{
	int num = 0;

	while (head)
	{
		++num;
		head = head->next;
	}

	return num;
}

7.判断两个单链表是否相交

由上面6可知,相交的单链表一定是“Y”形的,所以如果相交,那么最后的一个节点一定相同。所以很简单,代码如下:

/**
 * judge two list crossing or not
 */
template <typename Type>
bool IsCrossing(ListNode<Type> *h1, ListNode<Type> *h2)
{
	if(h1 == NULL || h2 == NULL)
		return false;

	while(h1->next != NULL)
		h1 = h1->next;
	while(h2->next != NULL)
		h2 = h2->next;

	if(h1 == h2)
		return true;
	return false;
}

8.判断单链表是否存在环

判断单链表是否存在环的思想就是判断遍历的结点是否已经遍历过。那么实现上最简单的就是通过辅助空间来保存已经遍历过的结点,在每遍历一个结点时判断该结点是否已经在空间中,如果在就说明有环,否则把该结点写入辅助空间,直到找到环或访问链表结束。可以通过hashmap来保存访问的结点,查找效率是O(1)。但是需要O(n)的辅助空间。面试官想要的方法是:通过两个指针,分别从链表的头结点出发,一个每次向后移动1步,另一个移动两步,两个指针移动速度不一样,如果存在环,那么两个指针一定会在环里相遇。代码如下:
/**
 * judge the list has circle or not
 */
template <typename Type>
bool HasCircle(ListNode<Type> *head)
{
	if(head == NULL)
		return false;

	ListNode<Type> *fast, *slow;
	fast = slow = head;

	while (fast && fast->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;

		if(fast == slow)
			return true;
	}

	return false;
}

9.求链表的中间结点

题目:求链表的中间结点,如果链表的长度为偶数,返回中间两个结点的任意一个,若为奇数,则返回中间结点。

此题的解决思路和第4题求链表的倒数第k个结点很相似。可以先求链表的长度,然后计算出中间结点所在链表顺序的位置。但是如果要求只能扫描一遍链表,如何解决呢?最高效额解法和第4题一样,通过两个指针来完成。用两个指针从链表头结点开始,一个指针每次向后移动两个结点,一个每次移动一个结点,直到移动快的那个指针移到到尾结点,那么慢的那个指针即是所求。代码如下:

/**
 * get the middle node of list 
 */
template <typename Type>
const ListNode<Type> * ListMidNode(const ListNode<Type> *head)
{
	if(head == NULL)
		return NULL;

	const ListNode<Type> *fast, *slow;
	fast = slow = head;

	while(fast && fast->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;
	}

	return slow;
}
如果要求在链表长度为偶数的情况下,返回中间两个结点的第一个,那么代码中的while循环判断条件可以改为如下:

while(fast && fast->next != NULL && fast->next->next != NULL)
由题4,7,8可知道,在链表的问题中,通过两个的指针来提高效率是很值得考虑的一个解决方案,所以一定要记住这种解题思路,秒杀面试官吧。。。
先写这么多,以后慢慢在加吧,有新的问题大家可以提出来,一起讨论,共同进步...<^_^>。。。

Date: Sept 4rd, 2013 @lab

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页