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;
}
}