给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode pre = new ListNode(0);
ListNode temp = pre;
int carry = 0;
while (l1 != null || l2 != null) {
int x = 0, y = 0;
if (l1 == null)
x = 0;
else
x = l1.val;
if (l2 == null)
y = 0;
else
y = l2.val;
int sum = x + y + carry;
if (sum >= 10)
carry = 1;
else
carry = 0;
sum = sum % 10;
temp.next = new ListNode(sum);
temp = temp.next;
if (l1 != null)
l1 = l1.next;
if (l2 != null)
l2 = l2.next;
}
if (carry == 1)
temp.next = new ListNode(1);
return pre.next;
}
}
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
示例 1：
输入：s = "()"
输出：true
class Solution {
public boolean isValid(String s) {
char[] sym = new char[100000];
int cur = 0;
for (int i = 0; i < s.length(); i++) {
if (isLeft(s.charAt(i))) {
sym[cur++] = s.charAt(i);
}
if (isRight(s.charAt(i))) {
if (s.charAt(i) == ')') {
if (cur == 0) return false;
if (sym[cur - 1] == '(') {
cur--;
sym[cur] = ' ';
}
else return false;
}
if (s.charAt(i) == ']') {
if (cur == 0) return false;
if (sym[cur - 1] == '[') {
cur--;
sym[cur] = ' ';
}
else return false;
}
if (s.charAt(i) == '}') {
if (cur == 0) return false;
if (sym[cur - 1] == '{') {
cur--;
sym[cur] = ' ';
}
else return false;
}
}
}
if (sym[0] != ' ')
return false;
else return true;
}
public static boolean isLeft(char c) {
if (c == '[' || c == '(' || c == '{')
return true;
else return false;
}
public static boolean isRight(char c) {
if (c == ']' || c == ')' || c == '}')
return true;
else return false;
}
}
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode pre = new ListNode();
ListNode temp = pre;
while (l1 != null || l2 != null) {
if (l1 == null) {
temp.next = new ListNode(l2.val);
l2 = l2.next;
temp = temp.next;
continue;
}
if (l2 == null) {
temp.next = new ListNode(l1.val);
l1 = l1.next;
temp = temp.next;
continue;
}
if (l1.val <= l2.val) {
temp.next = new ListNode(l1.val);
l1 = l1.next;
temp = temp.next;
} else {
temp.next = new ListNode(l2.val);
l2 = l2.next;
temp = temp.next;
}
}
return pre.next;
}
}
给定一个排序数组，你需要在** 原地** 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
class Solution {
public int removeDuplicates(int[] nums) {
int length = 1;
for (int i = 0; i < nums.length; i++) {
if (nums[length - 1] != nums[i]) {
length++;
nums[length - 1] = nums[i];
}
}
return length;
}
}
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
class Solution {
public int removeElement(int[] nums, int val) {
if (nums.length == 0) {
return 0;
}
int first = 0;
for (int i= 0; i < nums.length; i++) {
if (nums[i] != val) {
nums[first++] = nums[i];
}
}
return first;
}
}
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
示例 1:
输入: haystack = "hello", needle = "ll"
输出: 2
class Solution {
public int strStr(String haystack, String needle) {
int x = haystack.length();
int y = needle.length();
if (y == 0)
return 0;
for (int i = 0; i <= x - y; i++) {
for (int j = 0; j < y; j++) {
if (haystack.charAt(i + j) != needle.charAt(j)) {
break;
}
if (j == y - 1) {
return i;
}
}
}
return -1;
}
}
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
class Solution {
public int searchInsert(int[] nums, int target) {
int n = nums.length;
int low = 0;
int high = n - 1;
int ans = n;
while (low <= high) {
int mid = ((high - low) >> 1) + low;
if (target <= nums[mid]) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return ans;
}
}