数据结构之链表经典算法QJ题目

最新推荐文章于 2024-05-20 22:31:31 发布
最新推荐文章于 2024-05-20 22:31:31 发布
阅读量695 收藏 18
点赞数 23
分类专栏： 数据结构 文章标签： 数据结构 链表 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52550678/article/details/136153600
版权

目录

单链表经典算法题目

1. 单链表相关经典算法OJ题：移除链表元素

题目路径（点击练习）：

题目：
在这里插入图片描述

思路一：

遍历原链表，遇到val就执行删除val节点的操作

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val) {
    
		//当链表的头结点的值为val时
       while(head && head->val==val)
    {
        head = head->next;
    }
    //当链表为空的时候，直接返回
     if (head == NULL) {
        return head;
    }   
      
    struct ListNode* pre = head;//定义临时指针指向与head一致

   
     while (pre->next)
    {
    	 //当链表指向的下一个节点的值为val
        if (pre->next->val == val) {
            pre->next = pre->next->next;   
        } else {
            /* 没找到，则继续遍历查找 */
            pre = pre->next;
        }
    }
    return head;
}
思路二：

定义新链表，遍历原链表找不为val的节点，尾插在新链表中

在这里插入图片描述

链表为空：插入进来的节点就是链表的头结点和尾结点

链表不为空：插入进来的节点就是新的尾结点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val) {
    struct ListNode* newHead = NULL;
    struct ListNode* newtail = NULL;
    struct ListNode* pcur = head;

    while(pcur)
    {
        //当原链表pcur的val不为查找的val时，将此节点尾插到新节点中,否则就继续往下走
        if(pcur->val != val)
        {
            //当链表为空
            if(newHead == NULL)
            {
                newHead = newtail = pcur;
            }else{
                //链表不为空
                newtail->next = pcur;
                newtail = newtail->next;
            }
        }
        pcur = pcur->next;
    }

    if(newtail)
        {
            newtail->next=NULL;
        }
    return newHead;
}

2. 单链表相关经典算法QI题：链表的中间节点

题目路径（点击练习）

题目

在这里插入图片描述

思路一

使用循环遍历统计链表中的个数

使用for循环根据除以2结果走到中间节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* middleNode(struct ListNode* head) {
    struct ListNode* pre= head;
    int flag = 0;//用于计数
    while(pre)
    {
        flag++;//统计链表的个数
        pre=pre->next;
    }
    
   int mid = flag/2;//获取中间的位置
   pre=head;
   for(int i=0;i<mid;i++)
   {
       pre=pre->next;
   }
    return pre;
}
思路二

根据快慢指针

先定义两个指针
slow指针每走一步
fast指针每走两步

当fast->next 为空，则slow刚好指向的就是中间节点

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* middleNode(struct ListNode* head) {  
    //定义两个指针
    struct ListNode* slow = head;
    struct ListNode* fast = head;

    while(fast&&fast->next)
    {
        slow = slow->next;//一次走一步
        fast = fast->next->next;//一次走两步。当fase走完的时候slow指向的就是中间的节点
    }
    return slow;
}

3. 单链表相关经典算法QJ题：反转链表

题目路径（点击练习）

题目：

在这里插入图片描述

思路一

简单迭代

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {
   //定义两个指针
   struct ListNode* temp = NULL;
   struct ListNode* curr = NULL;
   //循环遍历head
    while(head){
        temp = head->next;
        head->next = curr;
        curr = head;
        head = temp;//head和temp已被事实上置空了，防止跑飞
    }
    return curr;

}
思路二

创建三个指针

分别记录前驱结点，当前节点，后继节点，改变原链表指针方向
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {
    //处理空链表
    if(head==NULL)
    {
        return head;
    }
    
    //创建三个指针，分别记录前驱节点，当前节点以及后继节点
    struct ListNode* n1 = NULL;
    struct ListNode* n2 = head;
    struct ListNode* n3 = head->next;

    while(n2)
    {
        n2->next = n1;

        n1 = n2;
        n2 = n3;
        if(n3)
        {
            n3 = n3->next;
        }
    }
 return n1;
}

4. 单链表相关经典算法QJ题：合并两个有序链表

题目路径（点击练习）

题目

在这里插入图片描述

思路

在两个原链表中创建两个指针l1,l2
再创建一个新链表

