给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。
如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外,这两个数都不会以 0 开头。
示例:
输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出:7 -> 0 -> 8
原因:342 + 465 = 807
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode result = new ListNode(0);
ListNode cur = result;
ListNode start1 = l1;
ListNode start2 = l2;
int add = 0;
while(start1 != null || start2 != null) {
int x = start1 == null ? 0 : start1.val;
int y = start2 == null ? 0 : start2.val;
int sum = x + y + add;
add = sum / 10;
int val = sum % 10;
cur.next = new ListNode(val);
cur = cur.next;
if(start1 != null) {
start1 = start1.next;
}
if(start2 != null) {
start2 = start2.next;
}
}
if (add > 0) {
cur.next = new ListNode(add);
}
return result.next;
}
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如,数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值,如果数组中存在这个目标值,则返回它的索引,否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1
public int search(int[] nums, int target) {
if(nums == null || nums.length == 0) {
return -1;
}
int x = 0;
int y = nums.length - 1;
if(y == 0) {
return nums[0] == target ? 0 : -1;
}
while(x <= y) {
int mid = (x + y) / 2;
if(nums[mid] == target) {
return mid;
}
if (nums[0] <= nums[mid]) {
if (nums[0] <= target && target < nums[mid]) {
y = mid - 1;
} else {
x = mid + 1;
}
} else {
if (nums[mid] < target && target <= nums[nums.length - 1]) {
x = mid + 1;
} else {
y = mid - 1;
}
}
}
return -1;
}
一个整型数组 nums 里除两个数字之外,其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n),空间复杂度是O(1)。
示例 1:
输入:nums = [4,1,4,6]
输出:[1,6] 或 [6,1]
示例 2:
输入:nums = [1,2,10,4,1,4,3,3]
输出:[2,10] 或 [10,2]
public int[] singleNumbers(int[] nums) {
int result = 0;
for(int i = 0; i < nums.length; i++) {
result ^= nums[i];
}
int index = 0;
while(result > 0) {
if((result & 1) == 1) {
break;
}
index++;
result = result >> 1;
}
int[] resultArray = new int[2];
for(int i : nums) {
if(((i >> index) & 1) == 0 ) {
resultArray[0] ^= i;
} else {
resultArray[1] ^= i;
}
}
return resultArray;
}
给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。
请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。
public int lengthOfLongestSubstring(String s) {
int result = 0;
HashMap<Character, Integer> map = new HashMap<>();
int left = 0;
for(int i = 0; i < s.length(); i++) {
if(map.containsKey(s.charAt(i))) {
left = Math.max(map.get(s.charAt(i)) + 1, left);
}
map.put(s.charAt(i), i);
result = Math.max(result, i - left + 1);
}
return result;
}
给定一个二叉树,判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征:
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
public boolean isValidBST(TreeNode root) {
return validate(root, Long.MIN_VALUE, Long.MAX_VALUE);
}
boolean validate(TreeNode node, long min, long max) {
if(node == null) {
return true;
}
if(node.val <= min || node.val >= max) {
return false;
}
return validate(node.left, min, node.val) && validate(node.right, node.val, max);
}