JAVA编程题（LeetCode)

1.两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

你可以按任意顺序返回答案。

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

 

2.回文数

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

class Solution {
    public boolean isPalindrome(int x) {
        // 当 x < 0 时，x 不是回文数。如果数字的最后一位是 0，为了使该数字为回文，其第一位数字也应该是 0，只有 0 满足这一属性
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }

        int Number = 0;
        while (x > Number) {
            Number = Number * 10 + x % 10;
            x /= 10;
        }

        // 当数字长度为奇数时，Number/10 去除处于中位的数字。
        return x == Number || x == Number / 10;
    }
}

 

3.杨辉三角

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> ret = new ArrayList<List<Integer>>();
        for (int i = 0; i < numRows; ++i) {
            List<Integer> row = new ArrayList<Integer>();
            for (int j = 0; j <= i; ++j) {
                if (j == 0 || j == i) {   //边界特殊处理
                    row.add(1);
                } else {
                    row.add(ret.get(i - 1).get(j - 1) + ret.get(i - 1).get(j));
                }
            }
            ret.add(row);
        }
        return ret;
    }
}

 

4.整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

注意：假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231,  231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

思路：将整数中每位上的数字进行反转，反转后应先判断得到的数字有没有溢出。当反转后的绝对值大于231时，返回0

 

class Solution {
    public int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            int pop = x % 10;
            x /= 10;
            if (rev > Integer.MAX_VALUE/10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
            if (rev < Integer.MIN_VALUE/10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
            rev = rev * 10 + pop;
        }
        return rev;
    }
}

5.两整数之和

不使用运算符 + 和 - ，计算两整数 a 、b 之和。

思路：题目要求不使用运算符 + 和 -，所以我们要换种方法进行运算，这时我们可以采用位运算的方法进行两整数和的运算。

class Solution {
    public int getSum(int a, int b) {
        while(b != 0){
            int temp = a ^ b;
            b = (a & b) << 1;
            a = temp;
        }
        return a;
    }
}

 

6.检测大写字母

给定一个单词，你需要判断单词的大写使用是否正确。我们定义，在以下情况时，单词的大写用法是正确的：全部字母都是大写，比如"USA"。
单词中所有字母都不是大写，比如"leetcode"。如果单词不只含有一个字母，只有首字母大写， 比如 "Google"。
否则，我们定义这个单词没有正确使用大写字母。

注意: 输入是由大写和小写拉丁字母组成的非空单词。

思路：根据题目要求，可以统计大写的字母数，若大写字母个数为0，或者大写字母个数为字符串长度，说明此时为全大写或者全小写，返回true；首字母大写，大写字母个数为1，说明此时只有首字母大写，返回true。

class Solution {
    public boolean detectCapitalUse(String word) {
        int len = word.length();
        int count = 0;
        for (int i = 0; i < len; i++) {
            char s = word.charAt(i);
            if (s >= 'A' && s <= 'Z') {
                count++;
            }
        }
        return count == len || count == 0
            || (count == 1 && word.charAt(0) >= 'A' && word.charAt(0) <= 'Z');
    }
}

7.斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给你 n ，请计算 F(n) 。
思路：利用递归思想去实现

class Solution {
   public int fib(int n) {
       System.out.println(f(35));
       //迭代O(n)
       System.out.println(fibo_it(35));
   }
   public static int fibo_it(int x) {
       if (x == 1 || x == 2) {
          return 1;
       }
       int a = 1;
       int b = 1;
       int c = 0;
       for (int i = 3; i <= x; i++) {
           c = a + b;
           a = b;
           b = c;
       }
       return c;
    }
    public static int f(int x) {
        if (x == 1 || x == 2) {
           return 1;
        }else {
           return f(x-1) + f(x-2);
        }
    }
}

8.猜数字大小

猜数字游戏的规则如下：

每轮游戏，我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。
如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。
你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有 3 种可能的情况（-1，1 或 0）：

-1：我选出的数字比你猜的数字小 pick < num
1：我选出的数字比你猜的数字大 pick > num
0：我选出的数字和你猜的数字一样。恭喜！你猜对了！pick == num
思路：利用循环的方法

import java.util.Scanner;
public class Solution extends GuessGame {
    public int guessNumber(int n) {
        //先产生一个随机数
        /*Math.random(); 产生一个[0,1)的小数
        (int) [0,1) * 101 = [0,101)
        如果要产生一个[a,b]之间的整数
        [0,1) * 10 = [0,10) + 3 = [0,13)
        [0,1) * (b - a + 1) + a
        */
        int com = (int) (Math.random() * 101);
        //System.out.println(com);
        //让猜的用户输入数字 来判断是否猜中
        Scanner input = new Scanner(System.in);
        while (true) {
        System.out.print("Guss a number:");
        int Guess = input.nextInt();
        if (Guess > res) {
           return -1;
           } else if(Guess < res) {
           return 1;
           } else {
                return 0;
                break;
           }
        }
    }
}