l1和l2相比较，较小值的放入新链表中
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {

    //当list1为空时直接返回list2
   if(list1 == NULL)
   {
       return list2;
   }
   //同理
   if(list2 == NULL)
   {
       return list1;
   }

   struct ListNode* l1 = list1;
   struct ListNode* l2 = list2;

   struct ListNode* newHead = NULL;
   struct ListNode* newTail = NULL;


   while(l1 && l2)
   {
       //当l1<l2
       if(l1->val < l2->val)
       {
           //判读链表是否为空
           if(newHead == NULL)
           {
               newHead = newTail = l1;
           }else{
               newTail->next = l1;
               newTail = newTail->next;
           }
           l1 = l1->next;
       }//l2<l1
       else{
           if(newHead == NULL)
           {
               newHead = newTail = l2;
           }else{
               newTail->next = l2;
               newTail = newTail->next;
           }
           l2=l2->next;
       }
       
   }
      //跳出循环时，出现两种情况l1为空，或者l2为空
      if(l1)
      {
          newTail->next = l1;
      }
      if(l2)
      {
          newTail->next = l2;
      }

   return newHead;
}

但是我们可以看到，上述出现了重复的代码，如何优化解决呢？

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {

    //当list1为空时直接返回list2
   if(list1 == NULL)
   {
       return list2;
   }
   //同理
   if(list2 == NULL)
   {
       return list1;
   }

    ListNode* l1 = list1;
    ListNode* l2 = list2;

   ListNode* newHead,*newTail;//申请一块哨兵位
   newHead=newTail=(ListNode*)malloc(sizeof(ListNode));
   while(l1 && l2)
   {
       //当l1<l2
       if(l1->val < l2->val)
       {
           newTail->next = l1;
           newTail = newTail->next;
           l1 = l1->next;
       }//l2<l1
       else{
           newTail->next = l2;
           newTail = newTail->next;
           l2=l2->next;
       }
       
   }
      //跳出循环时，出现两种情况l1为空，或者l2为空
      if(l1)
      {
          newTail->next = l1;
      }
      if(l2)
      {
          newTail->next = l2;
      }

      
    //malloc开辟了空间，但是这块空间用不了得释放掉
    ListNode* ret = newHead->next;
    free(newHead);  

   return ret;
}

5. 循环链表经典应用：环形链表的约瑟夫问题

著名的Josephus问题 据说著名犹太 Josephus有过以下的故事：
~
在罗⻢⼈占领乔塔帕特后，39 个犹太⼈与Josephus及他的朋友躲到⼀个洞中，39个犹太⼈决定宁愿死也不要被⼈抓到，于是决定了⼀个⾃杀 ⽅式，41个⼈排成⼀个圆圈，由第1个⼈开始报数，每报数到第3⼈该⼈就必须⾃杀，然后再由下⼀ 个重新报数，直到所有⼈都⾃杀⾝亡为⽌。 历史学家
然⽽Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与⾃⼰安排在 第16个与第31个位置，于是逃过了这场死亡游戏。

题目

题目路径（点击练习）

在这里插入图片描述

思路

根据n来创建不带头单向链表
逢m删除当前节点

在这里插入图片描述

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param n int整型 
 * @param m int整型 
 * @return int整型
 */

 typedef struct ListNode ListNode;

 ListNode* BuyNode(int x)
 {
    ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
    newnode->val = x;
    newnode->next = NULL;
    return newnode;
 }

 ListNode* createList(int n)
 {
    ListNode* phead = BuyNode(1);
    ListNode* ptail = phead;
    for(int i = 2;i<=n;i++)
    {
        ptail->next=BuyNode(i);
        ptail = ptail->next;
    }
    //链表要首尾相连使其循环起来
    ptail->next = phead;
    return phead;
 }
int ysf(int n, int m ) {
    //根据n来创建不带头单向链表
    ListNode* head = createList(n);
    ListNode* pcur = head;
    ListNode* prev = NULL;
    int count = 1;
    //逢m删除当前节点
    while(pcur->next != pcur)
    {
       if(count == m)
       {
        //删除当前节点
        prev->next = pcur->next;
        free(pcur);
        pcur = prev->next;
        count = 1;

       }else{
        prev = pcur;
        pcur = pcur->next;
        count++;
       }
    }
    //此时，节点便是唯一幸存下来的
    return pcur->val;
}

