leetcode每日一练

最新推荐文章于 2022-04-09 15:08:04 发布

失忆机器

最新推荐文章于 2022-04-09 15:08:04 发布

阅读量312

点赞数

分类专栏：数据结构与算法文章标签： java 算法数据结构 leetcode 算法笔记

本文链接：https://blog.csdn.net/weixin_44196561/article/details/123765527

版权

数据结构与算法专栏收录该内容

101 篇文章 1 订阅

订阅专栏

167. 两数之和 II - 输入有序数组

344. 反转字符串

557. 反转字符串中的单词 III

876. 链表的中间结点

704. 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

 public int search(int[] nums, int target) {
            int begin = 0;
            int end = nums.length-1;
        while(begin <= end){
            int mid =  begin + ((end - begin)>>1);
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] > target){
                    end = mid -1;
                }else{
                    begin = mid + 1;     
                }
            }
            return -1;
            }

278. 第一个错误的版本

假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
       int left = 1;
       int right = n;
       while(left < right){
        int mid = left + ((right-left)>>1);
        if(isBadVersion(mid)){
            right = mid;
        }else{
            left = mid + 1;
        }
       }
       //while 完了，left和right在相同位置。
       return left;
        }
    }

35. 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法。

//即找大于等于target的第一个位置 
public int searchInsert(int[] nums, int target) {
            int left = 0;
            int right = nums.length - 1;
            while(left <= right){
                int mid = left + (right - left)/2;
                if(nums[mid] == target){
                    return mid;
                }else{
                    if(nums[mid] > target){
                        right = mid - 1;
                    }else{
                        left = mid + 1;
                    }
                }
    }
     return left;
}

977. 有序数组的平方

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

//双指针 
public int[] sortedSquares(int[] nums) {
            int left = 0;
            int right = nums.length - 1;
            int[] res = new int[nums.length];
            for(int i = res.length-1;i >= 0;i--){
                if(nums[left]*nums[left] >= nums[right]*nums[right]){
                    res[i] = nums[left]*nums[left];
                    left++;
                }else{
                     res[i] = nums[right]*nums[right];
                     right--;
                }
            }
            return res;
    }

189. 轮转数组

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]

public void rotate(int[] nums, int k) {
            int len = nums.length;
            if(k > len){
                k=k%len;
            }
            int[] newArr = new int[nums.length];
            if(len == 1){
                return;
            }
            int j = 0;
            for(int i = nums.length - k; i < nums.length; i++){
                newArr[j] = nums[i];
                j++;
            }
            for(int i = 0; i < nums.length-k; i++){
                newArr[j] = nums[i];
                j++;
            }
            for (int i = 0;i < newArr.length; i++){
                nums[i] = newArr[i];
       }
    }

283. 移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。请注意，必须在不复制数组的情况下原地对数组进行操作。

public void moveZeroes(int[] nums) {
        int left = 0;
        int right = 0;
        while(right < nums.length){
            if(nums[right] != 0){
                swap(nums,left,right);
                left++;
            }
            right++;
    }
    }
    public void swap(int[] arr,int a,int b){
        int tep = arr[a];
        arr[a] = arr[b];
        arr[b] = tep;
    }

167. 两数之和 II - 输入有序数组

给你一个下标从 1 开始的整数数组 numbers ，该数组已按非递减顺序排列，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。你所设计的解决方案必须只使用常量级的额外空间。

//双指针
public int[] twoSum(int[] numbers, int target) {
           int low = 0;
           int high = numbers.length - 1;
        while(low < high){
            int res = numbers[low] + numbers[high];
            if(res == target){
                return new int[]{low+1,high+1};
            }else if(res > target){
                high--;
            }else{
                low++;
            }
        }
    return new int[]{-1,-1};
}

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

 public void reverseString(char[] s) {
            int left = 0;
            int right = s.length-1;
            while(left < right){
                swap(s,left,right);
                left++;
                right--;
            }
    }
    public void swap(char[] s,int a,int b){
        char tep = s[a];
        s[a] = s[b];
        s[b] = tep;
    }

557. 反转字符串中的单词 III

给定一个字符串 s ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

输入：s = "Let's take LeetCode contest"
输出："s'teL ekat edoCteeL tsetnoc"

 public String reverseWords1(String s) {
             StringBuffer ret = new StringBuffer();
        int length = s.length();
        int i = 0;
        while (i < length) {
            int start = i;
            while (i < length && s.charAt(i) != ' ') {
                i++;
            }
            for (int p = start; p < i; p++) {
                ret.append(s.charAt(start + i - 1 - p));
            }
            while (i < length && s.charAt(i) == ' ') {
                i++;
                ret.append(' ');
            }
        }
        return ret.toString();
    }


  public String reverseWords2(String s) {
             String res = "";
            String[] arrS = s.split(" ");
            for(int i = 0; i < arrS.length; i++){
                char[] chars = arrS[i].toCharArray();
                reverseString(chars);
               arrS[i] = String.valueOf(chars);
              if(i == arrS.length-1){
                  res= res + arrS[i];
              }else{
               res= res + arrS[i] + " ";
                }
            }
            return res;             
    }
    public void reverseString(char[] s) {
        int left = 0;
        int right = s.length-1;
        while (left < right){
            swap(s,left,right);
            left++;
            right--;
        }
    }
    public void swap(char[] s,int a,int b){
        char tep = s[a];
        s[a] = s[b];
        s[b] = tep;
    }

876. 链表的中间结点

给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

//双指针
 public ListNode middleNode(ListNode head) {
           ListNode slow = head;
           ListNode fast = head;
           while(fast != null && fast.next != null){
               slow = slow.next;
               fast = fast.next.next;
           }
           return slow;
    }