在笔试面试考数据结构时，由于时间有限，所出的题不会是红黑树、平衡二叉树等比较复杂的数据结构。链表结构简单，题目规模小但需要仔细考虑细节，因此称为笔试面试中的高频考点。因此，下面总结出链表相关题目，以供复习。
1.比较顺序表和链表的优缺点，说说他们分别在什么场景下使用？
2.从尾到头打印单链表（剑指offer第五题）
3.删除一个无头单链表的非尾节点
4.在无头单链表的一个非头结点前插入一个节点
5.单链表实现约瑟夫环
6.逆置/反转单链表
7.单链表排序（冒泡排序&快速排序）
8.合并两个有序链表合并后依然有序
9.查找链表的中间节点，要求只能遍历一次链表
10.查找单链表倒数第K个节点，要求只能遍历一次链表
11.判断单链表是否带环？若带环，求环的长度？求环的入口点？并计算每个算法的时间复杂度&空间复杂度。
12.判断两个链表是否相交，若相交，求交点（假设链表不带环）
13.判断两个链表是否相交，若相交，求交点（假设链表带环）
14.复杂链表的复制，一个链表的每个节点，有一个指向next指针指向下一个节点，还有一个random指针指向这个链表中的一个随机节点或者NULL，现在要求实现复制这个链表
15.求两个已排序链表中相同的数据。void UnionSet(ListNode* l1,ListNode* l2);
/////////////////////////////////////////////////////////////////////////////////////////////////////////(分割线）///////////////////////////////////////////////////
1.比较顺序表和链表的优缺点，说说他们分别在什么场景下使用？
首先我们从顺序表和链表的结构上来进行分析：
（1）对于顺序表，无论是动态的还是静态的，他们都是连续的存储空间，在读取上时间效率比较高，可通过地址之间的运算来访问，但是在插入和删除时会出现比较麻烦的负载操作。
（2）对于顺序表，因为是链式存储。因此在我们需要的时候我们才在堆上为他们开辟空间，链表对于插入删除比较简单，但是遍历的话需要多次跳转。
其次，我们从顺序表和链表的空间申请方式来看：
（1）对于顺序表，空间开辟是在顺序表已满的时候开辟，开辟次数较多的时候会出现较大的空间浪费
（2）对于链表，空间是针对单个节点的，不存在多余的空间浪费。并且在碎片内存池的机制下，可以有效的利用空间。
综上所述：顺序表一般用于查找遍历操作比较频繁的情况下使用，链表则针对于数据删除修改操作比较多的情况下使用。
2.从尾到头打印单链表
从尾到头打印单链表有两种解法，一种是利用栈把节点从头到尾push进去，利用栈先进后出的特点，从尾到头打印单链表节点，一种是利用递归，在输出现有节点之前输出下一个节点，循环直至最后一个节点，然后再将节点从尾到头依次打印。
code1:利用栈
void PrintTailToHead(ListNode* head)
{
stack<int> st;
ListNode* p = head;
while (p != NULL)
{
st.push(p->_data);
p = p->_next;
}
while (!st.empty())
{
printf("%d->", st.top());
st.pop();
}
}
code2：利用递归
void PrintTailToHead(ListNode* head)
{
if (head != NULL)
{
while (head->_next != NULL)
{
PrintTailToHead(head->_next);
}
}
printf("%d->", head->data);
}
3.删除一个无头单链表的非尾节点
由于链表无头，所以用常规方法删除节点是不可能的。所以我们可以换种思路，将要删除的节点后面的节点的值赋给要删的节点，然后再把要删除节点的后面的节点删除，等于通过转换，为被删除节点创造了一个头结点。代码如下：
void DeleteNotTailNode(ListNode* p)
{
ListNode* s = p->_next;
assert(s);
p->_data = s->_data;
p->_next = s->_next;
free(p);
}
4.在无头单链表的一个非头结点前插入一个节点
这个题目跟上一个题目很像。在这个非头结点后面插入一个节点，把这个非头节点的值赋给新插入的节点，然后再把要插入的值赋给这个非头节点即可。
void InsertNotHeadNode(ListNode* p, int data)
{
ListNode* s = (ListNode)malloc(sizeof(&ListNode));
assert(s);
s->_next =p->_next;
p->_next = s;
s->_data = p->_data;
p->_data = data;
}
5.单链表实现约瑟夫环（剑指offer第45题）
6.逆置/反转单链表（剑指offer第16题）
7.单链表排序（冒泡排序&快速排序）
8.合并两个有序链表合并后依然有序（剑指offer第17题）
这个题比较简单，分别用指针指向两个链表，比较两个链表指针所指向节点的值，然后将节点取下来重新组成一个链表即可，代码如下：
ListNode Merge(ListNode* head1, ListNode* head2)
{
if (head1 == NULL)
return head2;
if (head2 == NULL)
return head1;
ListNode* newhead = NULL;
if (head1->_data < head2->_data)
{
newhead = head1;
newhead->_next=Merge(head1->_next, head2);
}
if (head1->_data>head2->data)
{
newhead = head2;
newhead->_next = Merge(head1, head2->_next);
}
}
9.查找链表的中间节点，要求只能遍历一次链表
查找链表的中间节点，但只能遍历一次链表，所以我们会想到用快慢指针来解决这个问题。定义一个快指针，每次走两步，载定义一个慢指针，每次走一步。等到快指针走到链表尾，慢指针所指向的节点就是链表的中间节点。代码如下：
ListNode* FindMidNode(ListNode* head)
{
ListNode* fast;
ListNode* slow;
fast = head;
slow = head;
while (fast&&fast->_next)
{
slow = slow->_next;
fast = fase->_next->_next;
}
retrun slow;
}
10.查找单链表倒数第K个节点，要求只能遍历一次链表（剑指offer第15题）
其实这个题跟上面的题很像，稍微转化一下就能想出思路。我们可以定义两个指针，一个指针先走K步，然后两个指针同时移动，等到先走的指针走到链表尾部，后走的指针所指向的节点就是倒数第K个节点。要注意考虑链表的各种情况。代码如下：
ListNode* FindKthNode(ListNode* head,int k)
{
if (head == NULL || k == 0)
return NULL;
ListNode* fast;
ListNode* slow;
fast = head;
slow = head;
for (int i = 0; i < k - 1; ++i) //要注意链表长度比K短的情况
{
if (fast->_next != NULL)
fast = fast->_next;
else retrun NULL;
}
while (fast->_next != NULL)
{
fast = fast->_next;
slow = slow->_next;
}
return slow;
}
11.判断单链表是否带环？若带环，求环的长度？求环的入口点？并计算每个算法的时间复杂度&空间复杂度。（剑指offer第56题）
12.判断两个链表是否相交，若相交，求交点（假设链表不带环）
13.判断两个链表是否相交，若相交，求交点（假设链表带环）
14.复杂链表的复制，一个链表的每个节点，有一个指向next指针指向下一个节点，还有一个random指针指向这个链表中的一个随机节点或者NULL，现在要求实现复制这个链表（剑指offer第26题）
15.求两个已排序链表中相同的数据。void UnionSet(ListNode* l1,ListNode* l2);
16.在已排序的链表中删除链表中重复的结点（剑指offer第57题）