转自:http://blog.sina.com.cn/s/blog_54b2ce380100uqwr.html
某本书上面说了,链表这个东西,实际用的并不多,但是可以提供很好的考察面试者编程技巧和思维能力的素材。这里总结一下,见过的面试题和对应的候选解法。
题一、 给定单链表,检测是否有环。
http://ostermiller.org/find_loop_singly_linked_list.html
这篇文章讲了很多好的坏得相关算法。
题二、 给定两个单链表(head1, head2),检测两个链表是否有交点,如果有返回第一个交点。
题三、 给定单链表(head),如果有环的话请返回从头结点进入环的第一个节点。
题四、只给定单链表中某个结点p(并非最后一个结点,即p->next!=NULL)指针,删除该结点。
题五、只给定单链表中某个结点p(非空结点),在p前面插入一个结点。
题六、给定单链表头结点,删除链表中倒数第k个结点。
题七、链表排序
double cmp(ListNode *p ,ListNode *q)
{return (p->keyVal - q->keyVal);}
ListNode* mergeSortList(ListNode *head)
{
}
另外一篇博客,链表的归并排序:http://blog.csdn.net/lalor/article/details/7430624 贴在下面
当我们需要对链表进行排序时,由于不能对它的元素进行随机访问,所以更适合使用归并排序,大名鼎鼎的快速排序用到链表上,效率也很低,原因还是在于不能对链表中的元素进行随机访问,同理,采用堆排序更是不可能的事情。
算法具体实现时需要一个指向头节点(链表的第一个节点,链表中不包含额外的一个节点来作头节点)的指针,这是因为在算法实现的时候,不大可能第一个节点正好就是所有元素中最小的一个,则链表的头节点会改变,因此我们需要一个指向头节点的指针来存储不断变化的头节点。
算法思想:
1) If head is NULL or there is only one element in the Linked List
then return.
2) Else divide the linked list into two halves.
FrontBackSplit(head, &a, &b); /* a and b are two halves */
3) Sort the two halves a and b.
MergeSort(a);
MergeSort(b);
4) Merge the sorted a and b (using SortedMerge() discussed here)
and update the head pointer using headRef.
*headRef = SortedMerge(a, b);
代码示例:
#include <stdio.h>
#include <stdlib.h>
/*Link list node*/
struct node
{
int data;
struct node* next;
};
/*function prototype */
struct node* SortedMerge(struct node* a, struct node* b);
void FrontBackSplit(struct node* source, struct node** frontRef, struct node** backRef);
/*sorts the linked list by changing next pointers(not data) */
void MergeSort(struct node** headRef)
{
struct node* head = *headRef;
struct node* a;
struct node* b;
/*base case-- length 0 or 1 */
if((head == NULL) || (head->next == NULL))
{
return;
}
/*Split head into 'a' and 'b' sublists */
FrontBackSplit(head, &a, &b);
/*Recursively sort the sublists */
MergeSort(&a);
MergeSort(&b);
/* answer = merge the two sorted lists together */
*headRef = SortedMerge(a, b);
}
struct node* SortedMerge(struct node* a, struct node* b)
{
struct node* result = NULL;
/* Base cases */
if(a == NULL)
return (b);
else if(b == NULL)
return (a);
/* Pick either a or b recur */
if(a->data <= b->data)
{
result = a;
result->next = SortedMerge(a->next, b);
}
else
{
result = b;
result->next = SortedMerge(a, b->next);
}
return (result);
}
/* UTILITY FUNCTIONS */
/* Split the nodes of the given list into front and back halves,
and return the two lists using the references parameters.
If the length is odd, the extra node shold go in the front list.
Uses the fast/slow pointer strategy. */
void FrontBackSplit(struct node* source, struct node** frontRef, struct node** backRef)
{
struct node* fast;
struct node* slow;
if(source == NULL || source->next == NULL)
{
*frontRef = source;
*backRef = NULL;
}
else
{
slow = source;
fast = source->next;
/* Advance 'fast' two nodes, and advance 'slow' one node */
while(fast != NULL)
{
fast = fast->next;
if( fast != NULL )
{
slow = slow->next;
fast = fast->next;
}
}
*frontRef = source;
*backRef = slow->next;
slow->next = NULL;
}
}
/*Function to print nodes in a given linked list*/
void printList(struct node* node)
{
while( node != NULL )
{
printf("%d ", node->data);
node = node->next;
}
}
/* Function to insert a node at the begining of the linked list*/
void push(struct node** head_ref, int new_data)
{
/*allocate node*/
struct node* new_node = (struct node*)malloc(sizeof(struct node));
/*put in the data*/
new_node->data = new_data;
/*link the old list off the new node*/
new_node->next = (*head_ref);
/*move the head to point to the new node*/
(*head_ref) = new_node;
}
/* Drier program to test above functions*/
int main()
{
/* Start with the empty list */
struct node* res = NULL;
struct node* a = NULL;
/* Let us create a unsorted linked lists to test the functions
Created lists shall be a: 2->3->20->5->10->15 */
push(&a, 15);
push(&a, 10);
push(&a, 5);
push(&a, 20);
push(&a, 3);
push(&a, 2);
/* Sort the above created Linked List */
MergeSort(&a);
printf("\n Sorted Linked List is: \n");
printList(a);
return 0;
}
题八、倒转单链表
给出非递归和递归解法:
#include <iostream>
using namespace std;
struct Node
{
}*head;
// 非递归写法
Node* InverseLinkedList(Node* head)
{
}
// 递归写法
Node* InverseLinkedListRecur(Node* head)
{
}
int main()
{
}
题九、两个有序链表的合并
typedef struct node{
int data;
struct node * next;
}* List;
List mergeSortedLinkList(List list1, List list2)
{
List pList1,pList2,mergedList,pCurNode;
if (list1 == NULL)
{
return list2;
}
if (list2 == NULL)
{
return list1;
}
pList1 = list1;
pList2 = list2;
mergedList = NULL;
if (pList1==pList2)
{
mergedList = pList1;
pList1 = pList1->next;
pList2 = pList2->next;
}
else
{
if (pList1->data <= pList2->data)
{
mergedList = pList1;
pList1 = pList1->next;
}
else
{
mergedList = pList2;
pList2 = pList2->next;
}
}
pCurNode = mergedList;
while(pList1 && pList2)
{
if (pList1==pList2)
{
pCurNode->next = pList1;
pCurNode = pList1;
pList1 = pList1->next;
pList2 = pList2->next;
}
else
{
if (pList1->data <= pList2->data)
{
pCurNode->next = pList1;
pCurNode = pList1;
pList1 = pList1->next;
}
else
{
pCurNode->next = pList2;
pCurNode = pList2;
pList2 = pList2->next;
}
}
}
pCurNode->next =pList1?pList1:pList2;
return mergedList;
}
题十、找出链表的中间元素
单链表的一个比较大的特点用一句广告语来说就是“不走回头路”,不能实现随机存取(random access)。如果我们想要找一个数组a的中间元素,直接a[len/2]就可以了,但是链表不行,因为只有a[len/2 - 1] 知道a[len/2]在哪儿,其他人不知道。因此,如果按照数组的做法依样画葫芦,要找到链表的中点,我们需要做两步(1)知道链表有多长(2)从头结点开始顺序遍历到链表长度的一半的位置。这就需要1.5n(n为链表的长度)的时间复杂度了。有没有更好的办法呢?有的。想法很简单:两个人赛跑,如果A的速度是B的两倍的话,当A到终点的时候,B应该刚到中点。这只需要遍历一遍链表就行了,还不用计算链表的长度。