C语言实现单链表面试题--基础篇

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

(1). 顺序表支持随机访问，单链表不支持随机访问。
(2). 顺序表插入/删除数据效率很低，时间复杂度为O(N)（除尾插尾删），单链表插入/删除效率更高，时间复杂度为O(1)。
(3). 顺序表的CPU高速缓存效率更高，单链表CPU高速缓存效率低。

2.从尾到头打印单链表

void reverse(ListNode* plist){    if (NULL == plist)    {        printf("NULL");        return;    }    reverse(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);    next = NULL;}

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

void InsertNonTeal(ListNode *pos, DataType x){    assert(pos);    ListNode* newnode = BuyNode(x);    ListNode* next = pos->next;    pos->next = newnode;    newnode->next = next;    newnode->data = pos->data;    pos->data = x;}

5.单链表实现约瑟夫环
约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3…n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。

ListNode* JosepRing(ListNode* list, int k)//删除第K个结点，把这个结点的data改成下一个结点的data，然后删除第K个结点的下一个结点。{    if (!list)    {        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;        free(next);    }    return cur;}

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){    ListNode* tail = NULL;    while (list->next != tail)    {        ListNode* cur = list;        ListNode* next = cur->next;        while (next != tail)        {            if (cur->data > next->data)            {                Datetype tmp = cur->data;                cur->data = next->data;                next->data = tmp;            }            cur = cur->next;            next = next->next;        }        tail = cur;    }}

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

ListNode* Merge(ListNode* list1, ListNode* list2){    if (!list1)    {        return list2;    }    if (!list2)    {        return list1;    }    //先找出两个链表中小的一个结点，把它摘下来做新链表的头结点    ListNode* list = NULL;    if (list1->data < list2->data)    {        list = list1;        list1 = list1->next;    }    else    {        list = list2;        list2 = 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 = list2;    }    if (!list2)    {        tail->next = list1;    }    return list;}

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

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

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

ListNode* FindTail_k_Node(ListNode* list,int K){    ListNode* slow = list;    ListNode* fast = list;    while (--K)    {        if (fast == NULL)//fast为空说明K值大于链表长度。既K值无效        {            return NULL;        }        fast = fast->next;    }    while (fast->next)    {        slow = slow->next;        fast = fast->next;    }    return slow;}