leedcode精选TOP面试题_数组

已于 2022-09-25 16:42:18 修改
阅读量143 收藏
点赞数
分类专栏： leetcode刷题 文章标签： leedcode
于 2022-08-30 21:06:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42148307/article/details/126611869
版权

1. 两数之和

java解决方法：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] arr = new int[2];
        for(int i = 0; i < nums.length; i++)
        {
            for(int i1 = i + 1; i1 < nums.length; i1++)
            {
                if(nums[i] + nums[i1] == target)
                {
                    arr[0] = i;
                    arr[1] = i1;
                    return arr;
                }
            }
        }
        return arr;
    }
}

 输入：

[2,7,11,15]
9

输出：[0,1]

public class Main {
    public static int[] stringToIntegerArray(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
          return new int[0];
        }
    
        String[] parts = input.split(",");
        int[] output = new int[parts.length];
        for(int index = 0; index < parts.length; index++) {
            String part = parts[index].trim();
            output[index] = Integer.parseInt(part);
        }
        return output;
    }
    
    public static String integerArrayToString(int[] nums, int length) {
        if (length == 0) {
            return "[]";
        }
    
        String result = "";
        for(int index = 0; index < length; index++) {
            int number = nums[index];
            result += Integer.toString(number) + ", ";
        }
        return "[" + result.substring(0, result.length() - 2) + "]";
    }
    
    public static String integerArrayToString(int[] nums) {
        return integerArrayToString(nums, nums.length);
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = in.readLine()) != null) {
            int[] nums = stringToIntegerArray(line);
            line = in.readLine();
            int target = Integer.parseInt(line);
            
            int[] ret = new Solution().twoSum(nums, target);
            
            String out = integerArrayToString(ret);
            
            System.out.print(out);
        }
    }
}

11. 盛水最多的容器

 java解决方法：

class Solution {
    public int maxArea(int[] height) {
        // 每次移动两端的较短的那一条,不可能移动长的那一条,有可能找到更大的.
        int start = 0;
        int end = height.length - 1;
        int maxA = 0;
        while(start < end)
        {
            int s = 0;
            if(height[start] > height[end])
            {
                s = height[end] * (end - start);
                if(s > maxA)
                {
                    maxA = s;
                }
                end--;
            }
            else
            {
                s = height[start] * (end - start);
                if(s > maxA)
                {
                    maxA = s;
                }
                start++;
            }
        }
        return maxA;
    }
}

输入：

[1,8,6,2,5,4,8,3,7]

输出：

49

public class MainClass {
    public static int[] stringToIntegerArray(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
          return new int[0];
        }
    
        String[] parts = input.split(",");
        int[] output = new int[parts.length];
        for(int index = 0; index < parts.length; index++) {
            String part = parts[index].trim();
            output[index] = Integer.parseInt(part);
        }
        return output;
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = in.readLine()) != null) {
            int[] height = stringToIntegerArray(line);
            
            int ret = new Solution().maxArea(height);
            
            String out = String.valueOf(ret);
            
            System.out.print(out);
        }
    }
}

15. 三数之和

java解决方法：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> Li = new ArrayList<List<Integer>>();
        for(int i1 = 0; i1 < nums.length; i1++)
        {
            int start = i1 + 1;
            int end = nums.length - 1;
            while(start < end)
            {
                if(nums[i1] + nums[start] + nums[end] == 0)
                {
                    List<Integer> li = new ArrayList<Integer>();
                    li.add(nums[i1]);
                    li.add(nums[start]);
                    li.add(nums[end]);
                    //不能有重复的三元组
                    Li.add(li);
                    int a = nums[start];
                    int b = nums[end];
                    while(start < nums.length && a == nums[start])
                    {
                        start++;
                    }
                    while(end > start && b == nums[end])
                    {
                        end--;
                    }
                }
                else if(nums[i1] + nums[start] + nums[end] < 0)
                {
                    int a = nums[start];
                    while(start < nums.length && a == nums[start])
                    {
                        start++;
                    }
                }
                else
                {
                    int b = nums[end];
                    while(end > start  && b == nums[end])
                    {
                        end--;
                    }
                }
            }
            int A = nums[i1];
            while(i1 + 1 < nums.length && A == nums[i1 + 1])
            {
                i1++;
            }
        }
        return Li;
    }
}

 输入：[-1,0,1,2,-1,-4]

