Merge remote-tracking branch 'origin/master'
# Conflicts: # LeetCode/src/main/java/leetcode/editor/cn/all.json # LeetCode/src/main/java/leetcode/editor/cn/translation.json
This commit is contained in:
huangge1199@hotmail.com
commit
8b1647a240
@ -32,11 +32,13 @@ public class TreeNode {
|
||||
}
|
||||
List<TreeNode> treeNodeList = new ArrayList<>();
|
||||
int index = 0;
|
||||
int size = 0;
|
||||
for (int i = 0; i < list.size(); i++) {
|
||||
if (treeNodeList.size() == 0) {
|
||||
this.val = list.get(i);
|
||||
treeNodeList.add(this);
|
||||
index = 0;
|
||||
size = 1;
|
||||
} else {
|
||||
TreeNode root = treeNodeList.get(index);
|
||||
treeNodeList.remove(index);
|
||||
@ -61,8 +63,9 @@ public class TreeNode {
|
||||
}
|
||||
index++;
|
||||
}
|
||||
if (index == treeNodeList.size()*2) {
|
||||
if (treeNodeList.size() == size * 2) {
|
||||
index = 0;
|
||||
size = treeNodeList.size();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,132 @@
|
||||
//实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
|
||||
//
|
||||
//
|
||||
//
|
||||
// BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出
|
||||
//。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
|
||||
// boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
|
||||
// int next()将指针向右移动，然后返回指针处的数字。
|
||||
//
|
||||
//
|
||||
// 注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例：
|
||||
//
|
||||
//
|
||||
//输入
|
||||
//["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext
|
||||
//", "next", "hasNext"]
|
||||
//[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
|
||||
//输出
|
||||
//[null, 3, 7, true, 9, true, 15, true, 20, false]
|
||||
//
|
||||
//解释
|
||||
//BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
|
||||
//bSTIterator.next(); // 返回 3
|
||||
//bSTIterator.next(); // 返回 7
|
||||
//bSTIterator.hasNext(); // 返回 True
|
||||
//bSTIterator.next(); // 返回 9
|
||||
//bSTIterator.hasNext(); // 返回 True
|
||||
//bSTIterator.next(); // 返回 15
|
||||
//bSTIterator.hasNext(); // 返回 True
|
||||
//bSTIterator.next(); // 返回 20
|
||||
//bSTIterator.hasNext(); // 返回 False
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 树中节点的数目在范围 [1, 105] 内
|
||||
// 0 <= Node.val <= 106
|
||||
// 最多调用 105 次 hasNext 和 next 操作
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 进阶：
|
||||
//
|
||||
//
|
||||
// 你可以设计一个满足下述条件的解决方案吗？next() 和 hasNext() 操作均摊时间复杂度为 O(1) ，并使用 O(h) 内存。其中 h 是树的高
|
||||
//度。
|
||||
//
|
||||
// Related Topics 栈 树 设计
|
||||
// 👍 435 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import com.code.leet.entiy.TreeNode;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
//173:二叉搜索树迭代器
|
||||
public class BinarySearchTreeIterator {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
// Solution solution = new BinarySearchTreeIterator().new Solution();
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* public class TreeNode {
|
||||
* int val;
|
||||
* TreeNode left;
|
||||
* TreeNode right;
|
||||
* TreeNode() {}
|
||||
* TreeNode(int val) { this.val = val; }
|
||||
* TreeNode(int val, TreeNode left, TreeNode right) {
|
||||
* this.val = val;
|
||||
* this.left = left;
|
||||
* this.right = right;
|
||||
* }
|
||||
* }
|
||||
*/
|
||||
class BSTIterator {
|
||||
|
||||
List<TreeNode> list = new ArrayList<>();
|
||||
int i = 0;
|
||||
|
||||
public BSTIterator(TreeNode root) {
|
||||
list = getList(root);
|
||||
}
|
||||
|
||||
private List<TreeNode> getList(TreeNode root) {
|
||||
List<TreeNode> list = new ArrayList<>();
|
||||
if (root == null) {
|
||||
return list;
|
||||
}
|
||||
list.addAll(getList(root.left));
|
||||
list.add(root);
|
||||
list.addAll(getList(root.right));
|
||||
return list;
|
||||
}
|
||||
|
||||
public int next() {
|
||||
int num = list.get(i).val;
|
||||
i++;
|
||||
return num;
|
||||
}
|
||||
|
||||
public boolean hasNext() {
|
||||
return i < list.size();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Your BSTIterator object will be instantiated and called as such:
|
||||
* BSTIterator obj = new BSTIterator(root);
|
||||
* int param_1 = obj.next();
|
||||
* boolean param_2 = obj.hasNext();
|
||||
*/
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,57 @@
|
||||
实现一个二叉搜索树迭代器类<code>BSTIterator</code> ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
|
||||
<div class="original__bRMd">
|
||||
<div>
|
||||
<ul>
|
||||
<li><code>BSTIterator(TreeNode root)</code> 初始化 <code>BSTIterator</code> 类的一个对象。BST 的根节点 <code>root</code> 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。</li>
|
||||
<li><code>boolean hasNext()</code> 如果向指针右侧遍历存在数字，则返回 <code>true</code> ；否则返回 <code>false</code> 。</li>
|
||||
<li><code>int next()</code>将指针向右移动，然后返回指针处的数字。</li>
|
||||
</ul>
|
||||
|
||||
<p>注意，指针初始化为一个不存在于 BST 中的数字，所以对 <code>next()</code> 的首次调用将返回 BST 中的最小元素。</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<p>你可以假设 <code>next()</code> 调用总是有效的，也就是说，当调用 <code>next()</code> 时，BST 的中序遍历中至少存在一个下一个数字。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/25/bst-tree.png" style="width: 189px; height: 178px;" />
|
||||
<pre>
|
||||
<strong>输入</strong>
|
||||
["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
|
||||
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
|
||||
<strong>输出</strong>
|
||||
[null, 3, 7, true, 9, true, 15, true, 20, false]
|
||||
|
||||
<strong>解释</strong>
|
||||
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
|
||||
bSTIterator.next(); // 返回 3
|
||||
bSTIterator.next(); // 返回 7
|
||||
bSTIterator.hasNext(); // 返回 True
|
||||
bSTIterator.next(); // 返回 9
|
||||
bSTIterator.hasNext(); // 返回 True
|
||||
bSTIterator.next(); // 返回 15
|
||||
bSTIterator.hasNext(); // 返回 True
|
||||
bSTIterator.next(); // 返回 20
|
||||
bSTIterator.hasNext(); // 返回 False
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点的数目在范围 <code>[1, 10<sup>5</sup>]</code> 内</li>
|
||||
<li><code>0 <= Node.val <= 10<sup>6</sup></code></li>
|
||||
<li>最多调用 <code>10<sup>5</sup></code> 次 <code>hasNext</code> 和 <code>next</code> 操作</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>你可以设计一个满足下述条件的解决方案吗？<code>next()</code> 和 <code>hasNext()</code> 操作均摊时间复杂度为 <code>O(1)</code> ，并使用 <code>O(h)</code> 内存。其中 <code>h</code> 是树的高度。</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>栈</li><li>树</li><li>设计</li></div></div>\n<div><li>👍 435</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,62 @@
|
||||
//给定一个二叉树，返回它的 后序 遍历。
|
||||
//
|
||||
// 示例:
|
||||
//
|
||||
// 输入: [1,null,2,3]
|
||||
// 1
|
||||
// \
|
||||
// 2
|
||||
// /
|
||||
// 3
|
||||
//
|
||||
//输出: [3,2,1]
|
||||
//
|
||||
// 进阶: 递归算法很简单，你可以通过迭代算法完成吗？
|
||||
// Related Topics 栈 树
|
||||
// 👍 564 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import com.code.leet.entiy.TreeNode;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
//145:二叉树的后序遍历
|
||||
public class BinaryTreePostorderTraversal{
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new BinaryTreePostorderTraversal().new Solution();
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* public class TreeNode {
|
||||
* int val;
|
||||
* TreeNode left;
|
||||
* TreeNode right;
|
||||
* TreeNode() {}
|
||||
* TreeNode(int val) { this.val = val; }
|
||||
* TreeNode(int val, TreeNode left, TreeNode right) {
|
||||
* this.val = val;
|
||||
* this.left = left;
|
||||
* this.right = right;
|
||||
* }
|
||||
* }
|
||||
*/
|
||||
class Solution {
|
||||
public List<Integer> postorderTraversal(TreeNode root) {
|
||||
List<Integer> list = new ArrayList<>();
|
||||
if(root==null){
|
||||
return list;
|
||||
}
|
||||
list.addAll(postorderTraversal(root.left));
|
||||
list.addAll(postorderTraversal(root.right));
|
||||
list.add(root.val);
|
||||
return list;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,15 @@
|
||||
<p>给定一个二叉树，返回它的 <em>后序 </em>遍历。</p>
|
||||
|
||||
<p><strong>示例:</strong></p>
|
||||
|
||||
<pre><strong>输入:</strong> [1,null,2,3]
|
||||
1
|
||||
\
|
||||
2
|
||||
/
|
||||
3
|
||||
|
||||
<strong>输出:</strong> [3,2,1]</pre>
|
||||
|
||||
<p><strong>进阶:</strong> 递归算法很简单，你可以通过迭代算法完成吗？</p>
|
||||
<div><div>Related Topics</div><div><li>栈</li><li>树</li></div></div>\n<div><li>👍 564</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,99 @@
|
||||
//给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：root = [1,null,2,3]
|
||||
//输出：[1,2,3]
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：root = []
|
||||
//输出：[]
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
//
|
||||
//输入：root = [1]
|
||||
//输出：[1]
|
||||
//
|
||||
//
|
||||
// 示例 4：
|
||||
//
|
||||
//
|
||||
//输入：root = [1,2]
|
||||
//输出：[1,2]
|
||||
//
|
||||
//
|
||||
// 示例 5：
|
||||
//
|
||||
//
|
||||
//输入：root = [1,null,2]
|
||||
//输出：[1,2]
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 树中节点数目在范围 [0, 100] 内
|
||||
// -100 <= Node.val <= 100
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 进阶：递归算法很简单，你可以通过迭代算法完成吗？
|
||||
// Related Topics 栈 树
|
||||
// 👍 552 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import com.code.leet.entiy.TreeNode;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
//144:二叉树的前序遍历
|
||||
public class BinaryTreePreorderTraversal {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new BinaryTreePreorderTraversal().new Solution();
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
|
||||
/**
|
||||
* Definition for a binary tree node.
|
||||
* public class TreeNode {
|
||||
* int val;
|
||||
* TreeNode left;
|
||||
* TreeNode right;
|
||||
* TreeNode() {}
|
||||
* TreeNode(int val) { this.val = val; }
|
||||
* TreeNode(int val, TreeNode left, TreeNode right) {
|
||||
* this.val = val;
|
||||
* this.left = left;
|
||||
* this.right = right;
|
||||
* }
|
||||
* }
|
||||
*/
|
||||
class Solution {
|
||||
public List<Integer> preorderTraversal(TreeNode root) {
|
||||
List<Integer> list = new ArrayList<>();
|
||||
if (root == null) {
|
||||
return list;
|
||||
}
|
||||
list.add(root.val);
|
||||
list.addAll(preorderTraversal(root.left));
|
||||
list.addAll(preorderTraversal(root.right));
|
||||
return list;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,52 @@
|
||||
<p>给你二叉树的根节点 <code>root</code> ，返回它节点值的 <strong>前序</strong><em> </em>遍历。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 202px; height: 324px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,null,2,3]
|
||||
<strong>输出：</strong>[1,2,3]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = []
|
||||
<strong>输出：</strong>[]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1]
|
||||
<strong>输出：</strong>[1]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 4：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_5.jpg" style="width: 202px; height: 202px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,2]
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 5：</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_4.jpg" style="width: 202px; height: 202px;" />
|
||||
<pre>
|
||||
<strong>输入：</strong>root = [1,null,2]
|
||||
<strong>输出：</strong>[1,2]
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>树中节点数目在范围 <code>[0, 100]</code> 内</li>
|
||||
<li><code>-100 <= Node.val <= 100</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>递归算法很简单，你可以通过迭代算法完成吗？</p>
|
||||
<div><div>Related Topics</div><div><li>栈</li><li>树</li></div></div>\n<div><li>👍 552</li><li>👎 0</li></div>
|
||||
@ -27,15 +27,15 @@ package leetcode.editor.cn;
|
||||
|
||||
import com.code.leet.entiy.TreeNode;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Stack;
|
||||
import java.util.*;
|
||||
|
||||
//103:二叉树的锯齿形层序遍历
|
||||
public class BinaryTreeZigzagLevelOrderTraversal {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new BinaryTreeZigzagLevelOrderTraversal().new Solution();
|
||||
List<Integer> list = Arrays.asList(3,9,20,null,null,15,7);
|
||||
solution.zigzagLevelOrder(new TreeNode(list));
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
@ -56,40 +56,37 @@ public class BinaryTreeZigzagLevelOrderTraversal {
|
||||
* }
|
||||
*/
|
||||
class Solution {
|
||||
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
|
||||
List<List<Integer>> result = new ArrayList<>();
|
||||
Stack<TreeNode> stack1 = new Stack<>();
|
||||
Stack<TreeNode> stack2 = new Stack<>();
|
||||
stack1.push(root);
|
||||
TreeNode temp;
|
||||
List<Integer> list;
|
||||
while (!stack1.isEmpty() || !stack2.isEmpty()) {
|
||||
list = new ArrayList<>();
|
||||
while (!stack1.isEmpty()) {
|
||||
temp = stack1.pop();
|
||||
list.add(temp.val);
|
||||
if (temp.left != null) {
|
||||
stack2.push(temp.left);
|
||||
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {List<List<Integer>> ans = new LinkedList<List<Integer>>();
|
||||
if (root == null) {
|
||||
return ans;
|
||||
}
|
||||
if (temp.right != null) {
|
||||
stack2.push(temp.right);
|
||||
|
||||
Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
|
||||
nodeQueue.offer(root);
|
||||
boolean isOrderLeft = true;
|
||||
|
||||
while (!nodeQueue.isEmpty()) {
|
||||
Deque<Integer> levelList = new LinkedList<Integer>();
|
||||
int size = nodeQueue.size();
|
||||
for (int i = 0; i < size; ++i) {
|
||||
TreeNode curNode = nodeQueue.poll();
|
||||
if (isOrderLeft) {
|
||||
levelList.offerLast(curNode.val);
|
||||
} else {
|
||||
levelList.offerFirst(curNode.val);
|
||||
}
|
||||
result.add(list);
|
||||
if (curNode.left != null) {
|
||||
nodeQueue.offer(curNode.left);
|
||||
}
|
||||
list = new ArrayList<>();
|
||||
while (!stack2.isEmpty()) {
|
||||
temp = stack2.pop();
|
||||
list.add(temp.val);
|
||||
if (temp.right != null) {
|
||||
stack1.push(temp.right);
|
||||
}
|
||||
if (temp.left != null) {
|
||||
stack1.push(temp.left);
|
||||
}
|
||||
result.add(list);
|
||||
if (curNode.right != null) {
|
||||
nodeQueue.offer(curNode.right);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
ans.add(new LinkedList<Integer>(levelList));
|
||||
isOrderLeft = !isOrderLeft;
|
||||
}
|
||||
|
||||
return ans;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
@ -0,0 +1,125 @@
|
||||
//根据 逆波兰表示法，求表达式的值。
|
||||
//
|
||||
// 有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 说明：
|
||||
//
|
||||
//
|
||||
// 整数除法只保留整数部分。
|
||||
// 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：tokens = ["2","1","+","3","*"]
|
||||
//输出：9
|
||||
//解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：tokens = ["4","13","5","/","+"]
|
||||
//输出：6
|
||||
//解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
//
|
||||
//输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
|
||||
//输出：22
|
||||
//解释：
|
||||
//该算式转化为常见的中缀算术表达式为：
|
||||
// ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
|
||||
//= ((10 * (6 / (12 * -11))) + 17) + 5
|
||||
//= ((10 * (6 / -132)) + 17) + 5
|
||||
//= ((10 * 0) + 17) + 5
|
||||
//= (0 + 17) + 5
|
||||
//= 17 + 5
|
||||
//= 22
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= tokens.length <= 104
|
||||
// tokens[i] 要么是一个算符（"+"、"-"、"*" 或 "/"），要么是一个在范围 [-200, 200] 内的整数
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 逆波兰表达式：
|
||||
//
|
||||
// 逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。
|
||||
//
|
||||
//
|
||||
// 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
|
||||
// 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
|
||||
//
|
||||
//
|
||||
// 逆波兰表达式主要有以下两个优点：
|
||||
//
|
||||
//
|
||||
// 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
|
||||
// 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。
|
||||
//
|
||||
// Related Topics 栈
|
||||
// 👍 331 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.Stack;
|
||||
|
||||
//150:逆波兰表达式求值
|
||||
public class EvaluateReversePolishNotation {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new EvaluateReversePolishNotation().new Solution();
|
||||
System.out.println(solution.evalRPN(new String[]{"4", "13", "5", "/", "+"}));
|
||||
}
|
||||
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int evalRPN(String[] tokens) {
|
||||
Stack<Integer> stack = new Stack<>();
|
||||
String op = "+-*/";
|
||||
int result = 0;
|
||||
for (String str : tokens) {
|
||||
if (op.contains(str) && !stack.isEmpty()) {
|
||||
int op2 = stack.pop();
|
||||
int op1 = stack.pop();
|
||||
switch (str) {
|
||||
case "+":
|
||||
result = op1 + op2;
|
||||
break;
|
||||
case "-":
|
||||
result = op1 - op2;
|
||||
break;
|
||||
case "*":
|
||||
result = op1 * op2;
|
||||
break;
|
||||
case "/":
|
||||
result = op1 / op2;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
stack.push(result);
|
||||
} else {
|
||||
stack.push(Integer.valueOf(str));
|
||||
}
|
||||
}
|
||||
return stack.pop();
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,73 @@
|
||||
<p>根据<a href="https://baike.baidu.com/item/%E9%80%86%E6%B3%A2%E5%85%B0%E5%BC%8F/128437" target="_blank"> 逆波兰表示法</a>，求表达式的值。</p>
|
||||
|
||||
<p>有效的算符包括 <code>+</code>、<code>-</code>、<code>*</code>、<code>/</code> 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>说明：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>整数除法只保留整数部分。</li>
|
||||
<li>给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>tokens = ["2","1","+","3","*"]
|
||||
<strong>输出：</strong>9
|
||||
<strong>解释：</strong>该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>tokens = ["4","13","5","/","+"]
|
||||
<strong>输出：</strong>6
|
||||
<strong>解释：</strong>该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
|
||||
<strong>输出：</strong>22
|
||||
<strong>解释：</strong>
|
||||
该算式转化为常见的中缀算术表达式为：
|
||||
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
|
||||
= ((10 * (6 / (12 * -11))) + 17) + 5
|
||||
= ((10 * (6 / -132)) + 17) + 5
|
||||
= ((10 * 0) + 17) + 5
|
||||
= (0 + 17) + 5
|
||||
= 17 + 5
|
||||
= 22</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= tokens.length <= 10<sup>4</sup></code></li>
|
||||
<li><code>tokens[i]</code> 要么是一个算符（<code>"+"</code>、<code>"-"</code>、<code>"*"</code> 或 <code>"/"</code>），要么是一个在范围 <code>[-200, 200]</code> 内的整数</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>逆波兰表达式：</strong></p>
|
||||
|
||||
<p>逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。</p>
|
||||
|
||||
<ul>
|
||||
<li>平常使用的算式则是一种中缀表达式，如 <code>( 1 + 2 ) * ( 3 + 4 )</code> 。</li>
|
||||
<li>该算式的逆波兰表达式写法为 <code>( ( 1 2 + ) ( 3 4 + ) * )</code> 。</li>
|
||||
</ul>
|
||||
|
||||
<p>逆波兰表达式主要有以下两个优点：</p>
|
||||
|
||||
<ul>
|
||||
<li>去掉括号后表达式无歧义，上式即便写成 <code>1 2 + 3 4 + * </code>也可以依据次序计算出正确结果。</li>
|
||||
<li>适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>栈</li></div></div>\n<div><li>👍 331</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,85 @@
|
||||
//已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变
|
||||
//化后可能得到：
|
||||
//
|
||||
// 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
|
||||
// 若旋转 4 次，则可以得到 [0,1,2,4,5,6,7]
|
||||
//
|
||||
//
|
||||
// 注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2],
|
||||
//..., a[n-2]] 。
|
||||
//
|
||||
// 给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：nums = [3,4,5,1,2]
|
||||
//输出：1
|
||||
//解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：nums = [4,5,6,7,0,1,2]
|
||||
//输出：0
|
||||
//解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
|
||||
//
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
//
|
||||
//输入：nums = [11,13,15,17]
|
||||
//输出：11
|
||||
//解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// n == nums.length
|
||||
// 1 <= n <= 5000
|
||||
// -5000 <= nums[i] <= 5000
|
||||
// nums 中的所有整数 互不相同
|
||||
// nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转
|
||||
//
|
||||
// Related Topics 数组 二分查找
|
||||
// 👍 395 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//153:寻找旋转排序数组中的最小值
|
||||
public class FindMinimumInRotatedSortedArray {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new FindMinimumInRotatedSortedArray().new Solution();
|
||||
solution.findMin(new int[]{2, 1});
|
||||
}
|
||||
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int findMin(int[] nums) {
|
||||
int start = 0, end = nums.length - 1;
|
||||
int current;
|
||||
while (start < end - 1) {
|
||||
current = (start + end) / 2;
|
||||
if (nums[start] > nums[current]) {
|
||||
start++;
|
||||
end = current;
|
||||
} else if (nums[current] > nums[end]) {
|
||||
start = current;
|
||||
} else {
|
||||
end = current;
|
||||
}
|
||||
}
|
||||
return Math.min(nums[start], nums[end]);
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,48 @@
|
||||
已知一个长度为 <code>n</code> 的数组，预先按照升序排列，经由 <code>1</code> 到 <code>n</code> 次 <strong>旋转</strong> 后，得到输入数组。例如，原数组 <code>nums = [0,1,2,4,5,6,7]</code> 在变化后可能得到：
|
||||
<ul>
|
||||
<li>若旋转 <code>4</code> 次，则可以得到 <code>[4,5,6,7,0,1,2]</code></li>
|
||||
<li>若旋转 <code>4</code> 次，则可以得到 <code>[0,1,2,4,5,6,7]</code></li>
|
||||
</ul>
|
||||
|
||||
<p>注意，数组 <code>[a[0], a[1], a[2], ..., a[n-1]]</code> <strong>旋转一次</strong> 的结果为数组 <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code> 。</p>
|
||||
|
||||
<p>给你一个元素值 <strong>互不相同</strong> 的数组 <code>nums</code> ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 <strong>最小元素</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [3,4,5,1,2]
|
||||
<strong>输出：</strong>1
|
||||
<strong>解释：</strong>原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [4,5,6,7,0,1,2]
|
||||
<strong>输出：</strong>0
|
||||
<strong>解释：</strong>原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [11,13,15,17]
|
||||
<strong>输出：</strong>11
|
||||
<strong>解释：</strong>原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>1 <= n <= 5000</code></li>
|
||||
<li><code>-5000 <= nums[i] <= 5000</code></li>
|
||||
<li><code>nums</code> 中的所有整数 <strong>互不相同</strong></li>
|
||||
<li><code>nums</code> 原来是一个升序排序的数组，并进行了 <code>1</code> 至 <code>n</code> 次旋转</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>二分查找</li></div></div>\n<div><li>👍 395</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,88 @@
|
||||
//已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变
|
||||
//化后可能得到：
|
||||
//
|
||||
// 若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
|
||||
// 若旋转 7 次，则可以得到 [0,1,4,4,5,6,7]
|
||||
//
|
||||
//
|
||||
// 注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2],
|
||||
//..., a[n-2]] 。
|
||||
//
|
||||
// 给你一个可能存在 重复 元素值的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：nums = [1,3,5]
|
||||
//输出：1
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：nums = [2,2,2,0,1]
|
||||
//输出：0
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// n == nums.length
|
||||
// 1 <= n <= 5000
|
||||
// -5000 <= nums[i] <= 5000
|
||||
// nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 进阶：
|
||||
//
|
||||
//
|
||||
// 这道题是 寻找旋转排序数组中的最小值 的延伸题目。
|
||||
// 允许重复会影响算法的时间复杂度吗？会如何影响，为什么？
|
||||
//
|
||||
// Related Topics 数组 二分查找
|
||||
// 👍 282 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
/**
|
||||
* 154:寻找旋转排序数组中的最小值 II
|
||||
*/
|
||||
public class FindMinimumInRotatedSortedArrayIi {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new FindMinimumInRotatedSortedArrayIi().new Solution();
|
||||
System.out.println(solution.findMin(new int[]{3, 3, 1, 3}));
|
||||
}
|
||||
|
||||
/**
|
||||
* 力扣代码
|
||||
*/
|
||||
class Solution {
|
||||
public int findMin(int[] nums) {
|
||||
int start = 0, end = nums.length - 1;
|
||||
int current;
|
||||
while (start < end - 1) {
|
||||
current = (start + end) / 2;
|
||||
if (nums[start] > nums[current]) {
|
||||
start++;
|
||||
end = current;
|
||||
} else if (nums[current] > nums[end]) {
|
||||
start = current;
|
||||
} else if (nums[start] == nums[end]) {
|
||||
start++;
|
||||
} else {
|
||||
end = current;
|
||||
}
|
||||
}
|
||||
return Math.min(nums[start], nums[end]);
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,46 @@
|
||||
已知一个长度为 <code>n</code> 的数组，预先按照升序排列，经由 <code>1</code> 到 <code>n</code> 次 <strong>旋转</strong> 后，得到输入数组。例如，原数组 <code>nums = [0,1,4,4,5,6,7]</code> 在变化后可能得到：
|
||||
<ul>
|
||||
<li>若旋转 <code>4</code> 次，则可以得到 <code>[4,5,6,7,0,1,4]</code></li>
|
||||
<li>若旋转 <code>7</code> 次，则可以得到 <code>[0,1,4,4,5,6,7]</code></li>
|
||||
</ul>
|
||||
|
||||
<p>注意，数组 <code>[a[0], a[1], a[2], ..., a[n-1]]</code> <strong>旋转一次</strong> 的结果为数组 <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code> 。</p>
|
||||
|
||||
<p>给你一个可能存在 <strong>重复</strong> 元素值的数组 <code>nums</code> ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 <strong>最小元素</strong> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,3,5]
|
||||
<strong>输出：</strong>1
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2,2,2,0,1]
|
||||
<strong>输出：</strong>0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>n == nums.length</code></li>
|
||||
<li><code>1 <= n <= 5000</code></li>
|
||||
<li><code>-5000 <= nums[i] <= 5000</code></li>
|
||||
<li><code>nums</code> 原来是一个升序排序的数组，并进行了 <code>1</code> 至 <code>n</code> 次旋转</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>这道题是 <a href="https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/description/">寻找旋转排序数组中的最小值</a> 的延伸题目。</li>
|
||||
<li>允许重复会影响算法的时间复杂度吗？会如何影响，为什么？</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>二分查找</li></div></div>\n<div><li>👍 282</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,98 @@
|
||||
//给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 最多出现两次 ，返回删除后数组的新长度。
|
||||
//
|
||||
// 不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 说明：
|
||||
//
|
||||
// 为什么返回数值是整数，但输出的答案是数组呢？
|
||||
//
|
||||
// 请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
|
||||
//
|
||||
// 你可以想象内部操作如下:
|
||||
//
|
||||
//
|
||||
//// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
|
||||
//int len = removeDuplicates(nums);
|
||||
//
|
||||
//// 在函数里修改输入数组对于调用者是可见的。
|
||||
//// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
|
||||
//for (int i = 0; i < len; i++) {
|
||||
// print(nums[i]);
|
||||
//}
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：nums = [1,1,1,2,2,3]
|
||||
//输出：5, nums = [1,1,2,2,3]
|
||||
//解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：nums = [0,0,1,1,1,1,2,3,3]
|
||||
//输出：7, nums = [0,0,1,1,2,3,3]
|
||||
//解释：函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。 不需要考虑数组中超出新长度后面的
|
||||
//元素。
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= nums.length <= 3 * 104
|
||||
// -104 <= nums[i] <= 104
|
||||
// nums 已按升序排列
|
||||
//
|
||||
// Related Topics 数组 双指针
|
||||
// 👍 438 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
//80:删除有序数组中的重复项 II
|
||||
public class RemoveDuplicatesFromSortedArrayIi {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new RemoveDuplicatesFromSortedArrayIi().new Solution();
|
||||
solution.removeDuplicates(new int[]{1,1,1,2,2,3});
|
||||
}
|
||||
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int removeDuplicates(int[] nums) {
|
||||
int length = nums.length;
|
||||
if (length < 3) {
|
||||
return nums.length;
|
||||
}
|
||||
int front = 0;
|
||||
int count = 0;
|
||||
int result = length;
|
||||
for (int i = 0; i < length; i++) {
|
||||
if (i == 0) {
|
||||
front = nums[i];
|
||||
count = 1;
|
||||
} else {
|
||||
count = front == nums[i] ? count + 1 : 1;
|
||||
front = front == nums[i] ? front : nums[i];
|
||||
if (count == 3) {
|
||||
count--;
|
||||
result--;
|
||||
} else {
|
||||
nums[i + result - length] = nums[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,53 @@
|
||||
<p>给你一个有序数组 <code>nums</code> ，请你<strong><a href="http://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95" target="_blank"> 原地</a></strong> 删除重复出现的元素，使每个元素 <strong>最多出现两次</strong> ，返回删除后数组的新长度。</p>
|
||||
|
||||
<p>不要使用额外的数组空间，你必须在 <strong><a href="https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95" target="_blank">原地 </a>修改输入数组 </strong>并在使用 O(1) 额外空间的条件下完成。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>说明：</strong></p>
|
||||
|
||||
<p>为什么返回数值是整数，但输出的答案是数组呢？</p>
|
||||
|
||||
<p>请注意，输入数组是以<strong>「引用」</strong>方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。</p>
|
||||
|
||||
<p>你可以想象内部操作如下:</p>
|
||||
|
||||
<pre>
|
||||
// <strong>nums</strong> 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
|
||||
int len = removeDuplicates(nums);
|
||||
|
||||
// 在函数里修改输入数组对于调用者是可见的。
|
||||
// 根据你的函数返回的长度, 它会打印出数组中<strong> 该长度范围内</strong> 的所有元素。
|
||||
for (int i = 0; i < len; i++) {
|
||||
print(nums[i]);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1,1,1,2,2,3]
|
||||
<strong>输出：</strong>5, nums = [1,1,2,2,3]
|
||||
<strong>解释：</strong>函数应返回新长度 length = <strong><code>5</code></strong>, 并且原数组的前五个元素被修改为 <strong><code>1, 1, 2, 2,</code></strong> <strong>3 </strong>。 不需要考虑数组中超出新长度后面的元素。
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [0,0,1,1,1,1,2,3,3]
|
||||
<strong>输出：</strong>7, nums = [0,0,1,1,2,3,3]
|
||||
<strong>解释：</strong>函数应返回新长度 length = <strong><code>7</code></strong>, 并且原数组的前五个元素被修改为 <strong><code>0</code></strong>, <strong>0</strong>, <strong>1</strong>, <strong>1</strong>, <strong>2</strong>, <strong>3</strong>, <strong>3 。</strong> 不需要考虑数组中超出新长度后面的元素。
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 3 * 10<sup>4</sup></code></li>
|
||||
<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>
|
||||
<li><code>nums</code> 已按升序排列</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>双指针</li></div></div>\n<div><li>👍 438</li><li>👎 0</li></div>
|
||||
65
LeetCode/src/main/java/leetcode/editor/cn/SNJvJP.java
Normal file
65
LeetCode/src/main/java/leetcode/editor/cn/SNJvJP.java
Normal file
@ -0,0 +1,65 @@
|
||||
//某乐团的演出场地可视作 `num * num` 的二维矩阵 `grid`（左上角坐标为 `[0,0]`)，每个位置站有一位成员。乐团共有 `9` 种乐器，乐
|
||||
//器编号为 `1~9`，每位成员持有 `1` 个乐器。
|
||||
//
|
||||
//为保证声乐混合效果，成员站位规则为：自 `grid` 左上角开始顺时针螺旋形向内循环以 `1，2，...，9` 循环重复排列。例如当 num = `5` 时
|
||||
//，站位如图所示
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
//请返回位于场地坐标 [`Xpos`,`Ypos`] 的成员所持乐器编号。
|
||||
//
|
||||
//**示例 1：**
|
||||
//>输入：`num = 3, Xpos = 0, Ypos = 2`
|
||||
//>
|
||||
//>输出：`3`
|
||||
//>
|
||||
//>解释：
|
||||
//
|
||||
//
|
||||
//
|
||||
//**示例 2：**
|
||||
//>输入：`num = 4, Xpos = 1, Ypos = 2`
|
||||
//>
|
||||
//>输出：`5`
|
||||
//>
|
||||
//>解释：
|
||||
//
|
||||
//
|
||||
//
|
||||
//**提示：**
|
||||
//- `1 <= num <= 10^9`
|
||||
//- `0 <= Xpos, Ypos < num` 👍 23 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
/**
|
||||
* LCP 29:乐团站位
|
||||
*/
|
||||
public class SNJvJP {
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new SNJvJP().new Solution();
|
||||
System.out.println(solution.orchestraLayout(7466, 7084, 2520));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* 力扣代码
|
||||
*/
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int orchestraLayout(int num, int xPos, int yPos) {
|
||||
long round = Math.min(Math.min(xPos, num - xPos - 1), Math.min(yPos, num - yPos - 1));
|
||||
long length = (xPos - round) + (yPos - round);
|
||||
if (xPos > yPos) {
|
||||
round++;
|
||||
}
|
||||
long head = 4 * round * (num - round) + 1;
|
||||
int result = (int) (xPos > yPos ? (head - length) % 9 : (head + length) % 9);
|
||||
return result == 0 ? 9 : result;
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
30
LeetCode/src/main/java/leetcode/editor/cn/SNJvJP.md
Normal file
30
LeetCode/src/main/java/leetcode/editor/cn/SNJvJP.md
Normal file
@ -0,0 +1,30 @@
|
||||
某乐团的演出场地可视作 `num * num` 的二维矩阵 `grid`（左上角坐标为 `[0,0]`)，每个位置站有一位成员。乐团共有 `9` 种乐器，乐器编号为 `1~9`，每位成员持有 `1` 个乐器。
|
||||
|
||||
为保证声乐混合效果，成员站位规则为：自 `grid` 左上角开始顺时针螺旋形向内循环以 `1，2，...，9` 循环重复排列。例如当 num = `5` 时，站位如图所示
|
||||
|
||||
|
||||
|
||||
|
||||
请返回位于场地坐标 [`Xpos`,`Ypos`] 的成员所持乐器编号。
|
||||
|
||||
**示例 1：**
|
||||
>输入：`num = 3, Xpos = 0, Ypos = 2`
|
||||
>
|
||||
>输出：`3`
|
||||
>
|
||||
>解释：
|
||||
|
||||
|
||||
|
||||
**示例 2：**
|
||||
>输入：`num = 4, Xpos = 1, Ypos = 2`
|
||||
>
|
||||
>输出：`5`
|
||||
>
|
||||
>解释：
|
||||
|
||||
|
||||
|
||||
**提示：**
|
||||
- `1 <= num <= 10^9`
|
||||
- `0 <= Xpos, Ypos < num`<div><li>👍 23</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,69 @@
|
||||
//整数数组 nums 按升序排列，数组中的值 互不相同 。
|
||||
//
|
||||
// 在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[
|
||||
//k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2
|
||||
//,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
|
||||
//
|
||||
// 给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
|
||||
//
|
||||
//
|
||||
//
|
||||
// 示例 1：
|
||||
//
|
||||
//
|
||||
//输入：nums = [4,5,6,7,0,1,2], target = 0
|
||||
//输出：4
|
||||
//
|
||||
//
|
||||
// 示例 2：
|
||||
//
|
||||
//
|
||||
//输入：nums = [4,5,6,7,0,1,2], target = 3
|
||||
//输出：-1
|
||||
//
|
||||
// 示例 3：
|
||||
//
|
||||
//
|
||||
//输入：nums = [1], target = 0
|
||||
//输出：-1
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= nums.length <= 5000
|
||||
// -10^4 <= nums[i] <= 10^4
|
||||
// nums 中的每个值都 独一无二
|
||||
// 题目数据保证 nums 在预先未知的某个下标上进行了旋转
|
||||
// -10^4 <= target <= 10^4
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？
|
||||
// Related Topics 数组 二分查找
|
||||
// 👍 1288 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
//33:搜索旋转排序数组
|
||||
public class SearchInRotatedSortedArray{
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new SearchInRotatedSortedArray().new Solution();
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public int search(int[] nums, int target) {
|
||||
return Arrays.stream(nums).boxed().collect(Collectors.toList()).indexOf(target);
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,44 @@
|
||||
<p>整数数组 <code>nums</code> 按升序排列，数组中的值 <strong>互不相同</strong> 。</p>
|
||||
|
||||
<p>在传递给函数之前，<code>nums</code> 在预先未知的某个下标 <code>k</code>（<code>0 <= k < nums.length</code>）上进行了 <strong>旋转</strong>，使数组变为 <code>[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]</code>（下标 <strong>从 0 开始</strong> 计数）。例如， <code>[0,1,2,4,5,6,7]</code> 在下标 <code>3</code> 处经旋转后可能变为 <code>[4,5,6,7,0,1,2]</code> 。</p>
|
||||
|
||||
<p>给你 <strong>旋转后</strong> 的数组 <code>nums</code> 和一个整数 <code>target</code> ，如果 <code>nums</code> 中存在这个目标值 <code>target</code> ，则返回它的下标，否则返回 <code>-1</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [<code>4,5,6,7,0,1,2]</code>, target = 0
|
||||
<strong>输出：</strong>4
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [<code>4,5,6,7,0,1,2]</code>, target = 3
|
||||
<strong>输出：</strong>-1</pre>
|
||||
|
||||
<p><strong>示例 3：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [1], target = 0
|
||||
<strong>输出：</strong>-1
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 5000</code></li>
|
||||
<li><code>-10^4 <= nums[i] <= 10^4</code></li>
|
||||
<li><code>nums</code> 中的每个值都 <strong>独一无二</strong></li>
|
||||
<li>题目数据保证 <code>nums</code> 在预先未知的某个下标上进行了旋转</li>
|
||||
<li><code>-10^4 <= target <= 10^4</code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong>你可以设计一个时间复杂度为 <code>O(log n)</code> 的解决方案吗？</p>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>二分查找</li></div></div>\n<div><li>👍 1288</li><li>👎 0</li></div>
|
||||
@ -0,0 +1,67 @@
|
||||
//已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。
|
||||
//
|
||||
// 在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums
|
||||
//[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,
|
||||
//2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。
|
||||
//
|
||||
// 给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 targ
|
||||
//et ，则返回 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
|
||||
//
|
||||
//
|
||||
//
|
||||
// 提示：
|
||||
//
|
||||
//
|
||||
// 1 <= nums.length <= 5000
|
||||
// -104 <= nums[i] <= 104
|
||||
// 题目数据保证 nums 在预先未知的某个下标上进行了旋转
|
||||
// -104 <= target <= 104
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
// 进阶：
|
||||
//
|
||||
//
|
||||
// 这是 搜索旋转排序数组 的延伸题目，本题中的 nums 可能包含重复元素。
|
||||
// 这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？
|
||||
//
|
||||
// Related Topics 数组 二分查找
|
||||
// 👍 367 👎 0
|
||||
|
||||
package leetcode.editor.cn;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
//81:搜索旋转排序数组 II
|
||||
public class SearchInRotatedSortedArrayIi{
|
||||
public static void main(String[] args) {
|
||||
//测试代码
|
||||
Solution solution = new SearchInRotatedSortedArrayIi().new Solution();
|
||||
}
|
||||
//力扣代码
|
||||
//leetcode submit region begin(Prohibit modification and deletion)
|
||||
class Solution {
|
||||
public boolean search(int[] nums, int target) {
|
||||
return Arrays.stream(nums).boxed().collect(Collectors.toList()).contains(target);
|
||||
}
|
||||
}
|
||||
//leetcode submit region end(Prohibit modification and deletion)
|
||||
|
||||
}
|
||||
@ -0,0 +1,41 @@
|
||||
<p>已知存在一个按非降序排列的整数数组 <code>nums</code> ，数组中的值不必互不相同。</p>
|
||||
|
||||
<p>在传递给函数之前，<code>nums</code> 在预先未知的某个下标 <code>k</code>（<code>0 <= k < nums.length</code>）上进行了 <strong>旋转 </strong>，使数组变为 <code>[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]</code>（下标 <strong>从 0 开始</strong> 计数）。例如， <code>[0,1,2,4,4,4,5,6,6,7]</code> 在下标 <code>5</code> 处经旋转后可能变为 <code>[4,5,6,6,7,0,1,2,4,4]</code> 。</p>
|
||||
|
||||
<p>给你 <strong>旋转后</strong> 的数组 <code>nums</code> 和一个整数 <code>target</code> ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 <code>nums</code> 中存在这个目标值 <code>target</code> ，则返回 <code>true</code> ，否则返回 <code>false</code> 。</p>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>示例 1：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2<code>,5,6,0,0,1,2]</code>, target = 0
|
||||
<strong>输出：</strong>true
|
||||
</pre>
|
||||
|
||||
<p><strong>示例 2：</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>输入：</strong>nums = [2<code>,5,6,0,0,1,2]</code>, target = 3
|
||||
<strong>输出：</strong>false</pre>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>提示：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 5000</code></li>
|
||||
<li><code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code></li>
|
||||
<li>题目数据保证 <code>nums</code> 在预先未知的某个下标上进行了旋转</li>
|
||||
<li><code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<p><strong>进阶：</strong></p>
|
||||
|
||||
<ul>
|
||||
<li>这是 <a href="https://leetcode-cn.com/problems/search-in-rotated-sorted-array/description/">搜索旋转排序数组</a> 的延伸题目，本题中的 <code>nums</code> 可能包含重复元素。</li>
|
||||
<li>这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？</li>
|
||||
</ul>
|
||||
<div><div>Related Topics</div><div><li>数组</li><li>二分查找</li></div></div>\n<div><li>👍 367</li><li>👎 0</li></div>
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
Loading…
Reference in New Issue
Block a user