LeetCode简单题(一)

题目一：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

分析：这是一个求数组和的题目，数组求和问题。

方法一：暴力法

1、我们设置两层循环遍历数组，找出数组所有的两数之和可能，将其相加找到目标值

2、将找得到值得索引下标返回，return new int[] {i,j};

3、如果没有所求值，则抛出一个异常，throw new IllegalAugementException("No sum");

class Solution {
    public int[] twoSum(int[] nums, int target) {
        
        
        for(int i=0;i<nums.length;i++)
            for(int j=i+1;j<nums.length;j++)
            {
                if(nums[i]+nums[j]==target)
                {
                    return new int[] {i,j};
                }
            }
        
        throw new IllegalArgumentException("No sum");
    }
}

方法二：哈希表法

1、首先将数组的元素和下标存放在一个哈希表中，因为我们要返回的是下标。

      哈希表定义：Map<Interger,Interger> map=new HashMap<>();

       循环存储数组元素：for(int i=0;i<nums.lengh,i++)  map.put(nums[i],i);

2、循环进行目标值计算，这一步最重要的是设置变量存储要求得值 int com=targer-nums[i]

3、进行判断，if(map.containKey(com)&&map.get(com)!=i)，然后将其返回 return new int[] {i,map.get(com)};

4、抛出异常 throw new IllegalAugementException("No sum");

整体代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        
        Map<Integer,Integer> map=new HashMap();
        
        for(int i=0;i<nums.length;i++)
        {
            map.put(nums[i], i);
        }
        
        for(int i=0;i<nums.length;i++)
        {
            int com=target-nums[i];
            if(map.containsKey(com)&& map.get(com)!=i)
            {
                return new int[] {i,map.get(com)};
            }
        }
        
        throw new IllegalArgumentException("No sum");
    }
}

方法三、一次遍历哈希表

其实遍历和哈希表存储可以循环一次进行，一边遍历，一边将元素插入到哈希表，具体代码如下：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        
        Map<Integer,Integer> map=new HashMap();        
        for(int i=0;i<nums.length;i++)
        {
            int com=target-nums[i];
            if(map.containsKey(com))
            {
                return new int[] {i,map.get(com)};
            }
            map.put(nums[i], i)
        }
        
        throw new IllegalArgumentException("No sum");
    }
}

题目二：

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:输入: 121输出: true

分析：判断回文将整数反转，然后判断反转后的整数和之前的整数是否相同。

1、如果整数小于0或者其余数等于0，则返回false，if(x<0||x%10==0) return false;

2、接下就是整数的反转，当x!=0，m=x%10; result=result*10+m;x=x/10;

完整代码：

class Solution {
    public boolean isPalindrome(int x) {
        
        if(x<0||(x%10==0&&x!=0))
            return false;        
        int s=x;
        int result=0;
        
        while(x!=0)
        {
            int MeResult=x%10;
            result=result*10+MeResult;
            x=x/10;
        }
        if(s==result)
            return true;
        else {
            return false;
        }
    }
 }

题目三：

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

分析：这道题难点在于如何实现进位

1、遍历数组可以从最后一位开始，digit[digit.lenght]++；

2、对上式进行判断，如果其和等于10，选择进位，先将现在这一位赋值为0，将上一位加一；

3、遍历这样的一个循环；

4、如果相加之后小于10，直接返回digit；

5、上面可以实现大部分的测试用例，但对于9,99并不能通过，需要将数组长度加一，并将第一位设置为1，其他默认为0；

具体代码：

class Solution {
    public int[] plusOne(int[] digits) {        
        for(int i=digits.length-1;i>=0;i--)
        {
            digits[i]++;
            digits[i]=digits[i]%10;
            if(digits[i]!=0)
                return digits;
        }        
        digits=new int[digits.length+1];
        digits[0]=1;
        return digits;
    }
}

题目四：

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回  -1。

示例 1：

输入: haystack = "hello", needle = "ll"
输出: 2