输出：[[-1,-1,2],[-1,0,1]]

public class MainClass {
    public static int[] stringToIntegerArray(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
          return new int[0];
        }
    
        String[] parts = input.split(",");
        int[] output = new int[parts.length];
        for(int index = 0; index < parts.length; index++) {
            String part = parts[index].trim();
            output[index] = Integer.parseInt(part);
        }
        return output;
    }
    
    public static String integerArrayListToString(List<Integer> nums, int length) {
        if (length == 0) {
            return "[]";
        }
    
        String result = "";
        for(int index = 0; index < length; index++) {
            Integer number = nums.get(index);
            result += Integer.toString(number) + ", ";
        }
        return "[" + result.substring(0, result.length() - 2) + "]";
    }
    
    public static String integerArrayListToString(List<Integer> nums) {
        return integerArrayListToString(nums, nums.size());
    }
    
    public static String int2dListToString(List<List<Integer>> nums) {
        StringBuilder sb = new StringBuilder("[");
        for (List<Integer> list: nums) {
            sb.append(integerArrayListToString(list));
            sb.append(",");
        }
    
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = in.readLine()) != null) {
            int[] nums = stringToIntegerArray(line);
            
            List<List<Integer>> ret = new Solution().threeSum(nums);
            
            String out = int2dListToString(ret);
            
            System.out.print(out);
        }
    }
}

26. 删除有序数组中的重复项

 java解决方法：

class Solution {
    public int removeDuplicates(int[] nums) {
        int i = 0;
        int count = 0;
        while(i < nums.length)
        {
            int a = nums[i];
            nums[count] = a;
            count++;
            while(i < nums.length && a == nums[i])
            {
                i++;
            }
        }
        return count;
    }
}

33. 搜索旋转排序数组

 java解决方法：

import java.io.*;
class Solution {
    public int search(int[] nums, int target) {
        int l = 0;
        int r = nums.length - 1;
        while(l <= r)
        {
            int mid = (l + r) / 2;
            if(nums[mid] == target)
            {
                return mid;
            }
            if(nums[0] > nums[mid])
            {
                if(nums[0] > target && target > nums[mid])
                {
                    l = mid + 1;
                }
                else
                {
                    r = mid - 1;
                }
            }
            else
            {
                if(nums[0] <= target && target < nums[mid])
                {
                    r = mid - 1;
                }
                else
                {
                    l = mid + 1;
                }
            }
        }
        return -1;
    }
}

public class Main{
    public static int[] stringToIntegerArray(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
          return new int[0];
        }
    
        String[] parts = input.split(",");
        int[] output = new int[parts.length];
        for(int index = 0; index < parts.length; index++) {
            String part = parts[index].trim();
            output[index] = Integer.parseInt(part);
        }
        return output;
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = in.readLine()) != null) {
            int[] nums = stringToIntegerArray(line);
            line = in.readLine();
            int target = Integer.parseInt(line);
            
            int ret = new Solution().search(nums, target);
            
            String out = String.valueOf(ret);
            
            System.out.print(out);
        }
    }
}

34.  在排序数组中查找元素的第一个和最后一个位

java解决方法：

