单链表的相关操作

最新推荐文章于 2023-03-25 17:58:02 发布

qq_41027326

最新推荐文章于 2023-03-25 17:58:02 发布

阅读量149

点赞数

分类专栏：数据结构文章标签：排序逆置环长环入口约瑟夫环问题

本文链接：https://blog.csdn.net/qq_41027326/article/details/79729154

版权

数据结构专栏收录该内容

28 篇文章 1 订阅

订阅专栏

1.冒泡排序对单链表进行排序

void LinkListBubbleSort(LinkNode* head)
{
    if(head == NULL)
    {    
        return;//空链表
    }    
    if(head -> next == NULL)
    {    
        return;//只有一个结点
    }    
    LinkNode* cur = head;//趟数
    LinkNode* tail = NULL;//尾指针
    LinkNode* tmp = head;//次数
    for(; cur -> next != NULL; cur = cur -> next)
    {    
        for(tmp = head; tmp -> next != tail; tmp = tmp -> next)
        {    
            if(tmp -> data > tmp -> next -> data)
            {    
                LinkNodeSwap(&tmp -> data, &tmp -> next -> data);
            }                                                                                                                                                
        }    
        tail = tmp; 
    }    
}

其中cur控制总共需要几趟,N个元素需要N-1趟排序, tmp控制一趟需要进行几次比较
这里写图片描述

2.将两个已经排好序的单链表进行合并,并且保证新链表有序

LinkNode* LinkListMerge(LinkNode* head1, LinkNode* head2)
{                                                                                                                                                            
    if(head1 == NULL)
    {
        return head2;
    }
    if(head2 == NULL)
    {
        return head1;
    }
    LinkNode* new_head;
    LinkListInit(&new_head);
    LinkNode* cur1 = head1;
    LinkNode* cur2 = head2;
    while(cur1 != NULL && cur2 != NULL)
    {
        if(cur1 -> data > cur2 -> data)
        {
            LinkListPushBack(&new_head, cur1 -> data);
            cur1 = cur1 -> next;
        }
        else
        {
            LinkListPushBack(&new_head, cur2 -> data);
            cur2 = cur2 -> next;
        }
    }
    while(cur2 != NULL)
    {
        LinkListPushBack(&new_head, cur2 -> data);
        cur2 = cur2 -> next;
    }
    while(cur1 != NULL)
    {
        LinkListPushBack(&new_head, cur1 -> data);
        cur1 = cur1 -> next;
    }

    return new_head;
}

假设待排序列如下图
这里写图片描述
那就创建一个新链表,将其初始化,每次将cur1 和 cur2 作比较,在保证 cur1 和 cur2 两个指针都不为空的前提下将它们两个中 data 小的插入到新链表的尾部就可以同时 cur1 和 cur2 往后移动,当 cur1 为空, cur2 不为空时就将 cur2 的剩下的所有元素依次全部搬到新链表中.
这里写图片描述

3.查找单链表中间结点,并且保证只能遍历一次链表


LinkNode* LinkListFindMid(LinkNode* head)
{
    if(head == NULL)
    {
        return NULL;
    }
    if(head -> next == NULL || head -> next -> next == NULL)
    {
        return head;
    }
    LinkNode* fast = head;
    LinkNode* slow = head;
    while(fast != NULL && fast -> next != NULL)
    {
        fast = fast -> next -> next;
        slow = slow -> next;                                                                                                                                 
    }
    return slow;
}

定义两个指针 fas t, slow ,在保证 fast 不为空并且 fast -> next 不为空的前提下,让 fast 一次走两步,slow一次走一步, 当 fast 走到空的时候 slow 就刚好处于中间,此时返回 slow 就可以了
这里写图片描述

4.找链表的倒数第 k 个结点

LinkNode* LinkListFindLastKNode(LinkNode* head, int K)
{
    if(head == NULL)
    {
        return NULL;//空链表
    }
    int count = 0;
    LinkNode* cur = head;
    while(cur != NULL)
    {
        count ++;
        cur = cur -> next;
    }
    if(K > count)
    {
        return NULL;//K值大于节点个数
    }
    LinkNode* slow = head;
    LinkNode* fast = head;
    int i = 0;
    for(; i < K; i ++)
    {                                                                                                                                                        
        if(fast != NULL)
        {
            fast = fast -> next;
        }
    }
    while(fast != NULL)
    {
        slow = slow -> next;
        fast = fast -> next;
    }
    return slow;
}

同样,定义两个指针, fast 和 slow, 让 fast 先走 k 步, 然后 fas 走一步,slow跟着走一步,当 fast 等于空的时候 slow 刚好是倒数第 k 个结点
这里写图片描述

4.删除链表的倒数第 k 个结点

void LinkListEraseLastKNode(LinkNode** phead, int K)
{
   if(phead == NULL)
    {
        return;//非法输入
    }
    if(*phead == NULL)
    {                                                                                                                                                        
        return;//空链表
    }
    int count = 0;
    LinkNode* cur = *phead;
    while(cur != NULL)
    {
        count++;
        cur = cur -> next;
    }
    if(K > count)
    {
        return;//K大于结点个数
    }
    if(K == count)
    {
        LinkListPopFront(phead);
        return;
    }
    LinkNode* to_delete = LinkListFindLastKNode(*phead, K + 1);
    LinkListEraser(phead, to_delete -> next);
}

