LeetCode菜鸟笔记

开始刷题，权当做笔记吧:

 

一:

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素

代码:

class Solution {
    public int searchInsert(int[] nums, int target) {
        int result=nums.length;
        for(int i=0;i<nums.length;i++){
            if(nums[i]>=target)
                return i;

        }
        return  result;
        
    }
}

二:

 

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

class Solution {
    public boolean isValid(String s) {
     if(s.length()==0){//字符串长度为0
            return true;
        }
        Stack<Character> stack=new Stack<>();
        Map<Character,Character> map=new HashMap<>();
        map.put('{','}');
        map.put('[',']');
        map.put('(',')');
        stack.clear();
        stack.push(s.charAt(0));
        for(int i=1;i<s.length();i++) {
            //会出现前两个字符抵消出现栈空的现象，压栈
            //为防止出现map.get(stack.peek())为null的现象，添加条件map.get(stack.peek())==null
             if (stack.empty()||map.get(stack.peek())==null||s.charAt(i) != map.get(stack.peek())) {
                stack.push(s.charAt(i));
            } else {
                stack.pop();
            }
        }
        return stack.empty();
    }
}

三：

 给定 num1= [1, 2, 2, 1], nums2 = [2, 2], 返回 [2]

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int arr[]=new int[Math.min(nums1.length,nums2.length)];
        int length=0;
        boolean canSet=true;
        for (int anArr1 : nums1) {
            for (int anArr2 : nums2) {
                if (anArr1 == anArr2) {
                    for (int m = 0; m < length; m++) {
                        if (arr[m] == anArr1) {
                            canSet = false;
                            break;
                        }
                    }
                    if (canSet) {
                        arr[length] = anArr1;
                        length++;
                        System.out.println("length:"+length+"   "+anArr1);
                    }
                    canSet=true;
                }
            }
        }
        int temp[]=new int[length];
        System.arraycopy(arr,0,temp,0,length);
        return temp;        
    }
}

这个方法嘛相对麻烦，但是也不想改了，好吧好吧

四:

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序

class Solution {
    public void moveZeroes(int[] nums) {
        int length=nums.length;
        int n=0;
        int temp=0;
        for(int i=0;i<=length-n-2;i++){
            if(nums[i]==0){
                temp=nums[i];
                for(int j=i+1;j<=length-n-1;j++){
                    nums[j-1]=nums[j];
                }
                nums[length-n-1]=temp;
                n++;
                i--;
            }
            
        }
        
    }
}

 

 

五 leetcode 31

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。

如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

必须原地修改，只允许使用额外常数空间。

以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

算法思想：

譬如给定数列：

1 2 6 4 3 1

从后向前 依次增大 那么当6到2过渡时 数列减小；

那么从后向前寻找第一个大于2的值 即3，然后交换值；得到新的数列为:1 3 6 4 2 1

显然这不是我们想要的结果，而是1 3 1 2 4 6 

仔细观察就会发现，只不过是将新数列元素3后面的值倒转一下；

代码如下:

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int index=nums.size()-1;
        while(index>0){                                                          //从后向前寻找
            if(nums[index]>nums[index-1]){                             //发现过渡两值
                for(int i=nums.size()-1;i>=index;i--){                   //再次从后向前寻找适合值
                    if(nums[i]>nums[index-1]){
                        swap(nums[i],nums[index-1]);                    //交换
                        reverse(nums.begin()+index,nums.end()); //将后面递减的元素倒置一下
                        return;
                    }
                }
            }
            index--;
        }
        reverse(nums.begin(),nums.end());   //假如是递减的数列，那么直接倒转即可
    }
};

LeetCode-781:森林中的兔子

链接：https://leetcode-cn.com/problems/rabbits-in-forest/

算法思路：

使用HashMap，key保存（根据一个回答）推测的个数，value保存相同回答的次数：

当回答为 i 时：

如果当前还未有此回答，则put(i+1,1);

如果当前有此回答，且个数不超过 i+1(设想当三个兔子回答2时候，说明在最少情况下，这三个兔子是一类；当第四个兔子说2时候，就要重新归类了），则修改回答次数；注意考虑回答为0的情况：

int numRabbits(int []answers){
        HashMap<Integer,Integer> record = new HashMap<>();
        int ans = 0;
        for(int i : answers){
            if(i == 0){//为0结果直接加1
                ans++;
            }else if(record.containsKey(i + 1)){
                int times = record.get(i + 1);
                if(times == i){
                    ans += (i + 1);
                    record.remove(i + 1);
                }else{
                    record.put(i + 1, times + 1);
                }
            }else{
                record.put(i + 1,1);
            }
        }
        for(int key : record.keySet()){
            ans += key;
        }
        return ans;
    }

但是这种方法内存占用太大了，刷到了新的方法：

int numRabbits2(int []answers){
        int []record = new int[1000];
        int ans = 0;
        for(int i : answers){
            if(record[i] == 0 || (record[i] % (i + 1) == 0)){
                ans += (i+1);
            }
            record[i]++;
        }
        return ans;

    }