import java.io.*;
class Solution {
    public int[] searchRange(int[] nums, int target) {
        int start = 0;
        int end = nums.length - 1;
        int index = -1;
        int[] arr = new int[2];
        while(start <= end)
        {
            int mid = (start + end) / 2;
            if(nums[mid] == target)
            {
                index = mid;
                break;
            }
            else if(nums[mid] > target)
            {
                end = mid - 1;
            }
            else
            {
                start = mid + 1;
            }
        }
        if(index == -1)
        {
            arr[0] = -1;
            arr[1] = -1;
            return arr;
        }
        else
        {
            int index1 = index;
            int index2 = index;
            while(index1 >= 0 && nums[index1] == target)
            {
                index1--;
            }
            while(index2 < nums.length && nums[index2] == target)
            {
                index2++;
            }
            arr[0] = index1 + 1;
            arr[1] = index2 - 1;;
            return arr;
        }
    }
}

public class Main {
    public static int[] stringToIntegerArray(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
          return new int[0];
        }
    
        String[] parts = input.split(",");
        int[] output = new int[parts.length];
        for(int index = 0; index < parts.length; index++) {
            String part = parts[index].trim();
            output[index] = Integer.parseInt(part);
        }
        return output;
    }
    
    public static String integerArrayToString(int[] nums, int length) {
        if (length == 0) {
            return "[]";
        }
    
        String result = "";
        for(int index = 0; index < length; index++) {
            int number = nums[index];
            result += Integer.toString(number) + ", ";
        }
        return "[" + result.substring(0, result.length() - 2) + "]";
    }
    
    public static String integerArrayToString(int[] nums) {
        return integerArrayToString(nums, nums.length);
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = in.readLine()) != null) {
            int[] nums = stringToIntegerArray(line);
            line = in.readLine();
            int target = Integer.parseInt(line);
            
            int[] ret = new Solution().searchRange(nums, target);
            
            String out = integerArrayToString(ret);
            
            System.out.print(out);
        }
    }
}

 输入：

[5,7,7,8,8,10]

8

输出：

[3,4]

36. 有效的数独

判断是否有效有三个条件:

  • 同一个数字在每一行只能出现一次；

  • 同一个数字在每一列只能出现一次；

  • 同一个数字在每一个小九宫格只能出现一次。

java解题方法：

