12道Leetcode题目让你获得刷题的勇气~（Java语言描述）

最新推荐文章于 2024-03-22 06:09:21 发布
最新推荐文章于 2024-03-22 06:09:21 发布
阅读量620 收藏
点赞数
分类专栏： 算法 文章标签： 算法 leetcode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34058810/article/details/124156922
版权

Algorithm

Tips for beginner:

#include<iostream>
using namespace std;
int main(){
	for(int i = 0; i< 10;i++){ 
		cout << i<<endl;  //输出10个数，0-9 
	} 
	cout << endl;
	for(int i = 0; i <= 10; i++){
		cout << i << endl; // 输出11个数，0-10 
	} 
	return 0;
}

二分查找（前闭后开）

//注意是排过序的数组
class Solution {
    public int search(int[] nums,int target) {
        int left = 0, right = nums.length;
        while(left < right) {
            int mid = left + ((right - left) >> 1);
            if(nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid;
            }
        }
        return -1;
    }
}

Leetcode27 移除元素

//暴力解法C++
class Solution {
public:
    int removeElement(vector<int>& nums,int val) {
        int size = nums.size();
       	for(int i = 0; i< size; i++) {
            if (nums[i] == val) {
                for(int j = i +1 ; j<size; j++) {
                    nums[j - 1] = nums[j];
                }
                i --;
                size--;
            }
        }
        return size;
    }
};

//双指针
class Solution {
    public int removeElement(int[] nums,int val) {
        int fast = 0;
        int slow = 0;
        for(slow = 0; fast <nums.length; fast++) {
            if (nums[fast] != val) {
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }
}

Leetcode209 长度最小的子数组

//暴力解法C++
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum = 0;
        int n = nums.size();
        int result = INT_MAX; //最终的结果
        //如果想得到数组中最小值可以min = INT_MAX  想得到最大值可以max = INT_MIN
        int subLength = 0;
        for(int i = 0; i< n ; i++) {
            sum = 0;
            for(int j = i; j<n;j++) {
                sum += nums[j];
                if(sum >= target) {
                    subLength = j -i +1;
                    result = result < subLength ? result :subLength;
                    break;
                }
            }
        }
        return result == INT_MAX ? 0 : result; //若result没有被赋值 则返回0
    }
};

//滑动窗口法 降n x n -> n
class Solution {
    public int minSubArrayLen(int s,int[] nums) {
        int sum = 0;
        int left = 0;  //滑动窗口的初始位置
        int result = Integer.MAX_VALUE;
        //如果想得到数组中最小值可以min = INT_MAX  想得到最大值可以max = INT_MIN
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= s) {
                result = Math.min(result, right - left + 1);
                sum -=nums[left++]; //不断变更left(子数组的起始长度)
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;//若result没有被赋值 则返回0
    }
}

Leetcode203 移除链表元素

class Solution {
    public ListNode removeElments(ListNode head, int val) {
        if (head == null) return head;
        ListNode dummy = new ListNode(-1,head);
        ListNode pre = dummy;
        ListNode cur = head;
        while (cur != null) {
            if (cur.value = value) {
                pre.next = cur.next;
            } else {
                pre = cur;
            }
            cur = cur.next;
        }
        return dummy.next;
    }
}

Leetcode206 反转链表

//双指针
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next //保存下一个节点
            cur.next = pre;
            
            pre = cur; //更新pre和cur指针
            cur = temp;
        }
        return pre;
    }
}

//递归法
class Solution {
    public ListNode reverseList(ListNode head) {
        return reverse(null, head);
    }
    private ListNode reverse(ListNode pre, ListNode cur) {
        if (cur == null) {
            return pre;
        }
        ListNode temp = null;
        temp = cur.next;
        cur.next = pre;
        return reverse(cur,temp);
    }
}

Leetcode19 删除链表倒数第N节点

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1,head);
        ListNode slow = dummy;
        ListNode fast = dummy;

        while (n-- > 0) {
            fast = fast.next;
        }
        fast = fast.next; //fast 多走一步，让slow指向删除节点的上一个节点
        while ( fast != null ) {
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummy.next;
    }
}