9.编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

思路：

class Solution {
    public void reverseString(char[] s) {
        int n = s.length;
        for (int left = 0, right = n - 1; left < right) {
             ++left;
             --right;
             char tmp = s[left];
             s[left] = s[right];
             s[right] = tmp;
        }
    }
}

10.移动零

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

说明:

必须在原数组上操作，不能拷贝额外的数组。

尽量减少操作次数。

思路：采用双指针做法，让k一直卡着第一个0

import java.util.*;
class Solution {
    public void moveZeroes(int[] nums) {
        int k = 0;
        int temp = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) { 
               //进行交换
                temp = nums[i];
                nums[i] = nums[k];
                nums[k] = temp;
                k++;
            }
        }
    }
}

11.将数组分成和相等的三部分

给你一个整数数组 A，只有可以将其划分为三个和相等的非空部分时才返回 true，否则返回 false。

形式上，如果可以找出索引 i+1 < j 且满足 A[0] + A[1] + ... + A[i] == A[i+1] + A[i+2] + ... + A[j-1] == A[j] + A[j-1] + ... + A[A.length - 1] 就可以将数组三等分。

class Solution {
    public boolean canThreePartsEqualSum(int[] arr) {
        int sum = 0;
        for (int num : arr) {
            sum += num;
        }
        int key = sum / 3;
        int group = 0;
        for (int i = 0; i < arr.length; i++) {
            key -= arr[i];
            if (key == 0) {
               group++;
               key = sum / 3;
            }
        }
        return group == 3 || sum == 0 && group >= 3;
   }
}

12.按奇偶排序数组

给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。

你可以返回满足此条件的任何数组作为答案。

import java.util.*;
class Solution {
    public int[] sortArrayByParity(int[] A) {
        int l = 0;
        int r = A.length - 1;
        while (l < r) {
              //左奇右偶
              if (A[l] % 2 == 1 && A[r] % 2 == 0) {
                 int temp = A[l];
                 A[l] = A[r];
                 A[r] = temp;
                 //左偶右奇
                 } else if (A[l] % 2 == 0 && A[r] % 2 == 1) {
                     l++;
                     r--;
                 //左奇右奇
                 } else if (A[l] % 2 == 1 && A[r] % 2 == 1) {
                     r--;
                 } else {
                     l++;
              }
       }
       return A;
   }
}

13.加一

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

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

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

思路：除 99 之外的数字加一；数字 99。加一得十进一位个位数为 00 加法运算如不出现进位就运算结束了且进位只会是一。所以只需要判断有没有进位并模拟出它的进位方式，如十位数加 11 个位数置为 00，如此循环直到判断没有再进位就退出循环返回结果。然后还有一些特殊情况就是当出现 9999、999999 之类的数字时，循环到最后也需要进位，出现这种情况时需要手动将它进一位。此题可采用数组方法去解决。

import java.util.*;
class Solution{
    public int[] plusOne(int[] digits){
        int carry=1;//最开始的进位给个位加
        for(int i=digits.length-1;i>=0;i--){
           intnum=digits[i]+carry;
           digits[i]=num%10;
           carry=num/10;
           if(carry==0){
             break;
           }
        }
        if(carry==1){
          int[]arr=newint[digits.length+1];
          arr[0]=1;
          return arr;
        }
        return digits;
    }
}

14.多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

思路：利用插入排序解决，在排序后中间的位置一定为众数。

import java.util.*;
class Solution{
    public int majorityElement(int[] nums){
        //插入排序
        for(int i=0;i<nums.length;i++){
           int e=nums[i];
           int j=0;
           for(j=i;j>0&&nums[j- 1]>e;j--){
              nums[j]=nums[j- 1];
           }
           nums[j]=e;
        }
        return nums[nums.length/2];
     }
}

15.寻找数组的中心索引

给你一个整数数组 nums，请编写一个能够返回数组 “中心索引” 的方法。

数组 中心索引 是数组的一个索引，其左侧所有元素相加的和等于右侧所有元素相加的和。

如果数组不存在中心索引，返回 -1 。如果数组有多个中心索引，应该返回最靠近左边的那一个。

注意：中心索引可能出现在数组的两端。

思路：如果左边的总数=左边的总数，则它为数组的中心索引。

class Solution{
    public int pivotIndex(int[] nums){
        int sum=0;
        for(int num:nums){
           sum+=num;
        }
        int leftSum=0;
        int rightSum=0;
        for (int i=0;i<nums.length;i++){
            if (i==0){
               leftSum = 0;
            }else{
               leftSum += nums[i - 1];
            }
            rightSum=sum-leftSum-nums[i];
            if(rightSum==leftSum){
              return i;
            }
        }
        return -1;
    }
}