力扣刷题1472 1721 70 914 263 24 27 1027
1472
1472. 设计浏览器历史记录
难度中等56
你有一个只支持单个标签页的 浏览器 ，最开始你浏览的网页是 homepage ，你可以访问其他的网站 url ，也可以在浏览历史中后退 steps 步或前进 steps 步。
请你实现 BrowserHistory 类：
BrowserHistory(string homepage)，用homepage初始化浏览器类。void visit(string url)从当前页跳转访问url对应的页面 。执行此操作会把浏览历史前进的记录全部删除。string back(int steps)在浏览历史中后退steps步。如果你只能在浏览历史中后退至多x步且steps > x，那么你只后退x步。请返回后退 至多steps步以后的url。string forward(int steps)在浏览历史中前进steps步。如果你只能在浏览历史中前进至多x步且steps > x，那么你只前进x步。请返回前进 至多steps步以后的url。
示例：
输入：
["BrowserHistory","visit","visit","visit","back","back","forward","visit","forward","back","back"]
[["leetcode.com"],["google.com"],["facebook.com"],["youtube.com"],[1],[1],[1],["linkedin.com"],[2],[2],[7]]
输出：
[null,null,null,null,"facebook.com","google.com","facebook.com",null,"linkedin.com","google.com","leetcode.com"]
解释：
BrowserHistory browserHistory = new BrowserHistory("leetcode.com");
browserHistory.visit("google.com"); // 你原本在浏览 "leetcode.com" 。访问 "google.com"
browserHistory.visit("facebook.com"); // 你原本在浏览 "google.com" 。访问 "facebook.com"
browserHistory.visit("youtube.com"); // 你原本在浏览 "facebook.com" 。访问 "youtube.com"
browserHistory.back(1); // 你原本在浏览 "youtube.com" ，后退到 "facebook.com" 并返回 "facebook.com"
browserHistory.back(1); // 你原本在浏览 "facebook.com" ，后退到 "google.com" 并返回 "google.com"
browserHistory.forward(1); // 你原本在浏览 "google.com" ，前进到 "facebook.com" 并返回 "facebook.com"
browserHistory.visit("linkedin.com"); // 你原本在浏览 "facebook.com" 。 访问 "linkedin.com"
browserHistory.forward(2); // 你原本在浏览 "linkedin.com" ，你无法前进任何步数。
browserHistory.back(2); // 你原本在浏览 "linkedin.com" ，后退两步依次先到 "facebook.com" ，然后到 "google.com" ，并返回 "google.com"
browserHistory.back(7); // 你原本在浏览 "google.com"， 你只能后退一步到 "leetcode.com" ，并返回 "leetcode.com"
栈还没看，先写在这里，学完回来
class BrowserHistory {
Deque s1 = new LinkedList<>();
Deque s2 = new LinkedList();
public BrowserHistory(String homepage) {
s1.push(homepage);
}
public void visit(String url) {
s1.push(url);
s2.clear();
}
public String back(int steps) {
for(int i = 0;i < steps && s1.size() > 1;i++){
s2.push(s1.pop());
}
return s1.peek();
}
public String forward(int steps) {
for(int i = 0;i < steps && !s2.isEmpty();i++){
s1.push(s2.pop());
}
return s1.peek();
}
} 1721. 交换链表中的节点
难度中等60
给你链表的头节点 head 和一个整数 k 。
交换 链表正数第 k 个节点和倒数第 k 个节点的值后，返回链表的头节点（链表 从 1 开始索引）。
示例 1：
输入：head = [1,2,3,4,5], k = 2 输出：[1,4,3,2,5]
示例 2：
输入：head = [7,9,6,6,7,8,3,0,9,5], k = 5 输出：[7,9,6,6,8,7,3,0,9,5]
示例 3：
输入：head = [1], k = 1 输出：[1]
示例 4：
输入：head = [1,2], k = 1 输出：[2,1]
示例 5：
输入：head = [1,2,3], k = 2 输出：[1,2,3]
/**
*定义一个node结点和快慢指针都指向头结点，fast快指针一直往前走直到遇见null，当node结点走到正数第k个结点时停止，此时slow慢指针开始出发，最后fast快指针走完链表时，slow慢指针所在位置刚好就是倒数第k个结点。
*
*/
class Solution {
public ListNode swapNodes(ListNode head, int k) {
ListNode node = head;
ListNode slow = head;
ListNode fast = head;
int count = 1;
while(fast.next != null) {
if(count < k){
node = node.next;
}else{
slow = slow.next;
}
fast = fast.next;
count++;
}
int temp = node.val;
node.val = slow.val;
slow.val = temp;
return head;
}
}70
70. 爬楼梯
难度简单2573
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
示例 1：
输入：n = 2 输出：2 解释：有两种方法可以爬到楼顶。 1. 1 阶 + 1 阶 2. 2 阶
示例 2：
输入：n = 3 输出：3
class Solution {
public int climbStairs(int n) {
int[] dp = new int[n];
if(n==0) //特例
return 0;
if(n==1) //特例
return 1;
dp[0]=1; //非特例时
dp[1]=2;
for(int i = 2 ; i < n ; i ++){
dp[i] = dp[i-1]+dp[i-2];
}
return dp[n-1];
}
}914
914. 卡牌分组
难度简单261
给定一副牌，每张牌上都写着一个整数。
此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组：
- 每组都有
X张牌。 - 组内所有的牌上都写着相同的整数。
仅当你可选的 X >= 2 时返回 true。
示例 1：
输入：deck = [1,2,3,4,4,3,2,1] 输出：true 解释：可行的分组是 [1,1]，[2,2]，[3,3]，[4,4]
示例 2：
输入：deck = [1,1,1,2,2,2,3,3] 输出：false 解释：没有满足要求的分组
不是很懂，周六回来重刷
class Solution {
public boolean hasGroupsSizeX(int[] deck) {
if(deck.length == 1){
return false;
}
Map map = new HashMap<>();
for(int i :deck){
map.put(i,map.getOrDefault(i,0)+1);
}
int g = -1;
for(Map.Entry entry:map.entrySet()){
if(g == -1){
g = entry.getValue();
}else{
g = gcd(g,entry.getValue());
}
}
return g >= 2?true:false;
}
// 辗转相除法求最大公因子
private int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
} 263. 丑数
难度简单336
丑数 就是只包含质因数 2、3 和 5 的正整数。
给你一个整数 n ，请你判断 n 是否为 丑数 。如果是，返回 true ；否则，返回 false 。
示例 1：
输入：n = 6 输出：true 解释：6 = 2 × 3
示例 2：
输入：n = 1
输出：true
解释：1 没有质因数，因此它的全部质因数是 {2, 3, 5} 的空集。习惯上将其视作第一个丑数。
示例 3：
输入：n = 14
输出：false
解释：14 不是丑数，因为它包含了另外一个质因数 7
class Solution {
public boolean isUgly(int num) {
if(num < 1) return false;
while(num % 5 == 0) num /= 5;
while(num % 3 == 0) num /= 3;
while(num % 2 == 0) num /= 2;
if(num == 1) return true;
else return false;
}
}24. 两两交换链表中的节点
难度中等1506
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：
输入：head = [1,2,3,4] 输出：[2,1,4,3]
示例 2：
输入：head = [] 输出：[]
示例 3：
输入：head = [1] 输出：[1]
两两交换链表中的节点：
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
2.想法
遇到这样的题，想法是进行结点修改了，多定义几个指针，最后再修改指针的位置，但是这样的仔细看指针的位置。自己写的时候搞错了，看了下评论。
基本想法，是把这些点两两的观察来看：
定义多的点来控制先看1和2，head指向1，最终返回的头结点是2开始，所以返回的那个ans应该指向的是head.next（就是2）；
cur=head.next,
把这些点固定住以后，就开始变换位置,head用pre替换吧，题目中给的是head，再用就不好了。
2-->1 cur.next = pre;
1-->4 pre.next = temp.next;
这是一次循环，循环后 cur向后移动，应该是4的位置。cur = temp.next;pre=temp;
class Solution {
public ListNode swapPairs(ListNode head) {
if(head == null ||head.next ==null)
{
return head;//只有一个数或者没有
}
ListNode ans = head.next;
ListNode pre = head;
ListNode cur = head.next;
ListNode temp = null;
while(cur.next != null&&cur.next.next!=null)
{
temp = cur.next;
pre.next = temp.next;
cur.next =pre;
pre = temp;
cur = temp.next;
}
//最后跳出循环 倒数第一个点
pre.next = cur.next;
cur.next = pre;
return ans;
}
}I 027. 回文链表
难度简单68
给定一个链表的 头节点 head ，请判断其是否为回文链表。
如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。
示例 1：
输入: head = [1,2,3,3,2,1] 输出: true
示例 2：
输入: head = [1,2] 输出: false
class Solution {
public boolean isPalindrome(ListNode head) {
List list = new ArrayList<>();
while(head!=null){
list.add(head.val);
head = head.next;
}
for(int i=0,j=list.size()-1;i 周五要把整理完的链表的笔记发出来！