Leetcode142 环形链表II

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (fast == slow) {  //若两个指针相遇则证明有环
                ListNode index1 = fast; //相遇节点
                ListNode index2 = head; //头节点
                while (index1 != index2) {   //相遇节点w
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}

二叉树的定义

public class TreeNode {
    int val;
    TreeNode left,right;
    TreeNode() {}
    TreeNode(int val) {this.val = val;}
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

二叉树的递归遍历

//Leetcode144 preOrder
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root,result);
        return result;
    }
    public void preorder(TreeNode root,List<Integer> result) {
        if (root == null) return;
        result.add(root.val);
        preorder(root.left,result);
        preorder(root.right,result);
    }
}
//inOrder postOrder 类似-> 更改位置即可

二叉树的迭代遍历

//前序遍历 中-左-右  入栈顺序：中-右-左
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) return result;
        Deque<TreeNode> stack = new LinkedList<TreeNode>;
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.right != null) 
                stack.push(node.right);
            if (node.left != null) 
                stack.push(node.left);
        }
    }
}

//中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        if (root == null) return result;
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            result.add(root.val);
            root = root.right;
        }
        return result;
    }
}

//后序遍历：左右中 调整前序中左右为中右左(实际入栈为中左右)，然后result反转为左右中
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        if (root == null) return result;
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        while (!sisEmpty()) {
            TreeNode node = stack.pop();
            result.add(root.val);
            if (node.left != null) {
                stack.push(node.left);
            }
            if (node.right != null) {
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

二叉树前中后序统一迭代法

//中序:左中右    入栈顺序：右中左
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        if (root != null) st.push(root);
        while (!= isEmpty()) {
            TreeNode node = stack.peek();
            if (node != null) {
                stack.pop(); //将该节点弹出，避免重复操作，下面再将右中左添加到栈中
                if (node.right != null) stack.push(node.right);
                stack.push(node);   //添加中节点
                stack.push(null);	//中节点访问过，但是还没有处理，加入空节点作为标记
                
                if (node.left != null) stack.push(node.left);
            } else {
                stack.pop();        //将空节点弹出
                node = stack.peek();
                stack.pop();
                result.add(node.val);
            }
        }
        return result;
            
    }
}

//后序遍历左右中    入栈顺序：中右左
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        if (root != null) st.push(root);
        while (!= isEmpty()) {
            TreeNode node = stack.peek();
            if (node != null) {
                stack.pop(); //将该节点弹出，避免重复操作，下面再将右中左添加到栈中
                stack.push(node);   //添加中节点
                stack.push(null);	//中节点访问过，但是还没有处理，加入空节点作为标记
                if (node.right != null) stack.push(node.right);                 
                if (node.left != null) stack.push(node.left);
            } else {
                stack.pop();        //将空节点弹出
                node = stack.peek();
                stack.pop();
                result.add(node.val);
            }
        }
        return result;          
    }
}
//前序：中左右    入栈：右左中
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        if (root != null) st.push(root);
        while (!= isEmpty()) {
            TreeNode node = stack.peek();
            if (node != null) {
                stack.pop(); //将该节点弹出，避免重复操作，下面再将右中左添加到栈中
                if (node.right != null) stack.push(node.right);                 
                if (node.left != null) stack.push(node.left);
                stack.push(node);   //添加中节点
                stack.push(null);	//中节点访问过，但是还没有处理，加入空节点作为标记
            } else {
                stack.pop();        //将空节点弹出
                node = stack.peek();
                stack.pop();
                result.add(node.val);
            }
        }
        return result;          
    }
}

二叉树的层序遍历

我的方法：队列

Leetcode102
class Solution {
    //
    public List<List<Integer>> levelOrder(TreeNode root) {
        // 外围list 放最后结果
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        // 队列实现一层一层遍历 先进先出
        Queue<TreeNode> que = new LinkedList<>();
        if(root != null)
            que.offer(root);
        while(!que.isEmpty()){
            // 当前队列大小
            int length = que.size();
            // 内层list 放当前层结果
            List<Integer> curList = new ArrayList<>();
            // 将当前层存入curList中 并将其各自孩子结点拉入队列中
            while(length-- > 0){
                // 先进先出弹出队头元素
                TreeNode curNode = que.poll();
                curList.add(curNode.val);
                // 非空孩子结点存入队列
                if(curNode.left != null)
                    que.offer(curNode.left);
                if(curNode.right != null)
                    que.offer(curNode.right);
            }
            // 当前层存入最终结果列表中
            res.add(curList);
        }
        return res;
    }
}

