【递归算法】 1.合并两个有序链表（easy）2. 两两交换链表中的节点（medium）3. 快速幂

目录

1. 合并两个有序链表（easy）

2. 两两交换链表中的节点（medium）

3. 快速幂

---

前言

递归
在解决一个规模为n的问题时，如果满足以下条件，我们可以使用递归来解决:
a.问题可以被划分为规模更小的子问题，并且这些子问题具有与原问题相同的解决方法。

b.当我们知道规模更小的子问题(规模为n-1)的解时，我们可以直接计算出规模为n的问题
的解。
c.存在一种简单情况，或者说当问题的规模足够小时，我们可以南接求解问驹一般的递归求解过程如下:
1．验证是否满足简单情况。
2.   假设较小规模的问题已经解决,解决当前问题。上述步骤可以通过数学归纳法来证明。

---

1. 合并两个有序链表（easy）

题目链接： . - 力扣（LeetCode）

算法思路：

1. 递归函数的含义：交给你两个链表的头结点，你帮我把它们合并起来，并且返回合并后的头结点；

2. 函数体：选择两个头结点中较⼩的结点作为最终合并后的头结点，然后将剩下的链表交给递归函数 去处理；

3. 递归出⼝：当某⼀个链表为空的时候，返回另外⼀个链表。

代码实现：

package recursion;

//https://leetcode.cn/problems/merge-two-sorted-lists/
//21. 合并两个有序链表
  class ListNode {
     int val;
      ListNode next;
     ListNode() {}
      ListNode(int val) { this.val = val; }
      ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  }

public class Solution1 {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
      /* //尾插法
       //先设一个头节点然后比较尾插
       ListNode phead = new ListNode();
       ListNode last = phead;
       ListNode cur1 =list1;
       ListNode cur2 =list2;
       while(cur1!=null&&cur2!=null){
           if(cur1.val<cur2.val){
               last.next = cur1;
               cur1 =cur1.next;
           }else
           {
               last.next = cur2;
               cur2 = cur2.next;
           }
           last =last.next;
       }
       if(cur1 ==null){
           last.next = cur2;
       }else if(cur2 ==null){
           last.next =cur1;
       }
       return phead.next; */
     //递归法
      if(list1 == null){
        return list2;
      }
      if(list2 == null){
        return list1;
      }
      
       if(list1.val<list2.val){
        list1.next = mergeTwoLists(list1.next,list2);
        return list1;
       }else{
        list2.next = mergeTwoLists(list1,list2.next);
        return list2;
       }

    }
}

---

2. 两两交换链表中的节点（medium）

题目链接：. - 力扣（LeetCode）

算法思路：

1. 递归函数的含义：交给你⼀个链表，将这个链表两两交换⼀下，然后返回交换后的头结点；

2. 函数体：先去处理⼀下第⼆个结点往后的链表，然后再把当前的两个结点交换⼀下，连接上后⾯处 理后的链表；

3. 递归出⼝：当前结点为空或者当前只有⼀个结点的时候，不⽤交换，直接返回。

代码实现：

package recursion;

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public class Solution2 {
    public ListNode swapPairs(ListNode head) {
// 1. 递归函数的含义：交给你⼀个链表，将这个链表两两交换⼀下，然后返回交换后的头结点；
// 2. 函数体：先去处理⼀下第⼆个结点往后的链表，然后再把当前的两个结点交换⼀下，连接上后⾯处
// 理后的链表；
// 3. 递归出⼝：当前结点为空或者当前只有⼀个结点的时候，不⽤交换，直接返回。
     if(head == null||head.next==null){
        return head;
     }
     ListNode cur1 = head,cur2 = head.next;
     cur1.next = swapPairs(cur2.next);
     cur2.next = cur1;
     return cur2;
    }
}

---

3. 快速幂

题目链接：50. Pow(x, n) - 力扣（LeetCode）

//1．递归函数的含义:求出×的n次方是多少，然后返回;

//2．函数体:先求出×的n / 2次方是多少，然后根据n的奇偶，得出的n 次方是多少;

//3．递归出口:当n为的时候，返回1即可。

package recursion;

public class Solution3 {
    public double myPow(double x, int n) {
//1．递归函数的含义:求出×的n次方是多少，然后返回;
//2．函数体:先求出×的n / 2次方是多少，然后根据n的奇偶，得出的n 次方是多少;
//3．递归出口:当n为的时候，返回1即可。
       return n < 0 ? 1/pow(x,-n):pow(x,n);
    }
    public double pow(double x, int n ){
        if(n == 0) return 1.0;
        double tmp = pow(x, n / 2);
        return n % 2 == 0 ? tmp * tmp : tmp * tmp * x;
    }
}