LeetCode简单题汇总

 

1.两个数之和

给出一个整数数组，请在数组中找出两个加起来等于目标值的数，

你给出的函数twoSum 需要返回这两个数字的下标（index1，index2），需要满足 index1 小于index2.。注意：下标是从1开始的

假设给出的数组中只存在唯一解

例如：

给出的数组为 {2, 7, 11, 15},目标值为9
输出 ndex1=1, index2=2  (所有的代码在牛客网的LeetCode板块运行)

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        
        int index1 = 0,index2 =0;
        int sum = target;
        
        for(int i = 0; i < nums.length; i++){
            for(int j = i+1; j < nums.length; j++){
                    if (sum == nums[i]+ nums[j]){
                        index1 = i;
                        index2 = j;
                    }
            }
        }
        int [] b ={index1+1,index2+1};
        return b;
    }
}

2.反转整数

将给出的整数x翻转。
例1:x=123，返回321
例2:x=-123，返回-321

你有思考过下面的这些问题么？

如果整数的最后一位是0，那么输出应该是什么？比如10,100
你注意到翻转后的整数可能溢出吗？假设输入是32位整数，则将翻转10000000003就会溢出，你该怎么处理这样的样例？抛出异常？这样做很好，但是如果不允许抛出异常呢？这样的话你必须重新设计函数（比如添加一个额外的参数）。

public class Solution {
       public int reverse(int x) {
        if(x == 0){
            return 0;
        }else if(x < 0){
            String str = String.valueOf(x);
            StringBuffer bf = new StringBuffer(str.substring(1,str.length()));
            String s = new String(bf.reverse());
            return Integer.parseInt("-"+s);
        }else {
            StringBuffer bf = new StringBuffer(String.valueOf(x));
            String s = new String(bf.reverse());
            return Integer.parseInt(s);
        }
    }
}

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

public class Solution {
    //水平
    public String longestCommonPrefix(String[] strs) {
        if(strs == null || strs.length == 0){
            return "";
        }
        int max = strs[0].length() -1;
        for(int i = 1; i < strs.length; i++){
            int s = -1;
            while(s < max && s < strs[i].length()-1){
                if(strs[0].charAt(s+1) == strs[i].charAt(s+1)){
                    s++;
                }else{
                    break;
                }
            }
            if(s == -1){
                return "";
            }
            max = s;
        }
        return strs[0].substring(0,max+1);
    }
}

20.给出一个仅包含字符'(',')','{','}','['和']',的字符串，判断给出的字符串是否是合法的括号序列
括号必须以正确的顺序关闭，"()"和"()[]{}"都是合法的括号序列，但"(]"和"([)]"不合法。

import java.util.*;
public class Solution {
    public boolean isValid(String s) {
        if(s == null || s.length() == 0){
            return false;
        }
        Stack<Character> stack = new Stack<>();
        char [] c = s.toCharArray();
        for(int i = 0; i < s.length(); i++){
            if(c[i] == '('){
                stack.push(')');
            }else if(c[i] == '{'){
                 stack.push('}');
            }else if(c[i] == '['){
                 stack.push(']');
            }else if(stack.empty() || c[i] != stack.pop()){
                return false;
            }
        }
        return stack.empty();
    }
}

21.将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode heap = new ListNode(0);
        ListNode p = heap;
        while(l1 != null && l2 != null){
            if(l1.val <= l2.val){
                p.next = l1;
                l1 = l1.next;
            }else{
                p.next = l2;
                l2 = l2.next;
            }
            p = p.next;
        }
        if(l1 !=null){
            p.next = l1;
        }
        if(l2 != null){
            p.next = l2;
        }
        return heap.next;
    }
}

 26.给定一个已排序的数组，使用就地算法将重复的数字移除，使数组中的每个元素只出现一次，返回新数组的长度。

不能为数组分配额外的空间，你必须使用常熟级空间复杂度的就地算法。

例如，
给定输入数组 A=[1,1,2]，

你给出的函数应该返回length=2，A数组现在是[1,2]。

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