//代码随想录
class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun2(root);
        return resList;
    }
    public void checkFun2(TreeNode node) {
        if (node == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);
        while (! que.isEmpty()) {
            List<Integer> itemList = new ArrayList<Integer>();
            int length = que.size();
            while (length > 0) {
                TreeNode tmpNode = que.poll();
                itemList.add(tmpNode.val);
                if (tmpNode.left != null) que.offer(tmpNode.left);
                if (tmpNode.right != null) que.offer(tmpNode.right);
                length--;
            }
            resList.add(itemList);
        }
    }
}
Leetcode199
class Solution {
   public List<Integer> rightSideView(TreeNode root) {
       List<Integer> res = new ArrayList<Integer>();
       if (root == null) return res;
       
       Queue<TreeNode> que = new LinkedList<>();
       que.offer(root);
       while (! que.isEmpty()) {
           int size = que.size();
           for (int i = 0; i < size; i++) {
               TreeNode node = que.poll();
               if (node.left != null) que.offer(node.left);
               if (node.right != null) que.offer(node.right);
               if (i == size - 1) 
                   res.add(node.val);
           }
       }
       return res;
   }
}
Leetcode226 翻转二叉树
//DFS递归  只有中序不可以
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) return null;
        invertTree(root.left);
        invertTree(root.right);
        swapChildren(root);
        return root;
    }
    public void swapChildren(TreeNode root) {
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

//BFS
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) return null;
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.offer(root);
        while (! deque.isEmpty()) {
            int size = deque.size();
            while (size-- > 0) {
                TreeNode node = deque.poll();
                swap(node);
                if (node.left != null) deque.offer(node.left);
                if (node.right != null) deque.offer(node.right);
            }
        }
        return root;
    }
    public void swap(TreeNode root) {
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

Leetcode9

class Solution {
    public boolean isPalindrome(int x) {
        if (x < 0) return false;
        
        StringBuffer sb = new StringBuffer(String.valueOf(x));
        StringBuffer reverse = sb.reverse();
        if (reverse.toString().equals(String.valueOf(x)))
            return true;        
        return false;
    }
}

前缀和

class NumArray{
    //前缀和数组
    private int[] preSum;
    
	//构造前缀和
    public NumArray(int[] nums) {
        //preSum[0] = 0,便于计算累加和
        preSum = new int[nums.length +1];
        //计算nums的累加和
        for(int i = 1; i< preSum.length;i++) {
            preSum[i] = preSum[i - 1] + nums[i - 1];
        }
    }
    //查询闭区间[left,right]的累加和
    public int sumRange(int left,int right){
        reurn preSum[right +1] - preSum[left];
    }
}

class NumMatrix{
    private int[][] preSum;
    
    pubilc NumMatrix(int[][] matrix){
        int m = matrix.length, n =matrix[0].length;
        if(m ==0 || n ==0) return;
        preSum = new int[m+1][n+1];
        for(int i =1; i<=m;i++){
            preSum[i][j] = preSum[i-1][j]+preSum[i][j-1] +matrix[i-1][j-1] -preSum[i-1][j-1];
        }
    }
}
	public int sumRegion(int x1,int y1,int x2,int y2){
        return preSum[x2+1][y2+1] -preSum[x1][y2+1]-preSum[x2+1][y1] +preSum[x1][y1];
    }
Devinroot
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode题库-Leetcode:LeetCode持续更新刷题中~~~~
06-29
leetcode题库 笔试题：Leetcode周赛等题 剑指offer同步题 LeetCode 题库题
Leetcode Top100题目和答案（Java完整版 面试必备）
热门推荐
lx_lollipop的博客
03-26 8万+
最近忙着准备春招，复习完这个又复习那个。不过还是忙里偷闲，把剑指Offer这66道题目重新刷了一遍，收获还是很大的，下面贴出答案，又不懂的可以给我留言，博主会及时解答。 我的github 准备把春招复习的知识都整理到github上，一边是自己做个总结，一边也能供大家参考 ——leetcode数据库 19道题 ——剑指Offer 66道题 以下摘自leetcode Top100精选题目 文章目录1....
leetcode 数组练习，美团优选面试题java
最新发布
2401_82977171的博客
03-22 797
面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。外链图片转存中…(img-WarXnqMc-1711058950868)]面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。
LeetCode 算法刷题目录 (Java)
代码星辰的博客
01-13 1万+
保存自己的刷题纪录，方便以后复习。
Java力扣热门题目简单部分合集（共23道）
humor2020的博客
04-15 5942
文章目录前言1、两数之和(哈希表，双指针，数组)2、有效的括号（栈，哈希表）3、合并两个有序链表（递归，迭代）4、最大子数组和（动态规划，分治，贪心）5、爬楼梯（迭代，递归，动态规划，数学）6、买卖股票的最佳时间（贪心，双指针，动态规划）7、二叉树的中序遍历（Morris中序遍历，递归，迭代）8、对称二叉树（递归，迭代）9、二叉树的最大深度（BFS，DFS）10、只出现一次的数字（哈希表，异或）11、移动零（双指针）12、多数元素（哈希表，排序，随机化，分治）13、最小栈（栈）14、比特位计数（Brian
面试常考LeetCode题（附Java版题解）
白夜行
04-03 1008
精心搜集近年来各大厂面试常考LeetCode题
LeetCode 算法、数据结构刷题集~~~.zip
01-04
数据采集处理展示相关的源码、工具等
leetcode_java:leetcode刷题（java语言）
04-17
leetcode_java leetcode刷题（java语言）
如何在Intellij中安装LeetCode刷题插件方便Java刷题
08-18
主要介绍了如何在Intellij中安装LeetCode刷题插件方便Java刷题,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
LeetCode-Java:LeetCode刷题记录（Java）
03-07
LeetCode-Java LeetCode刷题记录（Java）
leetcode题库-leetcode-java:用Java实现leetcode题库
06-29
leetcode题库 leetcode-java 用Java实现leetcode题库
leetcode题库-leetcode-java:LeetcodeJava代码
06-29
leetcode题库 leetcode solutions in java 本仓库内包含了java实现的leetcode解法，代码规范，可读性良好，其中的解法思想并不受语言限制。 BFS(Breath First Search) bfs能解决什么样的问题 图遍历中是否可达、最短路径等等。 普通bfs解题框架 一个boolean[] visited数组，记录访问过的位置 两个List，保存要遍历的节点和下次要遍历的节点，Node的值可以按照情况变化，比如可以是数组的index，也可以是一个Point(x,y)对象等 注意这里的List在某些要去重的场景下需要使用Set代替 // 创建需要的数据结构 boolean[] visited = new boolean[length]; List<Integer> prev = new ArrayList(); List<Integer> next = new ArrayList(); // 初始化prev元素 prev.add(firstNode) while (!prev.isEmpty() { for (int nodeIndex : pr
1. 两数之和
Be_nurturing的博客
07-22 518
两数之和 给定一个整数数组 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], tar.
LeetCode编程题汇总（java实现）
qq_45824565的博客
03-14 430
26.删除排序数组中的重复项 java代码： class Solution { public int removeDuplicates(int[] nums) { int a=0; for(int i=1;i<nums.length;i++){ if(nums[a]!=nums[i]) { ...
[LeetCode]128. 最长连续序列（java实现）hashset
cloud的博客
03-17 1148
[LeetCode]128. （java实现）1. 题目2. 读题（需要重点注意的东西）3. 解法4. 可能有帮助的前置习题5. 所用到的数据结构与算法思想6. 总结 1. 题目 2. 读题（需要重点注意的东西） 思路（）： 3. 解法 ---------------------------------------------------解法---------------------------------------------------： 可能存在的问题： 4. 可能有帮助的前置习题 5. 所用
两数相加
weixin_43014149的博客
02-19 565
两数相加 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例 1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例 2： 输入：l1 = [0], l2 = [0] 输出：[0] 示例 3： 输入：l1 = [9,9,9,9,9
LeetCode(周刷5题篇)--[JAVA]
心态的博客
06-11 494
LeetCode(周刷5题篇)--[JAVA]你能多久做完这5题？
520道LeetCode题Java版，帮你备战金九银十，冲大厂
老男孩的架构路
07-31 687
下面就借此机会分享几个用Java语言实现的开源LeetCode题解，也要感谢这些优秀的开源作者们，去字节、美团、BAT等大厂面试，刷LeetCode上的数据结构+算法题可是必修课。这是一本基于Java语言实现的LeetCode题解，格式为PDF，可作为刷题的辅助和参考，方便阅读，也方便打印出来学习。有粉丝留言说，刷题的时候经常会遇到困难，想要找一本答案题解做参考。现在公开出来，供大家下载学习。LeetCode题解答案pdf（基于Java实现）LeetCode精讲视频及课件。...
leetcode刷题 java
10-05
Java是一种常用的编程语言，而LeetCode也提供了Java语言的题目。 如果你想刷LeetCode的Java题目，建议先学习Java的基础知识以及数据结构与算法的基础知识。有了这些基础之后，你可以按照题目的类型进行刷题，这样...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值