C语言实现单链表的相关解析

一、比较顺序表和单链表的优缺点，说说它们在什么场景下使用

顺序表：1、因为顺序表的存储空间是连续的，所以它支持随机访问，可在O（1）内查找元素，cpu高速缓存利用率比单链表高

                2、不增容的情况下尾插比较方便，中/头插效率低

                3、适用于大量访问元素的，而少量增/删元素的程序

单链表：1、可以动态的增加节点，长度可以变化

                2、在内存中存储地址不连续，不支持随机访问，查找元素的时间复杂度为O（n）

                3、适用于需要大量增/删元素操作，而对访问元素无要求的程序

接下来以几个简单的小程序来进一步的介绍单链表

1、从尾到头的打印单链表

看到这个题目我们可以有两种基本的直接解决方法。

第一种是直接打印出来链表然后逆序，第二种是利用递归来解决，接下来我们用递归的方法来解决这个问题  

        void PrintTailToHead(Node* head)

{

       if (head==NULL)return;//以节点为空为结束条件

       PrintTailToHead(head—>next);

        printf(“%d”,head—>data);

}

2、删除一个无头单链表的非尾节点

这道头目的首先考虑极端情况，链表为空和只有一个节点，此时不删除，抛出这两种情况之后可以进行删除

将问题转换为删除要删除的节点(pos)的下一个节点，在删除前将下一个节点的值传给该要删除的节点(pos)，具体实现如下

void EraseNoTail(ListNode* pos)

{

 ListNode* next = NULL;

assert(pos && pos->next);

next = pos->next;

pos->data = next->data;

pos->next = next->next;

free(next);

}

3、在无头单链表的一个节点前插入一个节点

这个问题可以这样考虑，在一个节点后插入一个节点，然后交换两个节点的位置就好了，具体实现如下

ListNode*BuyNode(DataType x)

{

ListNode* listnode = (ListNode*)malloc(sizeof(ListNode));

listnode->data = x;

listnode->next = NULL;

return listnode;

}

void InsertFront(ListNode* pos,DataType x)

{

ListNode* next = NULL;

ListNode* tmp = NULL;

assert(pos);

assert(pos->next);

next = pos->next;

tmp = BuyNode(pos->data);

pos->data = x;

pos->next = tmp;

tmp->next = next;

}

4、单链表实现约瑟夫环（一群人围坐在一起成环状，如：N 2），从某个编号开始报数（如： k 3）数到某个数（如 M）的时候某人出列，一直循环直到所有人出列。

这个问题由于要一直循直到所有人出列，对应到c语言也就是说所有的元素需要被选出来，而且其中用到循环，所以考虑使用循环链表来解决这个问题。具体实现如下。

ListNode* Josephus(ListNode* hus,size_t k)//返回幸存者，数到k的人干掉。

ListNode* next = NULL;

ListNode* man = NULL;

assert(hus);

man = hus;

man = hus;

while(man->next != man)

{

int count = k;

while(--count)

{

man = man->next;

}

next = man->next;

man->data = next->data;

man->next = next->next;

free(next);

renturn man;

}

6、逆置反转单链表

这个问题我们可以考虑在建立一个新的链表，然后使用两个指针来进行对链表的逆置。具体操作如下

newhead = NULL; cur = *ppHead; next = cur->next;把cur的next给newhead，然后把头改为cur，再把next给cur，

直到cur ==NULL

ListNode* newhead = NULL;

ListNode* cur = *ppHead;

ListNode* next = NULL;

 while(cur)

{

next = cur->next;//等于是记录cur，不然找不到cur->next

cur->next = newhead;

newhead = cur;

cur = next;

}

*ppHead = newhead;

7、单链表排序

单链表排序我们可以考虑使用快速排序和冒泡排序，选择其一即可，具体实现如下

void SortList(ListNode* pHead)

{

ListNode* cur = NULL;

ListNode* next = NULL;

ListNode* tail = NULL;

while(tail != pHead)

{

cur = pHead;

next = cur->next;

while(next != tail)

{

if(cur->data > next->data)

{

DataType tmp = cur->data;

cur->data = next->data;

next->data = tmp;

}

cur = cur->next;

next = next->next;

}

tail = next;

}

}

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

ListNode* MergeList(ListNode* list1, ListNode*list2)

{

ListNode* list = NULL;

ListNode* tail = NULL;

if(list1 = NULL)

{

return list2;

} 

if(list2 == NULL)

{

return list1;

}

if(list1->data < list2->data)

{

list = list1;

tail = list1;

list1 = list1->next;

}

else

{

list = list2;

tail = list2;

list2 = list2->next;

}

while(list1 && list2)

{

if(list1->data <list2->data)

{

tail->next = list1;

list1 = list1->next;

}

else

{

tali->next = list2;

list2 = list2->next;

}

tail = tail->next;

}

if(list1)

{

tail->next = list1;

}

if(list2)

{

tail->next = list2;

}

return list;

}

9、i：查找单链表的中间节点，ii：查找单链表的倒数第k个节点，只能遍历一次链表

i：这个问题我们需要考虑到快慢指针，初步的解决方案是用两个指针，一个快指针，一个慢指针，快指针一次走两步，慢指针一次走一步，当快指针为空时慢指针指向的位置就是中间节点的位置，具体实现如下

ListNode* FindMidNode(ListNode* pHead)

{

ListNode* fast = pHead;

ListNode* slow = pHead;

while(fast->next && fast && fast->next->next)

{

slow = slow->next;

fast = fast->next->next;

}

return slow;

}

ii：第二个问题是查找倒数第k个节点，我们可以这样考虑，还是需要用到指针，比如说一个5个节点的链表，我们要找倒数第3个节点，那我们需要指针走3-1步，也就是2步我们就可以到达这个节点了，所以考虑用两个指针，让一个指针先走，当第一个指针走k-1步之前第二个指针不动，当地一个指针从k-1步开始向后走时，第一个指针也开始走，那么当第一个指针到达尾节点时，第二个节点刚好走到倒数第k个节点，具体实现如下

ListNode* K_FindMidNode(ListNode* pHead, size_t k)

ListNode* fast = pHead;

ListNode* slow = pHead;

while(--K)

{

if(fast == NULL)

{

return NULL;

}

fast = fast->next;

}

while(fast->next)

{

fast = fast->next;

slow = slow->next;

return slow;

}