算法专题[递归-搜索-回溯-1]

递归

一.汉诺塔


汉诺塔

1.思路一:

cpp 复制代码
class Solution {
public:
    void hanota(vector<int>& A, vector<int>& B, vector<int>& C) {
        int n = A.size();
        def(A,B,C,n);
    }
    void def(vector<int>& A, vector<int>& B, vector<int>& C, int n)
    {
        //1.只有一个块的时候:
        if(n==1)
        {
            C.push_back(A.back());
            A.pop_back();
            return;
        }
        //2.两块以上
        def(A,C,B,n-1);
        C.push_back(A.back());
        A.pop_back();
        def(B,A,C,n-1);
    }
};

2.GIF题目解析

二.合并两个有序链表

合并两个有序链表

1.思路一:

cpp 复制代码
//2.合并两个有序链表:

//2-1:冗余版本

//Definition for singly-linked list.
 struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}
      ListNode(int x) : val(x), next(nullptr) {}
      ListNode(int x, ListNode *next) : val(x), next(next) {}
 };
 
 class Solution_2_1 {
 public:
     ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
         //1.特殊情况有一个链表为空返回另一个!
         if (list1 == nullptr)
             return list2;
         if (list2 == nullptr)
             return list1;
         //2.给一个头节点进入递归去进行连接:
         ListNode* head = new ListNode();
         ListNode* cur = head;
         //3.递归
         recursion(list1, list2, cur);
         //4.返回
         return head->next;
     }
     void recursion(ListNode*& list1, ListNode*& list2, ListNode*& cur)
     {
         //1.递归返回条件
         if (list1 == nullptr || list2 == nullptr)
         {
             if (list1 == nullptr && list2 != nullptr)
                 cur->next = list2;
             else if (list1 != nullptr && list2 == nullptr)
                 cur->next = list1;
             return;
         }
         //2.递归移动:
         int val1 = list1->val;
         int val2 = list2->val;

         if (val1 >= val2)
         {
             cur->next = list2;
             cur = cur->next;
             ListNode* next2 = cur->next;
             cur->next = nullptr;

             recursion(list1, next2, cur);
         }
         else
         {
             cur->next = list1;
             cur = cur->next;
             ListNode* next1 = cur->next;
             cur->next = nullptr;

             recursion(next1, list2, cur);
         }

     }
 };


 //2-2:优化版本

 class Solution {
 public:
     ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
         //1.特殊情况有一个链表为空返回另一个!
         if (list1 == nullptr)
             return list2;
         if (list2 == nullptr)
             return list1;

         //2.选择一个作为返回的!
         int val1 = list1->val;
         int val2 = list2->val;

         if (val1 >= val2)
         {
             list2->next = mergeTwoLists(list1, list2->next);
             return list2;

         }
         else
         {
             list1->next = mergeTwoLists(list1->next, list2);
             return list1;
         }

         return nullptr;
     }
 };

2.GIF题目解析

三.反转链表


反转链表

1.思路一:

cpp 复制代码
 //3.反转链表:

 
  //Definition for singly-linked list.
  struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}
      ListNode(int x) : val(x), next(nullptr) {}
      ListNode(int x, ListNode *next) : val(x), next(next) {}
  };
 
  //3-1:复杂版本

  class Solution_3 {
  public:
      ListNode* reverseList(ListNode* head) {
          if (head == nullptr)
              return nullptr;

          ListNode* newhead = nullptr;
          dfs(head, newhead);
          return newhead;
      }
      ListNode*& dfs(ListNode*& head, ListNode*& rehead)
      {
          if (head->next == nullptr)
          {
              rehead = head;
              return head;
          }

          ListNode* prev = dfs(head->next, rehead);
          prev->next = head;
          head->next = nullptr;
          return head;
      }
  };

  //3-2:优化版本

  class Solution {
  public:
      ListNode* reverseList(ListNode* head) {
          if (head == nullptr || head->next == nullptr)
              return head;

          ListNode* newhead = reverseList(head->next);
          head->next->next = head;
          head->next = nullptr;

          return newhead;
      }
  };

2.GIF题目解析

四.两两交换链表中的节点

两两交换链表中的节点

1.思路一:

cpp 复制代码
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        //1.没有节点和只有一个节点
        if(head==nullptr)
            return nullptr;
        if(head->next == nullptr)
            return head;
        
        //2.正常情况:
        ListNode* newnext_r = head->next->next;
        ListNode* newnext_l = head->next;
        head->next->next = head;
        head->next = swapPairs(newnext_r);
        return newnext_l;
    }
};

2.GIF题目解析

五.pow(X,N)-快速幂

pow(X,N)-快速幂

1.思路一:快速幂递归

cpp 复制代码
 //5.pow(x,n)实现

 class Solution_5 {
 public:
     double myPow(double x, int n) {
         //1.特殊情况的处理:n值无穷小的情况!
         //2.在这个地方去处理n的正负带来的影响!
         return n < 0 ? 1.0 / pow(x, -(long long)n) : pow(x, n);
     }
     double pow(double x, long long n)
     {
         if (n == 0)
             return 1;
         double tmp = pow(x, n / 2);
         return (n % 2 == 0 ? tmp * tmp : tmp * tmp * x);
     }
 };
相关推荐
葫三生42 分钟前
如何评价《论三生原理》在科技界的地位?
人工智能·算法·机器学习·数学建模·量子计算
pipip.1 小时前
UDP————套接字socket
linux·网络·c++·网络协议·udp
拓端研究室3 小时前
视频讲解:门槛效应模型Threshold Effect分析数字金融指数与消费结构数据
前端·算法
随缘而动,随遇而安5 小时前
第八十八篇 大数据中的递归算法:从俄罗斯套娃到分布式计算的奇妙之旅
大数据·数据结构·算法
孞㐑¥5 小时前
Linux之Socket 编程 UDP
linux·服务器·c++·经验分享·笔记·网络协议·udp
IT古董5 小时前
【第二章:机器学习与神经网络概述】03.类算法理论与实践-(3)决策树分类器
神经网络·算法·机器学习
水木兰亭8 小时前
数据结构之——树及树的存储
数据结构·c++·学习·算法
Jess079 小时前
插入排序的简单介绍
数据结构·算法·排序算法
老一岁9 小时前
选择排序算法详解
数据结构·算法·排序算法
CoderCodingNo9 小时前
【GESP】C++四级考试大纲知识点梳理, (7) 排序算法基本概念
开发语言·c++·排序算法