每日刷题-＞递归+动态规划&&数值+链表+数组+哈希表

1.两数之和->hashmap

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res=new int[2];
        if(nums.length==0){
            return res;
        }
        Map<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                res[0]=map.get(target-nums[i]);
                res[1]=i;
            }else{
                map.put(nums[i],i);
            }
        }
        return res;
    }
}

*2.数值的整数次方->迭代+递归

题解：

（1）迭代：

class Solution {
    public double myPow(double x, int n) {
        if(x==0) return 0;
        long b=n;
        double res=1.0;
        if(b<0){
            x=1/x;
            b=-b;
        }
        while(b>0){
            if((b&1)==1){
                res*=x;
            }
            x*=x;
            b>>=1;
        }
        return res;
    }
}

（2）递归：

class Solution {
    public double myPow(double x, int n) {
        if(n==0){
            return 1;
        }else if(n<0){
            return 1/(x*myPow(x,-n-1));//直接使用-n进行递归会栈溢出
        }else if(n%2==1){
            return x*myPow(x,n-1);
        }else{
            return myPow(x*x,n/2);
        }
    }
}

3.打印从1到n的最大的n位数

class Solution {
    public int[] printNumbers(int n) {
        int maxNum=(int)Math.pow(10,n)-1;
        int[] res=new int[maxNum];
        for(int i=1;i<=maxNum;i++){
            res[i-1]=i;
        }
        return res;
    }
}

4.删除链表中的节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if(head==null){
            return head;
        }
        if(val==head.val){
            return head.next;
        }

        ListNode cur=head;
        ListNode pre=new ListNode(0);
        pre.next=cur;
        
        while(cur.val!=val){
            cur=cur.next;
            pre=pre.next;
        }

        ListNode next=cur.next;
        pre.next=next;
        return head;
    }
}

5.正则表达式匹配->动归

class Solution {
    HashMap<String,Boolean> memo=new HashMap<>();
    public boolean isMatch(String s, String p) {
        return dp(0,0,s,p);
    }
    public boolean dp(int i,int j,String s, String p){
        if(j==p.length()) return i==s.length();//如果j已经走到了尽头的后面，那么i也应该走到了尽头的后面
        //使用hashmap进行记录，提高效率
        if(memo.containsKey(i+""+j+"")){
            return memo.get(i+""+j+"");
        }
        //当前字符可以正确匹配
        boolean first_match=(i<s.length()) && (p.charAt(j)==s.charAt(i) || p.charAt(j)=='.');
        boolean ans;
        if(j<=p.length()-2 && p.charAt(j+1)=='*'){//如果当前字符的下一个字符是*
        //则当前字符在下一个字符的位置使用0次或者1次，0次时j往后跳两位，1次时i往后跳一位
            ans= dp(i,j+2,s,p) || (first_match && dp(i+1,j,s,p));
        }else{//如果当前字符的下一个字符不是*
            ans= first_match && dp(i+1,j+1,s,p);//则都后移一位继续比较
        }
        memo.put(i+""+j+"",ans);
        return ans;
    }
    
}

6.调整数组顺序使奇数位于偶数前面->双指针

class Solution {
    public int[] exchange(int[] nums) {
        int n=nums.length;
        //1.快慢指针
        // int slow=0,fast=0;
        // while(fast<n){
        //     if((nums[fast]&1)==1){
        //         int temp=nums[slow];
        //         nums[slow]=nums[fast];
        //         nums[fast]=temp;
        //         slow++;
        //     }
        //     fast++;
        // }
        // return nums;
        //2.首尾指针
        int left=0,right=n-1;
        while(left<right){
            //从左到右找到为偶数的位置
           if((nums[left]&1)!=0){
                left++;
                continue;
            }
            //从右往左找到为奇数的位置
            if((nums[right]&1)!=1){
                right--;
                continue;
            }
            int temp=nums[left];
            nums[left]=nums[right];
            nums[right]=temp;
            left++;
            right--;
        }
        return nums;

    }
}