28.实现函数 strStr。

函数声明如下：

char *strStr(char *haystack, char *needle)

返回一个指针，指向needle第一次在haystack中出现的位置，如果needle不是haystack的子串，则返回null。

public class Solution {
    public String strStr(String haystack, String needle) {
        int index = haystack.indexOf(needle);
        if(index < 0){
            return null;
        }else{
            return haystack.substring(index,haystack.length());
        }
    }
}

53.请计算给出的数组（至少含有一个数字）中具有最大和的子数组（子数组要求在原数组中连续）

例如：给出的数组为[−2,1,−3,4,−1,2,1,−5,4],

子数组[−2,1,−3,4,−1,2,1,−5,4],具有最大的和:6.

public class Solution {
    public int maxSubArray(int[] array) {
         if(array.length == 0){
            return 0;
        }
        int sum = 0;
        //不能等于0，存在负数
        int max = array[0];
        for(int i=0; i < array.length; i++){
            if(sum >= 0){
                sum = sum+array[i];
            }else{
                //抛弃,重新计算
                sum = array[i];
            }
            if(sum > max){
                max = sum;
            }
        }
        return max;
    }
}

69.实现函数 int sqrt(int x). 计算并返回x的平方根

public class Solution {
    public int sqrt(int x) {
        return (int)Math.sqrt(x);
    }
}

 70.你在爬楼梯，需要n步才能爬到楼梯顶部

每次你只能向上爬1步或者2步。有多少种方法可以爬到楼梯顶部？

public class Solution {
    public int climbStairs(int n) {
        if( n <= 2 ){
            return n;
        }
        int [] s = new int[n+1];
        s[0] = 0;
        s[1] = 1;
        s[2] = 2;
        for(int i = 3; i < s.length;i++){
            s[i] = s[i-1]+s[i-2];
        }
        return s[n];
    }
}

88.给出两个有序的整数数组A和B，请将数组B合并到数组A中，变成一个有序的数组

注意：可以假设A数组有足够的空间存放B数组的元素，A和B中初始的元素数目分别为m和n

import java.util.*;
public class Solution {
    public void merge(int A[], int m, int B[], int n) {
        int i = m -1, j = n - 1, index = m+n-1;
        while(i >= 0 && j >= 0){
            A[index--] = A[i] >=  B[j] ? A[i--] : B[j--];
        }
        while(j >=0){
            A[index--] = B[j--];
        }
    }
}

104.求给定二叉树的最大深度，

最大深度是指树的根结点到最远叶子结点的最长路径上结点的数量。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.*;
public class Solution {
    public int maxDepth(TreeNode root) {
         if(root == null){
            return 0;
        }
        int count = 0, depth = 0, nextCount = 1;
        
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        
        //将根节点添加到队列中
        queue.add(root);
        
        //第一次循环时队列的长度为1
        while(queue.size()!=0){
            count++;
            //先进先出，取出队列的第一个元素
            TreeNode top = queue.poll();
            //如果根节点的左子树不为空，则将左子树的根节点添加到队列中
            if(top.left!=null){
                queue.add(top.left);
            }
             //如果根节点的右子树不为空，则将右子树的根节点添加到队列中
             if(top.right!=null){
                 queue.add(top.right);
            }
            //当同一层的节点全部添加到队列中时，count与nextCount相等，deph+1
            if(count==nextCount){
                nextCount = queue.size();
                depth++;
                count=0;
            }
        }
        return depth;
    }
}

136.现在有一个整数类型的数组，数组中素只有一个元素只出现一次，其余的元素都出现两次。

注意：你需要给出一个线性时间复杂度的算法，你能在不使用额外内存空间的情况下解决这个问题么？

public class Solution {
    public int singleNumber(int[] A) {
        //思路：两个相同的数异或为0
        //例子:1^2^3^4^4^3^2 = 2^2^3^3^4^4^1 = 1
        int result = A[0];
        for(int i = 1; i < A.length; i++){
            result = result ^ A[i];
        }
        return result;
    }
}