leetcode-7月8日的五题
79. 单词搜索
80. 删除排序数组中的重复项 II
81. 搜索旋转排序数组 II
82. 删除排序链表中的重复元素 II
83. 删除排序链表中的重复元素Copy for Markdown
————————————————————————
79. 单词搜索
Difficulty: 中等
给定一个二维网格和一个单词，找出该单词是否存在于网格中。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
示例:
board =
[
['A','B','C','E'],
['S','F','C','S'],
['A','D','E','E']
]
给定 word = "ABCCED", 返回 true
给定 word = "SEE", 返回 true
给定 word = "ABCB", 返回 false
提示：
board和word中只包含大写和小写英文字母。1 <= board.length <= 2001 <= board[i].length <= 2001 <= word.length <= 10^3
Solution：回溯法，先确定一个字符的位置，然后再去寻找剩余相邻的字符
class Solution {
public boolean exist(char[][] board, String word) {
int m = board.length;
if(m <= 0) return false;
int n = board[0].length;
if(n <= 0) return false;
for(int i=0; i<m; i++){
for(int j=0; j<n; j++){
if(board[i][j] == word.charAt(0)){
boolean[][] used = new boolean[m][n];
if(help(board, used, word, i, j, 0))
//以(i,j)开始的位置，找连续的序列
return true;
}
}
}
return false;
}
public boolean help(char[][] board, boolean[][] used, String word, int i, int j, int index){
//System.out.println("i:"+i+",j:"+j+",index:"+index);
if(i<0 || i>=board.length || j<0 || j>=board[0].length || used[i][j])
return false;
if(board[i][j]!=word.charAt(index)){
used[i][j] = false;
return false;
}
//System.out.println(", "+board[i][j]);
if(index==word.length()-1) return true;
used[i][j] = true;
if(help(board, used, word, i-1, j, index+1) ||
help(board, used, word, i, j-1, index+1) ||
help(board, used, word, i+1, j, index+1) ||
help(board, used, word, i, j+1, index+1)){
return true;
}
used[i][j] = false; //回溯
return false;
}
}
80. 删除排序数组中的重复项 II
Difficulty: 中等
给定一个排序数组，你需要在删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定 nums = [1,1,1,2,2,3],
函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,1,2,3,3],
函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。
你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以**“引用”**方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
Solution：用一个计数count表示前面重复字符的个数
class Solution {
public int removeDuplicates(int[] nums) {
int k = 0, count = 1;
for(int i=1; i<nums.length; i++){
if(nums[i] == nums[k]){
if(count >= 2) continue;
else{
k++;
nums[k] = nums[i];
count++;
}
}
else{
k++;
nums[k] = nums[i];
count = 1;
}
}
return k+1;
}
}
81. 搜索旋转排序数组 II
Difficulty: 中等
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。
示例 1:
输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true
示例 2:
输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false
进阶:
- 这是 的延伸题目，本题中的
nums可能包含重复元素。 - 这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？
Solution：1. 因为有重复的元素，分不清楚是左边有序还是右边有序 2. 如果左边有序； 3.如果右边有序；
- 时间复杂度平均：O(logn)
- 最坏情况下 O(n) 就是11111311111，这样的情况，相当于遍历整个数组
class Solution {
public boolean search(int[] nums, int target) {
int len = nums.length;
if(len <= 0) return false;
int low = 0, high = len-1, mid;
while(low <= high){
mid = (high-low)/2 + low;
if(nums[mid] == target)
return true;
//分不清到底是前面有序还是后面有序
else if(nums[low] == nums[mid])
low++;
//如果左边有序
else if(nums[low] < nums[mid]){
//如果target在前半段
if(target >= nums[low] && target <= nums[mid]){
high = mid-1;
}
//否则就去后半段找
else{
low = mid+1;
}
}
//如果右边有序
else{
//如果target在后半段
if(target > nums[mid] && target <= nums[high]){
low = mid+1;
}
//否则就去前半段找
else{
high = mid-1;
}
}
}
return false;
}
}
82. 删除排序链表中的重复元素 II
Difficulty: 中等
给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 _没有重复出现 _的数字。
示例 1:
输入: 1->2->3->3->4->4->5
输出: 1->2->5
示例 2:
输入: 1->1->1->2->3
输出: 2->3
Solution：对头结点的处理
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if(head == null) return head;
// res.next一直指向头结点， cur当前应该保留的结点的最后一个结点
//p表示遍历的结点
ListNode res = new ListNode(-1), cur, p = head;
res.next = head;
cur = res;
while(p != null){
while(p.next != null && p.val == p.next.val){
p = p.next;
}
if(cur.next == p){ //说明没有重复的
cur = cur.next;
}
else{
cur.next = p.next;
}
p = p.next;
}
cur.next = null;
return res.next;
}
}
83. 删除排序链表中的重复元素
Difficulty: 简单
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
示例 1:
输入: 1->1->2
输出: 1->2
示例 2:
输入: 1->1->2->3->3
输出: 1->2->3
Solution：头结点不会变
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if(head == null) return null;
// cur当前应该保留的结点的最后一个结点， p表示遍历的结点
ListNode cur = head, p = head.next;
while(p != null){
if(cur.val != p.val){
cur.next = p;
cur = cur.next;
}
p = p.next;
}
cur.next = null;
return head;
}
}