力扣刷题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<String> s1 = new LinkedList<>();
    Deque<String> 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<Integer,Integer> map = new HashMap<>();
        for(int i :deck){
            map.put(i,map.getOrDefault(i,0)+1);
        }
        int g = -1;
        for(Map.Entry<Integer,Integer> 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 <Integer> list = new ArrayList<>();
        while(head!=null){
            list.add(head.val);
            head = head.next;
        }
        for(int i=0,j=list.size()-1;i<j;i++,j--){
            int a = list.get(i);
            int b = list.get(j);
            if(a!=b)
                return false;
        }
        return true;
    }
}

周五要把整理完的链表的笔记发出来！