【C】单链表面试题（基础篇）

1. 比较顺序表和链表的优缺点，说说它们分别在什么场景下使用？

1）从结构上进行分析：

（1）对于顺序表，不论是静态的还是动态的，他们都是连续的存储空间，在读取上时间效率比较快，可以通过地址之间的运算来进行访问，但是在插入和删除操作会出现比较麻烦的负载操作。

（2）对于链表，因为是链式存储，在我们需要的时候才在堆上开辟空间，对于插入查找的方式比较便携。但是对于遍历的话需要多次的空间跳转。

2）从结构空间申请方式分析：

（1）顺序表的空间开辟是在满的时候进行多空间的申请开辟。往往存在着 2^n 的开辟原则。在开辟次数比较多的时候，会出现比较大的空间浪费。

（2）链表的空间开辟是针对于单个节点的空间开辟访问，不存在多余的空间浪费。并且在碎片内存池的机制下，可以有效地利用空间。

通过上面的总结，可以分析出顺序表往往用于查找遍历操作比较频繁的情况下使用。链表则针对于数据删除修改的多操作性上的情况下使用。

2. 从尾到头打印单链表

void PrintTailToHead(ListNode* pList)
{
if (pList == NULL)
return;
PrintTailToHead(pList->next);
printf("%d->", pList->data);
}

3. 删除一个无头单链表的非尾节点

void EraseNonTail(ListNode* pos)
{
assert(pos);
assert(pos->next);
ListNode* next = pos->next;
pos->data = next->data;
pos->next = next->next;
free(next);
}

4. 在无头单链表的一个节点前插入一个节点

void InsertNonHead(ListNode* pos, DataType x)
{
assert(pos);
ListNode* tmp = BuyNode(x);
ListNode* next = pos->next;
pos->next = tmp;
tmp->next = next;
DataType tmpData = pos->data;
pos->data = tmp->data;
tmp->data = tmpData;
}

5. 单链表实现约瑟夫环

       约瑟夫问题的一种描述是：编号为 1，2，…，n 的 n 个人按顺时针方向围坐一圈，每人持一个密码（正整数）。一开始任选一个正整数作为报数上限值 m，从第一个人开始按顺时针方向自 1 开始顺序报数，报到 m 时停止报数。报 m 的人出列，将他的密码作为新的 m 值，从他在顺时针方向上的下一个人开始重新从 1 报数，如此下去，直至所有人全部出列为止。

ListNode* JosephRing(ListNode* list, int k)
{
if (list == NULL)
return NULL;
ListNode* cur = list;
while (cur->next != cur)
{
int count == k;
while (--count)
{
cur = cur->next;
}
ListNode* next = cur->next;
cur->data = next->data;
cur->next = next->next;
free(next);
}
return cur;
}
//销毁
void DestoryList(ListNode** ppList)
{
ListNode* cur = *ppList;
while (cur)
{
ListNode* next = cur->next;
free(cur);
cur = next;
}
*ppList = NULL;
}

6. 逆置/反转单链表

ListNode* Reverse(ListNode* list)
{
ListNode* newList = NULL;
ListNode* cur = list;
while (cur)
{
//摘结点
ListNode* tmp = cur;
cur = cur->next;
//头插
tmp->next = newList;
newList = tmp;
}
return newList;
}

7. 单链表排序（冒泡排序 & 快速排序）

void BubbleSort(ListNode* list)
{
if (list == NULL || list->next == NULL)
return;
ListNode* tail = NULL;
while (tail != list->next)
{
int exchange = 0;
ListNode* cur = list;
ListNode* next = cur->next;
while (next != tail)
{
if ((cur->data) > next->data)
{
DataType tmp = cur->data;
cur->data = next->data;
next->data = tmp;
exchange = 1;
}
cur = cur->next;
next = next->next;
}
tail = cur;
}
}

8. 合并两个有序链表，合并后依然有序

ListNode* Merge(ListNode* list1, ListNode* list2)
{
if (list1 == NULL)
{
return list2;
}
if (list2 == NULL)
{
return list1;
}
//先摘一个结点作头
ListNode* list = NULL;
if (list2->data < list1->data)
{
list = list2;
list2 = list2->next;
}
else
{
list = list1;
list1 = list2->next;
}
ListNode* tail = list;
while (list1 && list2)
{
if (list1->data < list2->data)
{
tail->next = list1;
list1 = list1->next;
}
else
{
tail->next = list2;
list2 = list2->next;
}
tail = tail->next;
}
if (list1)
{
tail->next = list1;
}
else
{
tail->next = list2;
}
return list;
}

9. 查找单链表的中间节点，要求只能遍历一次链表

ListNode* FindMidNode(ListNode* list)
{
if (list == NULL)
return NULL;
ListNode* slow = list, *fast = list;
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
}
return slow;
}

10. 查找单链表的倒数第 k 个节点，要求只能遍历一次链表 

ListNode* FindTailkNode(ListNode* list, int k)
{
ListNode* slow = list, *fast = list;
while (k--)
{
if (fast == NULL)
{
return NULL;
}
fast = fast->next;
}
while (fast)
{
slow = slow->next;
fast = fast->next;
}
return slow;
}

11. 删除单链表的倒数第 k 个节点，要求只能遍历一次链表 

ListNode* DeleteLastNode(ListNode* head, int k)
{
if (NULL == head || k == 0)
{
return;
}
ListNode* fast = head;
while (k--)
{
if (fast == NULL)
{
return NULL;
}
fast fast->next;
}
ListNode* del = head;
ListNode* predel = NULL;
while (fast)
{
predel = del;
del = del->next;
fast = fast->next;
}
//倒数第 k 个刚好是头结点
if (del == head)
{
head = head->next;
}
else
{
predel->next = del->next;
}
delete del;
}