利用前面的算法找到倒数第 k + 1个结点, 然后删除第 k + 1 个结点的下一个结点即可
这里写图片描述

5.约瑟夫环问题

LinkNode* LinkListJosephCircle(LinkNode** phead, int M)
{
    if(phead == NULL)
    {                                                                                                                                                          
        return NULL;//非法输入
    }
    if(*phead == NULL)
    {
        return NULL;//链表为空
    }
    if((*phead) -> next == *phead)
    {
        return *phead;//只有一个元素
    }
    LinkNode* cur = *phead;
    LinkNode* to_delete;
    int i = 0;
    while(cur -> next != cur)
    {
        for(i = 1; i < M; i ++)
        {
            cur = cur -> next;
        }
        cur -> data = (cur -> next) -> data;
        to_delete = cur -> next;
        cur -> next = to_delete -> next;
        LinkNodeDestroy(&to_delete);
    }
    return cur;
}

对于约瑟夫环问题先将这个链表形成一个带环的链表,即最后一个结点的 next 指向第一个结点,然后从第一个结点遍历这个链表,当遍历到第M个结点时就把这个结点删除,注意当给定目标是M是,指针移动M - 1次, 当指针移动M-1次时,就定义一个指针to_delete指向要删除的这个元素,然后删除这个元素,如此继续,直到剩余一个结点,即cur -> next = cur 时,就返回这个结点
这里写图片描述

6.逆序打印单链表

void LinkListReversePrint(LinkNode* phead)
{
   if(phead == NULL) 
   {
       return;
   }                                                                                                                                                           
   LinkListReversePrint(phead -> next);
   printf("%c   ", phead -> data);
}

对于逆序打印单链表,采用递归的思想,即让指针往后遍历整个链表,直到最后一个时再将其对应的 data 打印出来即可
这里写图片描述

7.单链表的逆置

void LinkListReverse(LinkNode** phead)
{
    if(phead == NULL)
    {    
        return;//非法输入
    }    
    if(*phead == NULL)
    {    
        return;//链表为空
    }    
    if((*phead) -> next == NULL)
    {    
        return;//只有一个元素
    }    
    LinkNode* cur = *phead;
    LinkNode* to_delete = cur; 
    while(cur -> next != NULL)
    {    
        to_delete = cur -> next;
        cur -> next = to_delete -> next;
        to_delete -> next = *phead;
        *phead = to_delete;                                                                                                                                    
    }    
}

这里写图片描述

8.判断链表是否有环

LinkNode* LinkListHasCircle(LinkNode* head)
{
    if(head == NULL)                                                                                                                                           
    {    
        return NULL;//空链表
    }    
    if(head -> next == NULL)
    {    
        return NULL;//一个结点并且无环
    }    
    LinkNode* fast = head;
    LinkNode* slow = head;
    while(fast != NULL && fast -> next != NULL)
    {    
        fast = fast -> next -> next;
        slow = slow -> next;
        if(slow == fast)
        {    
            return slow;
        }    
    }    
    return NULL;
}

先构造一个有环的链表,然后定义两个指针 fast 和 slow, 在保证 fast 不为空, 以及fast -> next 不为空的前提下,fast一次走两步,slow一次走一步,如果有环,在一定时间内 fast 一定会追上 slow ,即 fast = slow,当遇到 fast 为空时,那就说明没有环
这里写图片描述

9.求环的长度

int LinkListGetCircleLength(LinkNode* head)
{
    if(head == NULL)
    {    
        return 0;//空链表
    }    
    if(head -> next == NULL)
    {    
        return 0;//只有一个结点，没有环
    }    
    LinkNode* meet = LinkListHasCircle(head);
    LinkNode* slow = meet;
    int size = 0; 
    while(slow -> next != meet)
    {    
        size ++;
        slow = slow -> next;
    }    
    return size + 1; 
}

定义一个快指针fast,一个慢指针slow,fast一次走两步, slow一次走一步,当两者相遇时定义一个指针meet记住这个位置, 然后让slow继续往前走,同时定义一个计数器进行计数count,当slow的next等于meet时候,此时count+1便是换的长度
这里写图片描述

10.求环的入口点

LinkNode* LinkListGetCircleEntry(LinkNode* head)
{
    if(head == NULL)
    {    
        return NULL;//空链表                                                                                                                                   
    }    
    if(head -> next == NULL)
    {    
        return NULL;//只有一个结点，并且没有环
    }    
    LinkNode* meet = LinkListHasCircle(head);
    if(meet == NULL)
    {    
        return NULL;
    }    
    LinkNode* slow = head;
    LinkNode* fast = meet;
    while(slow != fast)
    {    
        slow = slow -> next;
        fast = fast -> next;
    }    
    return slow;
}

还是快慢指针,链表开始到环入口的距离等于快慢指针相遇点到环入口的距离,即定义一个指针fast等于快慢指针相遇的那个位置,再定义一个指针slow等于head,然后两个指针一次向后遍历,当fast = slow 的之后,返回这个位置,便是环入口的位置
这里写图片描述

qq_41027326

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
单链表的相关操作

1.冒泡排序对单链表进行排序void LinkListBubbleSort(LinkNode* head){ if(head == NULL) { return;//空链表 } if(head -&gt; next == NULL) { return;//只有一个结点 } ...
复制链接

扫一扫