前言

递归

一、两数相加

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头

class Solution {
   
        public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
            ListNode pre = new ListNode(0);
            ListNode cur =pre;
            int carry=0;
            while (l1!=null||l2!=null){
                int x =l1==null? 0:l1.val;
                int y =l2==null? 0:l2.val;
                int sum =x+y+carry;
                carry =sum/10;
                sum = sum%10;
                cur.next=new ListNode(sum);
                cur=cur.next;
                if(l1!=null){
                    l1=l1.next;
                }
                if(l2!=null){
                    l2=l2.next;
                }
            }
            if(carry==1){
                cur.next=new ListNode(1);
            }
            return pre.next;




}
}

二、合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

class Solution {

        public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
            ListNode pre = new ListNode(0);
            ListNode cur =pre;
            while (l1!=null&&l2!=null){
                if(l1.val<l2.val){
                    cur.next=l1;
                    l1=l1.next;
                }else {
                    cur.next=l2;
                    l2=l2.next;
                }
                cur=cur.next;

            }
            cur.next=l1==null?l2:l1;
            return pre.next;





}
}

三、Pow（x，n）

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。

class Solution {
    public double myPow(double x, int n) {
        long N =n;
        if(N>=0){
           return pow(x,N); 
        }else{
          return 1.0/pow(x,-N);  
        }
        

    }
    public double pow(double x,Long n){
        if(n==0){
            return 1.0;
        }
     
        double y=pow(x,n/2);
        return n%2==0? y*y:y*y*x;
    }
}

四、反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }



        ListNode cur=reverseList(head.next);
        head.next.next=head;
        head.next=null;



        return cur;
    }




}

五、回文链表

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

class Solution {
    ListNode tmp;
  public boolean isPalindrome(ListNode head) {
       tmp=head;
      return check(head);
   

}
    private boolean check(ListNode head){
        if(head==null){
            return true;
        }
        boolean res=check(head.next)&&(tmp.val==head.val);
        tmp=tmp.next;
        return res;
    }
}

六、3的幂

给定一个整数，写一个函数来判断它是否是 3 的幂次方。如果是，返回 true ；否则，返回 false 。
整数 n 是 3 的幂次方需满足：存在整数 x 使得 n == 3x

class Solution {
    public boolean isPowerOfThree(int n) {
        if(n==1){
            return true;
        }
        if(n==0){
            return false;
        }
        if(n%3!=0){
            return false;
        }
        return isPowerOfThree(n/3);

    }

七、反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

class Solution {
    public void reverseString(char[] s) {
        int a=0;
        int b =s.length-1;
        while(a<b){
            char tmp = s[a];
            s[a]=s[b];
            s[b]=tmp;
            a++;
            b--;
        }

        

    }
}