力扣刷题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:

力扣刷题1472 1721 70 914 263 24 27 1027_第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

丑数 就是只包含质因数 23 和 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:

力扣刷题1472 1721 70 914 263 24 27 1027_第2张图片

输入: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

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

你可能感兴趣的:(leetcode,java,servlet)