进入LeetCode官方网站，你会看到醒目的Start coding now
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标;
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素;
给定 nums = [2, 7, 11, 15], target = 9;
因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1]
public static int[] twoSum(int[] nums, int target) {
int[] results = new int[2];
for (int i = 0; i <= nums.length - 1; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[i] + nums[j] == target) {
for (int index : nums) {
if (nums[i] == index) {
results[0] = i;
}
if (nums[j] == index) {
results[1] = j;
}
}
}
}
}
return results;
}给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转；
注意:假设我们的环境只能存储得下 32 位的有符号整数，请根据这个假设，如果反转后整数溢出那么就返回 0；
输入: 123；输出: 321；public static int reverseInt(int x) {
boolean isNegative = false;
if (x == 0) {
return 0;
}
if (x < 0) {
isNegative = true;
x = Math.abs(x);
}
String value = String.valueOf(x);
String result = "";
for (int i = value.length() - 1; i >= 0; i--) {
result += String.valueOf(value.charAt(i));
}
try {
if (!isNegative) {
return Integer.valueOf(result);
} else {
return (-Integer.parseInt(result));
}
}catch (NumberFormatException e){
e.printStackTrace();
return 0;
}
}判断一个整数是否是回文数。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121；输出: true
示例 2:
输入: -121；输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10；输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数public static boolean isPalindrome(int x) {
//保存x的值到a,然后对x进行操作
int a = x;
if (x < 0 || x % 10 == 0) {
return false;
}
if (x < 10) {
return true;
}
int t = 0;
while (x > 0) {
t = t * 10 + x % 10;
x /= 10;
}
return t == a;
}罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内//首先建立一个HashMap来映射符号和值，然后对字符串从左到右来，
//如果当前字符代表的值不小于其右边，就加上该值；
//否则就减去该值。以此类推到最左边的数，最终得到的结果即是答案;
public int romanToInt(String s) {
Map<Character, Integer> map = new HashMap<>();
map.put('I', 1);
map.put('V', 5);
map.put('X', 10);
map.put('L', 50);
map.put('C', 100);
map.put('D', 500);
map.put('M', 1000);
int res = 0;
for(int i = 0; i < s.length(); i ++) {
int curVal = map.get(s.charAt(i));
int nextVal = i < s.length() - 1 ? map.get(s.charAt(i + 1)) : 0;
res += curVal < nextVal ? - curVal : curVal;
}
return res;
}14 Longest Common Prefix 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1:
输入: ["flower","flow","flight"]
输出: "fl"
示例 2:
输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。
说明:
所有输入只包含小写字母 a-z public static String longestCommonPrefix(String[] strs) {
if (strs.length == 0) {
return "";
}
String ans = strs[0];
for (int i = 1; i < strs.length; i++) {
int j = 0;
for (; j < ans.length() && j < strs[i].length(); j++) {
if (ans.charAt(j) != strs[i].charAt(j))
break;
}
ans = ans.substring(0, j);
if (ans.equals(""))
return ans;
}
return ans;
}给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: "()"
输出: true
示例 2:
输入: "()[]{}"
输出: true/**
* 业务分析：
* 1、一个元素要么入栈要么消除：入栈的只能是左括号，消除的一定是右括号；
* 2、能全部完成消除，便有效；
* 工程实现：
* 1、一个元素要么是左括号，要第是右括号；你可以基于左括号的先入为主进行编程，也可以基于右括号的假设为前提
* 2、假设这是右括号，那么它必须找到栈里的头元素进行消除，否则便是无效字符串
*/
public static boolean isValid(String s) {
HashMap<Character, Character> map = new HashMap<>();
map.put('(', ')');
map.put('{', '}');
map.put('[', ']');
Stack<Character> stack = new Stack();
for (char in : s.toCharArray()) {
//左括号-map的key直接入栈
if (map.keySet().contains(in)) {
stack.push(in);
continue;
}
//出栈
if (!stack.isEmpty() && in == map.get(stack.pop())) continue;
return false;
}
return stack.isEmpty();
}将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
// 类似归并排序中的合并过程
ListNode dummyHead = new ListNode(0);
ListNode cur = dummyHead;
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 dummyHead.next;
}26 删除排序数组中的重复项
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。public static int removeDuplicates(int[] nums) {
if (nums.length == 0 || nums == null) {
return 0;
}
int a = 0;
for (int i = 1; i < nums.length; i++) {
if (nums[a] != nums[i]) {
nums[++a] = nums[i];
}
}
return a + 1;
}给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例:
给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素public static int removeElement(int[] nums, int val) {
if(nums.length==0||nums==null){
return 0;
}
int saveIndex = 0;
for(int i = 0; i < nums.length; i ++) {
if(nums[i] != val) {
nums[saveIndex++] = nums[i];
}
}
return saveIndex;
}实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串，
在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
public static int strStr(String haystack, String needle) {
if (needle.length() == 0) return 0;
for (int i = 0, j = 0; i < haystack.length(); ) {
if (i + needle.length() > haystack.length()) return -1;
if (haystack.charAt(i + j) != needle.charAt(j)) {
i++;
j = 0;
} else {
j++;
}
if (j == needle.length()) return i;
}
return -1;
}给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。
如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5;输出: 2public static int searchInsert(int[] nums, int target) {
for (int i = 0; i < nums.length; i++) {
if (nums[i] >= target) {
return i;
}
}
return nums.length;
}报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：
1. 1
2. 11
3. 21
4. 1211
5. 111221
1 被读作 "one 1" ("一个一") , 即 11。
11 被读作 "two 1s" ("两个一"）, 即 21。
21 被读作 "one 2", "one 1" （"一个二" , "一个一") , 即 1211。
给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。
注意：整数顺序将表示为一个字符串。
示例 2:
输入: 4;输出: "1211"public String countAndSay(int n) {
String res = "1";
int t;
//n次报数，循环n-1次
for (int i = 1; i < n; i++) {
t = 0;
StringBuilder temp = new StringBuilder();
//对当前res里每个字符进行遍历，t表当前字符下标
while (t < res.length()) {
int num = 1;
//数连续且相同的数有几个，计入num
while ((t + 1) < res.length() && res.charAt(t) == res.charAt(t + 1)) {
t++;
num++;
}
//temp最终为为下一个报数生成的值
temp.append(num).append(res.charAt(t));
t++;
}
//temp赋值res进行下一轮报数
res = temp.toString();
}
return res;
}给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例:
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。public static int maxSubArray(int[] nums) {
if (nums.length == 1) {
return nums[0];
}
int realMax = nums[0];
int currMax = nums[0];
for (int i = 1; i < nums.length; i++) {
if (currMax + nums[i] > nums[i]) {
currMax += nums[i];
} else {
currMax = nums[i];
}
if (currMax > realMax) {
realMax = currMax;
}
}
return realMax;
}给定一个仅包含大小写字母和空格 ' ' 的字符串，返回其最后一个单词的长度。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指由字母组成，但不包含任何空格的字符串。
示例:
输入: "Hello World"
输出: 5public static int lengthOfLastWord(String s) {
String[] strings = s.split(" ");
if (strings.length == 0) {
return 0;
}
return strings[strings.length - 1].length();
}66 Plus One
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1:
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。public static int[] plusOne(int[] digits) {
for (int i = digits.length - 1; i >= 0; i--) {
if (digits[i] != 9) {
digits[i]++;
return digits;
}
digits[i] = 0;
}
//跳出for循环，说明数字全部是9
int[] temp = new int[digits.length + 1];
temp[0] = 1;
return temp;
}67 Add Binary
给定两个二进制字符串，返回他们的和（用二进制表示）。
输入为非空字符串且只包含数字 1 和 0。
示例 1:
输入: a = "11", b = "1";输出: "100"
示例 2:
输入: a = "1010", b = "1011";输出: "10101"public static String addBinary(String a, String b) {
return new BigInteger(a, 2).add(new BigInteger(b, 2)).toString(2);
}69 Sqrt(x) 平方根
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
输入: 4；输出: 2
示例 2:
输入: 8；输出: 2
说明: 8 的平方根是 2.82842...,
由于返回类型是整数，小数部分将被舍去。public static int mySqrt(int x) {
if (x == 1) {
return 1;
}
int min = 0;
int max = x;
while (max - min > 1) {
int m = (max + min) / 2;
if (x / m < m) {
max = m;
} else {
min = m;
}
}
return min;
}假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶public static int climbStairs(int n) {
if (n == 1) {
return 1;
}
int[] dp = new int[n + 1];
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}75 Sort Colors
给定一个包含红色、白色和蓝色，一共 n 个元素的数组，
原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
注意:不能使用代码库中的排序函数来解决这道题。
示例:输入: [2,0,2,1,1,0]；输出: [0,0,1,1,2,2]
public static void sortColors(int[] nums) {
if (nums.length == 0 || nums == null) {
return;
}
ArrayList<Integer> redList = new ArrayList<>();
ArrayList<Integer> whiteList = new ArrayList<>();
ArrayList<Integer> blueList = new ArrayList<>();
for (int colornum : nums) {
if (colornum == 0) {
redList.add(colornum);
} else if (colornum == 1) {
whiteList.add(colornum);
} else {
blueList.add(colornum);
}
}
redList.addAll(whiteList);
redList.addAll(blueList);
int i = 0;
for (int colornum : redList) {
nums[i] = colornum;
i++;
}
}83 Remove Duplicates From Sorted List
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
示例 1:
输入: 1->1->2;输出: 1->2
示例 2:
输入: 1->1->2->3->3;输出: 1->2->3public static ListNode deleteDuplicates(ListNode head) {
ListNode cur = head;
while (cur != null && cur.next != null) {
if (cur.val == cur.next.val) {
cur.next = cur.next.next;
} else {
cur = cur.next;
}
}
return head;
}给定两个有序整数数组 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,2,3,5,6]//先合并后排序
public static void merge(int[] nums1, int m, int[] nums2, int n) {
System.arraycopy(nums2, 0, nums1, m, n);
Arrays.sort(nums1);
}//从后向前遍历比较大小
public void merge(int[] nums1, int m, int[] nums2, int n) {
int i = m - 1;
int j = n - 1;
int k = m + n - 1;
while (i >= 0 && j >= 0) {
if (nums1[i] > nums2[j]) {
nums1[k--] = nums1[i--];
} else {
nums1[k--] = nums2[j--];
}
}
while (j >= 0) {
nums1[k--] = nums2[j--];
}
}100 Same Tree
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例 1:
输入: 1 1
/ \ / \
2 3 2 3
[1,2,3], [1,2,3]
输出: truepublic class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
//递归调用
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.left, q.left) && isSameTree(p.right, q.right);
}
101 对称二叉树
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \
2 2
/ \ / \
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/ \
2 2
\ \
3 3 public static boolean isSymmetric(TreeNode root) {
return isMirror(root, root);
}
/**
* 如果同时满足下面的条件，两个树互为镜像：
* 它们的两个根结点具有相同的值。
* 每个树的右子树都与另一个树的左子树镜像对称
*/
public static boolean isMirror(TreeNode t1, TreeNode t2) {
if (t1 == null && t2 == null) return true;
if (t1 == null || t2 == null) return false;
return (t1.val == t2.val)
&&isMirror(t1.right, t2.left)
&& isMirror(t1.left, t2.right);
}104 二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。//递归
public int maxDepth(TreeNode root) {
if(root == null)return 0;
return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}107 二叉树的层序遍历
给定一个二叉树，返回其节点值自底向上的层次遍历。
即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历；
例如：
给定二叉树 [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其自底向上的层次遍历为：
[
[15,7],
[9,20],
[3]
]public static List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> mylist = new ArrayList<List<Integer>>();
recursiveAddNodeValue(root, mylist, 1);
return mylist;
}
public static void recursiveAddNodeValue(TreeNode node, List<List<Integer>> mylist, int level) {
if (node == null) {
return;
} else {
//这一层的第一个，在list中新建一层
if (level > mylist.size()) {
List<Integer> tempList = new ArrayList<Integer>();
mylist.add(0, tempList);
}
//自己的val值
mylist.get(mylist.size() - level).add(0, node.val);
//递归添加左右邻居
recursiveAddNodeValue(node.right, mylist, level + 1);
recursiveAddNodeValue(node.left, mylist, level + 1);
}
}
231 Power of Two
Given an integer, write a function to determine if it is a power of two.
Example 1:
Input: 1
Output: true
Explanation: 20 = 1//与运算符用符号“&”表示，其使用规律如下：
//两个操作数中位都为1，结果才为1，否则结果为0
//二进制中一旦是2的倍数，必为10，100，1000，10000，100000，...形式（n-1为01,011,0111,0111）
//所以，n&n-1==0恒成立
public static boolean isPowerOfTwo(int n) {
return (n > 0) && ((n & (n - 1)) == 0);
}344. Reverse String
Write a function that reverses a string.
即字符串翻转，类似于reverse功能
The input string is given as an array of characters char[].
Input: ["h","e","l","l","o"],Output: ["o","l","l","e","h"]public static String reverseString(char[] chars) {
if (chars.length == 0) {
return "";
}
StringBuilder builder = new StringBuilder();
for (int i = chars.length - 1; i >= 0; i--) {
builder.append(chars[i]);
}
return builder.toString();
}
不使用运算符 + 和 - ，计算两整数 a 、b 之和。
示例 1:
输入: a = 1, b = 2；输出: 3 public static int getSum(int a, int b) {
int num1 = a;
int num2 = b;
if (num1 == 0 && num2 == 0) {
return 0;
}
if (num1 == 0) {
return num2;
}
if (num2 == 0) {
return num1;
}
if (num1 > 0) {
while (num1 != 0) {
--num1;
++num2;
}
return num2;
}else{
while (num1 != 0){
++num1;
--num2;
}
return num2;
}
}
232 Implement Queue using Stacks
使用栈实现队列的下列操作：
push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。
示例:
MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek(); // 返回 1
queue.pop(); // 返回 1
queue.empty(); // 返回 falsepublic class TwoQueueUsingStacks {
private Stack<Integer> a;// 输入栈
private Stack<Integer> b;// 输出栈
public MyQueue() {
a = new Stack<>();
b = new Stack<>();
}
//将元素x推到队列的后面
public void push(int x) {
a.push(x);
}
//从队列前面删除该元素并返回该元素
public int pop() {
// 如果b栈为空，则将a栈全部弹出并压入b栈中，然后b.pop()
if(b.isEmpty()){
while(!a.isEmpty()){
b.push(a.pop());
}
}
return b.pop();
}
//获取前面的元素
public int peek() {
if(b.isEmpty()){
while(!a.isEmpty()){
b.push(a.pop());
}
}
return b.peek();
}
//判断队列是否为空
public boolean empty() {
return a.isEmpty() && b.isEmpty();
}
}
扫一扫
115
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