class Solution {
    public boolean isValidSudoku(char[][] board) {
        //row 第一维表示第几行,第二维表示第几个数字
        int[][] row = new int[9][9];
        int[][] col = new int[9][9];
        int[][][] subbox = new int[3][3][9];
        for(int i = 0; i < 9; i++)
        {
            for(int j = 0; j < 9; j++)
            {
                char c = board[i][j];
                if(c != '.')
                {
                    // 第几个数字
                    int n = c - '0' - 1;
                    row[i][n]++;
                    col[j][n]++;
                    subbox[i / 3][j / 3][n]++;
                    if(row[i][n] > 1 || col[j][n] > 1 || subbox[i / 3][j / 3][n] > 1)
                    {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

46. 全排列

 这个题主要采用回溯法。

Java解决方法：

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        // 回溯法
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        int len = nums.length;
        int[] visited = new int[len];
        backtrack(ans,nums,new ArrayList<Integer>(),visited);
        return ans;
    }
    private void backtrack( List<List<Integer>> ans,int[] nums,ArrayList<Integer> tmp,int[] visited)
    {
        if(tmp.size() == nums.length){
            ans.add(new ArrayList<>(tmp));
            return;
        }
        for(int i = 0; i < nums.length; i++)
        {
            if(visited[i] == 1)
            {
                continue;
            }
            else
            {
                tmp.add(nums[i]);
                visited[i] = 1;
                backtrack(ans,nums,tmp,visited);
                // 回溯的关键
                tmp.remove(tmp.size() - 1);
                visited[i] = 0;
            }
        }
    }
}

public class MainClass {
    public static int[] stringToIntegerArray(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
          return new int[0];
        }
    
        String[] parts = input.split(",");
        int[] output = new int[parts.length];
        for(int index = 0; index < parts.length; index++) {
            String part = parts[index].trim();
            output[index] = Integer.parseInt(part);
        }
        return output;
    }
    
    public static String integerArrayListToString(List<Integer> nums, int length) {
        if (length == 0) {
            return "[]";
        }
    
        String result = "";
        for(int index = 0; index < length; index++) {
            Integer number = nums.get(index);
            result += Integer.toString(number) + ", ";
        }
        return "[" + result.substring(0, result.length() - 2) + "]";
    }
    
    public static String integerArrayListToString(List<Integer> nums) {
        return integerArrayListToString(nums, nums.size());
    }
    
    public static String int2dListToString(List<List<Integer>> nums) {
        StringBuilder sb = new StringBuilder("[");
        for (List<Integer> list: nums) {
            sb.append(integerArrayListToString(list));
            sb.append(",");
        }
    
        sb.setCharAt(sb.length() - 1, ']');
        return sb.toString();
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = in.readLine()) != null) {
            int[] nums = stringToIntegerArray(line);
            
            List<List<Integer>> ret = new Solution().permute(nums);
            
            String out = int2dListToString(ret);
            
            System.out.print(out);
        }
    }
}

输入：

[1,2,3]

输出：

[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

身影王座
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCodeTop总结
m0_49507862的博客
10-26 343
链表题 1. 146 LRU缓存机制 题目 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。获取数据 get(key) - 如果关键字 (key) 存在于缓存中，则获取关键字的值（总是正数），否则返回 -1。写入数据 put(key, value) - 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值
LeetCode 精选 TOP 面试题（1）1
08-04
【LeetCode 精选 TOP 面试题（1）】包括了三道经典编程题，分别是“两数之和”、“两数相加”和“无重复字符的最长子串”。下面对这三个问题进行详细解析。 1. **两数之和**： - **思路1：暴力枚举** - 通过两层...
数组刷题总结
weixin_53156322的博客
10-09 128
1.二分法： 例：LeetCode-704 暴力n->二分logn 二分法是算法面试中的常考题，建议通过这道题目，锻炼自己手撕二分的能力 2.双指针法 例：LeetCode-27 移除元素 双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。 3. 滑动窗口 例：LeetCode-209长度最小的子数组 滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)的暴力解法降为O(n)。 4.模拟行为 Lee
【LeetCode题解】46. 全排列
zfeiyu的博客
08-07 145
给定一个没有重复数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 题解： 1、最近做的这几天简直没啥区别，套路都一模一样 2、回溯系列39. 组合总和 40. 组合总和 II class Solution { List<List<Inte...
LeetCode精选TOP面试题（中等篇）【出现率降序】
_zhy_cq
12-20 1504
LeetCodeTOP面试题中前300道中等题目
LeetCode 精选 TOP 面试题
qq_44845332的博客
03-03 233
4. 寻找两个正序数组的中位数 给定两个大小分别为m和n的正序（从小到大）数组nums1和nums2。请你找出并返回这两个正序数组的中位数。 算法的时间复杂度应该为O(log (m+n))。 示例 1： 输入：nums1 = [1,3], nums2 = [2] 输出：2.00000 解释：合并数组 = [1,2,3] ，中位数 2 示例 2： 输入：nums1 = [1,2], nums2 = [3,4] 输出：2.50000 解释：合并数组 = [1,2,3,...
‍ LeetCode 精选 TOP 面试题
qq_36627779的博客
02-08 364
这里是LeetCode 精选TOP面试题，一共145道，但是一部分与LeetCode 热题 HOT 100中的题目重复。因此重复的题目我都会写在我另一篇博客[LeetCode 热题 HOT 100](https://blog.csdn.net/qq_36627779/article/details/128943880)中。
LeetCode 精选 TOP 面试题总结
Love 6's Private Blog
06-09 296
文章目录前引题目博客链接Easy No.1-No.43 前引 因为在刷到贪心算法后面20-30通过率的中档题到 困难题时 我明显的感觉到有些力不从心 于是果断打算这段时间换一下口味 转战到Leetcode LeetCode 精选 TOP 面试题栏里面 故有此专栏博客总结 题目博客链接 Easy No.1-No.43 237. 删除链表中的节点 104. 二叉树的最大深度 344. 反转字符串 108. 将有序数组转换为二叉搜索树 94. 二叉树的中序遍历 ...
LeetCode精选TOP面试题66.加一
whtli的博客
10-22 133
题目描述 给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。 假设除了整数 0 之外，这个整数不会以零开头 example input : {0} output : {1} input : {1,9} output : {2,0} input : {9,9,9} output : {1,0,0,0} 解题思路 思路1 借助大数BigDecimal 先将数组转换为StringBuilder sb 再借助sb生成大
Leetcode热题Hot100+Top面试题-数组
weixin_42127177的博客
10-20 4312
题目： 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。 示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 示例 2： 输入：nums = [3,2,4], target
LeetCode 精选 TOP 面试题（5）1
08-04
本题是关于LeetCode精选的面试题，主要涉及两个知识点：寻找数组中的第k个最大元素和判断数组是否存在重复元素。 1. **寻找数组中的第k个最大元素**： 这个问题可以通过实现一个快速选择算法来解决。快速选择是...
LeetCode 精选 TOP 面试题（2）1
08-04
在LeetCode精选的TOP面试题中，我们经常会遇到各种算法问题。以下是针对题目描述和标签“leetcode”中涉及的一些知识点的详细解释： 1. **旋转图像（48. Rotate Image）** 这个问题涉及到二维数组的旋转操作。题目...
LeetCode 精选 TOP 面试题（6）1
08-04
本题主要涉及了LeetCode中的热门面试题，包括了字符串反转、计数排序、哈希表的应用以及位运算求两整数之和等知识点。下面将逐一进行详细解析。 1. **字符串反转**（344. 反转字符串） - **思路与方法**：双指针...
LeetCode精选TOP面试题108.将有序数组转换为二叉搜索树
02-15
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 将有序数组转换为二叉搜索树的结果肯定是不唯一的，因为存在...
在线图书商城平台，资源由网络分享整理，如有侵权请联系我
07-23
网上书店系统是一个基于Web的应用程序，它允许用户在互联网上浏览、选购图书，并进行在线交易。这个系统通常由几个核心组件组成，包括前端用户界面、后台数据库管理、购物车功能、支付接口以及订单处理模块。下面我们将详细探讨这些知识点。 1. ASP.NET：ASP.NET是由微软开发的一个用于构建动态网站、应用程序和Web服务的框架。它支持多种编程语言，如C#，提供了丰富的功能和工具，简化了Web应用的开发过程。在本系统中，ASP.NET可能用于创建网页交互逻辑，处理用户请求并返回响应。 2. C#：C#是一种面向对象的编程语言，常用于构建Windows桌面应用和Web应用。在这个网上书店系统中，C#可能被用来编写服务器端的业务逻辑代码，处理用户输入，访问数据库，以及与各种服务进行交互。 3. 数据库：数据库是存储网上书店系统所有数据的地方，包括书籍信息（如书名、作者、出版社、价格等）、用户信息、订单详情等。常见的数据库管理系统如MySQL、SQL Server或Oracle可能被用于存储和检索这些数据。开发者需要使用SQL语句来设计和操作数据库，确保数据的一致性和完整性。 4. 系统
html+js制作的网页计算机 可以实现加减乘除等运算
最新发布
07-23
大二下半学期的网页设计课程作业 html+js制作的网页计算机 可以实现加减乘除等运算
王江涛六级：完整齐全 课程+资料（百度网盘链接）
07-23
资料包含：讲义，规划导学，六级核心技巧讲解，水平测试解析，考前点睛，写译预测，高频核心词训练营，等等。
springboot整合MinIO中间件，实现文件便捷管理
07-23
springboot整合MinIO中间件，实现文件便捷管理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

身影王座

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值