方法一：

1、设置两个指针，一个用于指向原始字符串，另一个指向匹配字符串；

2、如果字符值相同，i++，j++；

3、如果字符值不同，j=0,i=i-j+1，对其进行回溯；

4、最后如果j=a2.length，说明匹配成功，将其下标进行返回

5、否则返回-1； 

具体代码：

class Solution {
    public int strStr(String haystack, String needle) {
        
        char[] a1=haystack.toCharArray();
        char[] a2=needle.toCharArray();
        
        int i=0,j=0;
        
        while(i<a1.length&&j<a2.length)
        {
            if(a1[i]==a2[j])
            {
                i++;
                j++;
            }
            else {
                i=i-j+1;
                j=0;
            }
        }
        
        if(j==a2.length)
            return i-j;
        else {
            return -1;
        }
    }
}

方法二：

public int strStr(String haystack, String needle) {
     return haystack.indexOf(needle);
}

题目五：

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"

方法一：

1、这是一道求解所有字符串的公共前缀，而不是子字符串；

2、先比较前两个字符串的公共前缀，得到前缀再与第三个字符串进行比较，逐步进行；

3、将数组第一个元素设置为前缀，prefix=strs[0]；

4、循环接下来数组的其他元素，for(int i=1;i<strs.lenght;i++)；

5、比较前两元素的公共前缀，while(strs[i].indexof(prefix)！=0)，将前缀将前推一位，直到前缀是第一个字符串的子字符；

6、prefix=prefix.substring(0,prefix.lenght)；

7、如果前缀为isempty()，return " "；

具体代码：

class Solution {
    public String longestCommonPrefix(String[] strs) {
        
        if(strs.length==0) return "";        
        String prefix=strs[0];
        
        for(int i=1;i<strs.length;i++)
        {
            while(strs[i].indexOf(prefix)!=0)
            {
                prefix=prefix.substring(0,prefix.length()-1);
                if(prefix.isEmpty()) return "";
            }
        }
        
        return prefix;
    }
}

题目六：

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。

方法一：

1、采用双指针，一个慢指针，一个快指针，快指针循环整个数组；

2、i=0；if(nums[i]!=nums[j]) i++;nums[i]=nums[j]；

具体代码：

class Solution {
    public int removeDuplicates(int[] nums) {
        
        int i=0;
        
        for(int j=1;j<nums.length;j++)
        {
            if(nums[i]!=nums[j])
            {
                i++;
                nums[i]=nums[j];
            }
        }        
        return i+1;        
    }
}

题目7：

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

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

方法1：迭代

1、两个链表的合并，链表是个很奇怪的，不需要设置链表长度，只需要设置一个节点，再设置一个节点指针，将指针指向节点；

2、对指针进行修改其实就是对这个链表进行修改，比较神奇；

3、遍历两个链表，不管遍历哪一个，pre.next=l1，就表示指针发生了变化，指针发生发变化也就是链表发生了变化；

4、最后判断链表是否为空，pre.next=l1==null?l2:l1；

5、返回节点的指针就是整个链表了；

具体代码：

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        
        ListNode result=new ListNode(0);
        ListNode rListNode;
        rListNode=result;
           
        while(l1!=null&&l2!=null)
        {
            if(l1.val<=l2.val)
            {
                rListNode.next=l1;
                l1=l1.next;
            }
            else
            {
                rListNode.next=l2;
                l2=l2.next;
            }
            
            rListNode=rListNode.next;
        }        
        rListNode.next=l1==null?l2:l1;        
        return result.next;
    }
}

方法二：递归

1、先找到递归出口，l1或l2=0；

