力扣(LeetCode)题解------简单
1、两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
public int[] twoSum(int[] nums, int target) {
int[] re = new int[2];
Map map = new HashMap<>();
for (int i=0; i 7、整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
public int reverse(int x) {
//定义为int会溢出
double result = 0;
if (x >= 0 && x < 10) {
return x;
}
if (x < 0) {
x = -x;
while (x > 0) {
int y = x % 10;
result = result * 10 + y;
x = x / 10;
}
result = -result;
if (result < -Math.pow(2, 31) || result > Math.pow(2, 31) - 1) {
result = 0;
}
return (int) result;
}
while (x > 0) {
int y = x % 10;
result = result * 10 + y;
x = x / 10;
}
if (result < -Math.pow(2, 31) || result > Math.pow(2, 31) - 1) {
result = 0;
}
return (int) result;
}
9、回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
public boolean isPalindrome(int x) {
int tem = x;
if (x<0) {
return false;
}
int re = 0;
while (x>0) {
int y = x % 10;
re = re * 10 + y;
x = x/10;
}
// x的值已经改变了
// if (re == x) {
// return true;
// }
if (re == tem) {
return true;
}
return false;
}
20、有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合
public boolean isValid(String s) {
Stack stack = new Stack();
char[] chars = s.toCharArray();
for (int i=0; i21、合并两个有序链表
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode newList = new ListNode(0);
ListNode cur = newList;
while (l1 != null && l2 != null) {
if (l1.val < l2.val) {
cur.next = l1;
cur = cur.next;
l1 = l1.next;
}else {
cur.next = l2;
cur = cur.next;
l2 = l2.next;
}
}
if (l1 == null) {
cur.next = l2;
}else {
cur.next = l1;
}
return newList.next;
}
26、 删除排序数组中的重复项
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
public int removeDuplicates(int[] nums) {
int len = nums.length;
//倒数第二个 会和倒数第一个进行比较 故倒数第一个不需要遍历了
for (int i=0; i26、官方解（牛逼 没想到）
/**
* i指向不重复的最后一个元素
* 如果重复 j去看下一个 i不动
* 如果重复 i增加 将j放到i的位置
* 直到j遍历所有元素
* @param nums
* @return
*/
private int re(int[] nums) {
if (nums.length == 0) {
return 0;
}
int i = 0;
for (int j = 1; j < nums.length; j++) {
if (nums[j] != nums[i]) {
i++;
nums[i] = nums[j];
}
}
return i + 1;
}
27、移动元素
给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
public int removeElement(int[] nums, int val) {
if (nums.length == 0) {
return 0;
}
int i=0;
for (int j=0; j35、搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
/**
* 二分查找
* 或者遍历一遍即可
* @author zhangchunguang
* 2019/3/13 下午3:47
*/
public int searchInsert(int[] nums, int target) {
int l=0;
int h = nums.length-1;
while (l <= h){
int m = (l + h) / 2;
if (target == nums[m]) {
return m;
}
if (target < nums[m]) {
h = m - 1;
}
if (target > nums[m]) {
l = m + 1;
}
}
if (target < nums[0]){
return 0;
}
if (target > nums[l-1]){
return l ;
}else if (target < nums[l-1]){
return l - 1;
}
return -1;
}
53、最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
public int maxSubArray(int[] nums) {
int sum = 0;
int res = Integer.MIN_VALUE;
for (int i=0; i 0) {
sum += nums[i];
}else {
sum = nums[i];
}
res = Math.max(sum,res);
}
return res;
}
58、最后一个单词的长度
给定一个仅包含大小写字母和空格 ’ ’ 的字符串，返回其最后一个单词的长度。
如果不存在最后一个单词，请返回 0 。
public int lengthOfLastWord(String s) {
if (s.trim().isEmpty()) {
return 0;
}
String[] strings = s.split(" ");
return strings[strings.length-1].trim().length();
}
66、加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
//(垃圾解法）
public int[] plusOne(int[] digits) {
int[] result = new int[digits.length + 1];
result[digits.length] = digits[digits.length - 1] + 1;
for (int i=digits.length-1; i>0; i--){
result[i] = digits[i-1];
}
for (int i = result.length - 1; i > 0; i--) {
if (result[i] > 9) {
result[i] = 0;
result[i - 1] += 1;
}
}
if (result[0] == 0) {
int index = 0;
for (int i=1; i100、相同的树
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
public boolean isSameTree(TreeNode p, TreeNode q) {
if(p == null && q == null) {
return true;
}
if(p == null || q == null) {
return false;
}
if(p.val != q.val) {
return false;
}
return isSameTree(p.right, q.right) && isSameTree(q.left, p.left);
}
970、强整数
给定两个正整数 x 和 y，如果某一整数等于 x^i + y^j，其中整数 i >= 0 且 j >= 0，那么我们认为该整数是一个强整数。
返回值小于或等于 bound 的所有强整数组成的列表。
你可以按任何顺序返回答案。在你的回答中，每个值最多出现一次。
public List powerfulIntegers(int x, int y, int bound) {
Set set = new HashSet();
// 2的21次方远远大于10的6次方
for (int i=0; i<21; i++) {
for (int j=0; j<21; j++) {
int z = (int)(Math.pow(x,i) + Math.pow(y,j));
//小于等于bound的都可以
if (z <= bound) {
set.add(z);
}
}
}
return new ArrayList(set);
}
976、三角形的最大周长
给定由一些正数（代表长度）组成的数组 A，返回由其中三个长度组成的、面积不为零的三角形的最大周长。
如果不能形成任何面积不为零的三角形，返回 0。
public int largestPerimeter(int[] A) {
int p = 0;
Arrays.sort(A);
//至少需要3条边 所以i至少保留3个
for (int i=A.length-1; i>=2; i--) {
if ((A[i-1] + A[i-2]) > A[i]){
p = A[i-1] + A[i-2] + A[i];
break;
}
}
return p;
}
977、有序数组的平方
给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
public int[] sortedSquares2(int[] A) {
int len = A.length;
int[] result = new int[len];
int j=0;
//j指向第一个非负数
while (j=0 && j=0) {
result[t++] = A[i] * A[i];
i--;
}
//剩余正数
while (j 1002、查找常用字符
给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。
你可以按任意顺序返回答案。
public List commonChars(String[] A) {
List list = new ArrayList();
List> lists = new ArrayList<>();
for (int i=1; i