6. 单链表相关经典算法 QJ题：分割链表

题目路径（点击练习）

题目

在这里插入图片描述

思路

定义两个链表：大链表和小链表，遍历原来的节点将其放入对应的新链表中，最后将大链表和小链表的首尾相连

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x){
    //小链表
    ListNode* lessHead,*lessTail;
    lessHead = lessTail = (ListNode*)malloc(sizeof(ListNode));//创建哨兵位

    //大链表
    ListNode* greaterHead,*greaterTail;
    greaterHead = greaterTail = (ListNode*)malloc(sizeof(ListNode));//创建哨兵位

    ListNode* pcur = head;

    while(pcur)
    {
        if(pcur->val < x)
        {
            lessTail->next = pcur;
            lessTail = lessTail->next;
        }else{
            greaterTail->next = pcur;
            greaterTail = greaterTail->next;
        }
        pcur = pcur->next;
    }
    
    greaterTail->next = NULL;
    lessTail->next = greaterHead->next;

    ListNode* ret = lessHead->next;
    free(lessHead);
    free(greaterHead);
    return ret;
}
凡人多烦事~
关注
  • 23
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JavaScript数据结构与算法之链表
10-22
链表就是线性表中针对顺序存储结构的一种优化手段，但是在javascript语言中由于数组的特殊性（自动更新引用位置），所以我们可以采用对象的方式做链表存储的结构
数据结构的双链表算法
09-27
数据结构的双链表算法：双链表基本运算插入前插入后，循环双链表的基本运算。用C++语言写的控制台程序。
软考中级软件设计师--13.数据结构与算法
mjzhang1993的博客
10-19 802
软考--数据结构与算法
C/C++数据结构课程设计安排
程序设计
10-31 4725
数据结构课程设计安排课程设计学时：32学时课程设计目的：综合应用数据结构课程中所学的数据结构：线性表、栈、队列、数组、广义表、树、二叉树、图、查找表中的一种或多种数据结构完成一个较大问题的求解（其实这里的问题也并不太大，所用的数据结构可能是其中的多个，也可能是其中的一个两个）。从而培养学生综合应用基本数据结构分析、解决实际问题的能力，并进一步加深对所学知识的理解和掌握。课程设计要求：1、课程设计以组为单位开展，每组2~4名同学，自由组合，确定组长一名。
数据结构学习笔记 1-1链表概述及LeetCode真题图解（Java）
2401_84411018的博客
04-19 673
机会是留给有准备的人，大家在求职之前应该要明确自己的态度，熟悉求职流程，做好充分的准备，把一些可预见的事情做好。对于应届毕业生来说，校招更适合你们，因为绝大部分都不会有工作经验，企业也不会有工作经验的需求。同时，你也不需要伪造高大上的实战经验，以此让自己的简历能够脱颖而出，反倒会让面试官有所怀疑。你在大学时期应该明确自己的发展方向，如果你在大一就确定你以后想成为Java工程师，那就不要花太多的时间去学习其他的技术语言，高数之类的，不如好好想着如何夯实Java基础。请转发本文支持一下。
数据结构学习笔记 1-1链表概述及LeetCode真题图解（Java）(2)
2401_84023482的博客
05-03 857
对于面试还是要好好准备的，尤其是有些问题还是很容易挖坑的，例如你为什么离开现在的公司（你当然不应该抱怨现在的公司有哪些不好的地方，更多的应该表明自己想要寻找更好的发展机会，自己的一些现实因素，比如对于我而言是现在应聘的公司离自己的家更近，又或者是自己工作到达了迷茫期，想跳出迷茫期等等）Java面试精选题、架构实战文档你的支持，我的动力；祝各位前程似锦，offer不断！
数据结构学习笔记 1-1链表概述及LeetCode真题图解（Java）(3)
2401_84023482的博客
05-03 782
上述知识点，囊括了目前互联网企业的主流应用技术以及能让你成为“香饽饽”的高级架构知识，每个笔记里面几乎都带有实战内容。很多人担心学了容易忘，这里教你一个方法，那就是重复学习。打个比方，假如你正在学习 spring 注解，突然发现了一个注解@Aspect，不知道干什么用的，你可能会去查看源码或者通过博客学习，花了半小时终于弄懂了，下次又看到@Aspect 了，你有点郁闷了，上次好像在哪哪哪学习，你快速打开网页花了五分钟又学会了。从半小时和五分钟的对比中可以发现多学一次就离真正掌握知识又近了一步。
【记录】算法 - 算法基础c++
Youkirrr_的博客
03-01 234
【代码】算法基础 - c++
数字图像处理：压缩编码
qq_46056318的博客
05-15 3775
数字图像处理：图像压缩编码——霍夫曼编码、算术编码、香农菲诺编码 Java实现
力扣刷题笔记
qq_52806136的博客
12-30 206
记录每天刷题
数据结构实验三 图的操作与实现
GHY
01-29 5883
一、实验目的： 1、领会图的两种主要存储结构和图的基本运算算法设计； 2、领会图的两种遍历算法； 3、领会Prim算法求带权连通图中最小生成树的过程和相关算法设计； 4、掌握深度优先遍历和广度优先遍历算法在图路径搜索问题中的应用； 5、深入掌握图遍历算法在求解实际问题中的应用。 二、使用仪器、器材 微机一台 操作系统：WinXP 编程软件：C/C++编程软件 三、实验内容及原理 填入自己的内容（思路或算法流程图、源代码、说明等） 1、教材P310实验题1：实现图的邻接矩阵和邻接表的存储 编写一个程序grap
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
二叉树专题（有关二叉树的相关学习）
aaa114514aaaa的博客
05-14 1591
有关二叉树的学习，目前已经学习了大概2/5的样子，后面更加有难度的，比如搜索平衡二叉树，红黑树等知识，将在C++学习。
数据结构之树与二叉树
最新发布
paradiso989的博客
05-20 744
本文介绍了数据结构中树与二叉树的基础概念以及实现方式
【数据结构/C语言】深入理解 双向链表
2302_78391795的博客
05-20 735
双向链表是一种常见的数据结构，与单向链表类似，但它允许我们从两个方向遍历链表：向前和向后。每个节点包含三个部分：一个数据元素和两个指针，一个指向链表中的前一个节点，另一个指向链表中的下一个节点。 一般情况下，我们所说的双向链表指的是带头节点，双向，循环链表，以下若无特殊说明，均代表此含义。
【数据结构】单链表逆置（详解）————四种方法
lzh20040919的博客
05-17 407
逆置就是把最后一个数据提到最前面，倒数第二个放到第二个……依次类推，直到第一个到最后一个。由于链表没有下标，所以不能借助下标来实行数据的逆置，要靠空间的转移来完成链表的逆置，这里采用没有头节点的链表来实现逆置。
数据结构之链表
qq_63448996的博客
05-19 459
2.然后，从第二个节点开始，依次将每个节点插入到头节点之后。这样，原来的第二个节点就变成了新的头节点，原来的第三个节点就变成了新的第二个节点，
数据结构与算法约瑟夫环之循环链表
12-03
循环链表是一种特殊的链表，它的最后一个节点指向头节点，形成一个环。约瑟夫环问题是一个经典的问题，它的描述是：n个人围成一圈，从第k个人开始报数，报到m的人出圈，然后从出圈的下一个人开始重新报数，直到所有人出圈。这个问题可以使用循环链表来解决。 具体实现思路如下1. 创建一个单向循环链表，链表中每个节点存储一个人的密码和顺序。 2. 从第k个人开始，依次遍历链表，直到找到第m个人，将该节点从链表中删除。 3. 重复步骤2，直到链表中只剩下一个节点，返回该节点的顺序即可。 以下是Python代码实现： ```python class Node: def __init__(self, password, order): self.password = password self.order = order self.next = None def josephus(n, k, m): # 创建循环链表 head = Node(0, 0) cur = head for i in range(1, n+1): cur.next = Node(i, i) cur = cur.next cur.next = head.next # 从第k个人开始报数，直到找到第m个人并删除 cur = head.next while cur.next != cur: for i in range(k-1): cur = cur.next for i in range(m-1): cur = cur.next print("出列的人的顺序为：", cur.next.order) cur.next = cur.next.next # 返回最后一个节点的顺序 return cur.order # 测试 n = 7 k = 3 m = 4 print("最后一个出列的人的顺序为：", josephus(n, k, m)) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值