2、递归实在太简单了；

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        
        if(l1==null)
            return l2;
        else if (l2==null) {
            return l1;
        }
        else if (l1.val<l2.val) {
            l1.next=mergeTwoLists(l1.next, l2);
            return l1;
        }
        else {
            l2.next=mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

题目八：

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

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

示例 1:

输入: [1,3,5,6], 5
输出: 2

分析：

1、通过有序数组查找目标值，就应该想到用二分查找；

2、这是一种思维，具体二分查找的过程，先设定数组首位的索引值和末尾索引值，l=0,r=len，这个长度应该是数组长度加一；

3、进行判断mid=(left+right)/2，nums[mid]==target，这个判断过程比较巧妙；

4、if(nums[mid]<target)，left=mid+1；否则，right=mid；因为mid可能包括了等于target的情况；

5、我们的目标是获取相同值的下标，对于返回left还是right会有所考虑，我们只需要设置循环while(left<right)，这样一定是left=right的时候跳出循环，不管返回那个都一样；

6、在求中间索引mid时，可能存在整数溢出的问题，解决方法是mid=(left+right)>>>1，这样实现无符号右移，得到不溢出结果；

具体代码：

class Solution {
    public int searchInsert(int[] nums, int target) {
       
        int len=nums.length;
        if(len==0)
            return 0;
        int left=0,right=len;
        
        while(left<right)
        {
            int mid=left+right>>>1;
            if(nums[mid]<target)
            {
                left=mid+1;
            }
            else {
                right=mid;
            }
        }
       
        return left;       
    }
}

题目九：

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

方法：

1、这道题思路很奇怪，我们什么时候应舍弃，从下个节点开始遍历是问题的关键；

2、先定义求和sum=0，ans=nums[0]；

3、遍历数组，只要sum>0，就将nums[i]加进去，如果sum<0，从新开始遍历sum=nums[i]；

4、求ans和sum的最大值；

具体代码：

class Solution {
    public int maxSubArray(int[] nums) {
        
        int ans=nums[0];
        int sum=0;
        
        for(int i=0;i<nums.length;i++)
        {
            if(sum>0)
            {
                sum=sum+nums[i];
            }
            else {
                sum=nums[i];
            }
            ans=Math.max(ans, sum);
        }        
        return ans;      
    }
}

题目十：

给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:

初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3

方法一：

1、将一个数组复制到另一个数组中；

2、复制好的数组进行排序；

如何复制数组？ java中给定了一个系统函数：System.arraycopy(要复制的数组，从第几位，目标数组，从第几位，复制几位)；

数组如何排序？ java中Arrays.sort(要排序的数组)；

具体代码：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        
        System.arraycopy(nums2, 0, nums1, m, n);
        Arrays.sort(nums1);
    }
}

方法二：

1、因为要返回num1，先将num1复制到一个数组num1_copy，System.arraycopy(nums1,0,num1_copy,0,m)；

2、设置双指针分别从前到后遍历num1_copy和num2，i,j；为num1也设置一个指针p，用于往后推进；

3、while(i<m&&j<n) num1[p++]=(nums1_copy[i]<nums2[j]) ?nums1_copy[i++]：nums2[j++]；

4、处理两个数组其中一个剩下的元素；

具体代码：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        
        int[] nums1_copy=new int[m];
        System.arraycopy(nums1, 0, nums1_copy, 0, m);
        
        int i=0,j=0,p=0;
        while(i<m&&j<n)
        {
            nums1[p++]=(nums1_copy[i]<nums2[j])? nums1_copy[i++]:nums2[j++];
        }
        
        if(i<m)
            System.arraycopy(nums1_copy, i, nums1, i+j, m+n-i-j);
        if(j<m)
            System.arraycopy(nums2, j, nums1, i+j, m+n-i-j);
    }
}

方法三：

1、同样设置三个指针，但是不需要复制num1；

2、从后往前进行遍历，思想有点巧妙；

具体代码：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        
        int p1=m-1;
        int p2=n-1;
        int p=m+n-1;
        
        while(p1>=0&&p2>=0)
        {
            nums1[p--]=(nums1[p1]<nums2[p2])?nums2[p2--]:nums1[p1--];
        }
        
        System.arraycopy(nums2, 0, num1, 0, p2+1);
    }
}