力扣爆刷第112天之CodeTop100五连刷46-50

力扣爆刷第112天之CodeTop100五连刷46-50

文章目录

      • 力扣爆刷第112天之CodeTop100五连刷46-50
      • [一、148. 排序链表](#一、148. 排序链表)
      • [二、22. 括号生成](#二、22. 括号生成)
      • [三、70. 爬楼梯](#三、70. 爬楼梯)
      • [四、2. 两数相加](#四、2. 两数相加)
      • [五、165. 比较版本号](#五、165. 比较版本号)

一、148. 排序链表

题目链接:https://leetcode.cn/problems/sort-list/description/

思路:链表的归并排序,先递归分割链表,然后比较合并,注意分割操作,和边界条件。

java 复制代码
class Solution {
    public ListNode sortList(ListNode head) {
        return cutList(head, null);
    }

    ListNode cutList(ListNode head, ListNode end) {
        if(head == null) return head;
        if(head.next == end) {
            head.next = null;
            return head;
        }
        ListNode slow = head, fast = head;
        while(fast != end) {
            slow = slow.next;
            fast = fast.next;
            if(fast != end) {
                fast = fast.next;
            }
        }
        ListNode left = cutList(head, slow);
        ListNode right = cutList(slow, end);
        return merge(left, right);
    }
    
    ListNode merge(ListNode node1, ListNode node2) {
        ListNode root = new ListNode(), temp = root;
        while(node1 != null && node2 != null) {
            if(node1.val <= node2.val) {
                temp.next = node1;
                node1 = node1.next;
            }else{
                temp.next = node2;
                node2 = node2.next;
            }
            temp = temp.next;
        }
        if(node1 != null) {
            temp.next = node1;
        }
        if(node2 != null) {
            temp.next = node2;
        }
        return root.next;
    }
   
}

二、22. 括号生成

题目链接:https://leetcode.cn/problems/generate-parentheses/description/

思路:排列题,但是不需要考虑去重,只需要正常排列,然后收获结果的时候进行判断是否合法。

java 复制代码
class Solution {
    char[] source  = {'(', ')'};
    List<String> list = new ArrayList<>();
    StringBuilder builder = new StringBuilder();
    public List<String> generateParenthesis(int n) {
        backTracking(n*2);
        return list;
    }
    
    void backTracking(int n) {
        if(builder.length() == n) {
            if(isTrue(builder)) {
                list.add(builder.toString());
            }
            return;
        }
        for(int i = 0; i < 2; i++) {
            builder.append(source[i]);
            backTracking(n);
            builder.deleteCharAt(builder.length()-1);
        }
    }
    boolean isTrue(StringBuilder builder) {
        int n = 0;
        for (int i = 0; i < builder.length(); i++) {
            if(builder.charAt(i) == '(') {
                n++;
            }else{
                n--;
            }
            if(n < 0) return false;
        }
        return n == 0;
    }
}

三、70. 爬楼梯

题目链接:https://leetcode.cn/problems/climbing-stairs/description/

思路:最简单的动态规划,每一个位置依赖于前两个位置,分别为跨一步和跨两步。

java 复制代码
class Solution {
    public int climbStairs(int n) {
        if(n < 4) return n;
        int a = 1, b = 2, c = 0;
        for(int i = 3; i <= n; i++) {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
}

四、2. 两数相加

题目链接:https://leetcode.cn/problems/add-two-numbers/description/

思路:遍历相加,然后用一个变量记录进制值,下次计算时加进去。

java 复制代码
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int res = 0;
        ListNode root = new ListNode(), p = root;
        while(l1 != null || l2 != null) {
            int a = l1 != null ? l1.val : 0;
            int b = l2 != null ? l2.val : 0;
            int sum = a+b+res;
            res = sum / 10;
            ListNode t = new ListNode(sum%10);
            p.next = t;
            p = t;
            l1 = l1 != null ? l1.next : null;
            l2 = l2 != null ? l2.next : null;
        }    
        if(res == 1) {
            p.next = new ListNode(1);
        }
        return root.next;
    }

}

五、165. 比较版本号

题目链接:https://leetcode.cn/problems/compare-version-numbers/description/

思路:利用乘10循环计数的方法,前导0乘10后还是0,剩下的就简单轻松了,不等就判断返回,等就进行下一轮计算。

java 复制代码
class Solution {
    public int compareVersion(String version1, String version2) {
        int i = 0, j = 0, m = version1.length(), n = version2.length();
        while(i < m || j < n) {
            int x = 0;
            for(; i < m && version1.charAt(i) != '.'; i++) {
                x = x * 10 + version1.charAt(i) - '0';
            }
            i++;
            int y = 0;
            for(; j < n && version2.charAt(j) != '.'; j++) {
                y = y * 10 + version2.charAt(j) - '0';
            }
            j++;
            if(x != y) {
                return x > y ? 1 : -1;
            }
        }
        return 0;
    }
}
相关推荐
小码农<^_^>6 分钟前
优选算法精品课--滑动窗口算法(一)
算法
羊小猪~~8 分钟前
神经网络基础--什么是正向传播??什么是方向传播??
人工智能·pytorch·python·深度学习·神经网络·算法·机器学习
软工菜鸡34 分钟前
预训练语言模型BERT——PaddleNLP中的预训练模型
大数据·人工智能·深度学习·算法·语言模型·自然语言处理·bert
南宫生36 分钟前
贪心算法习题其三【力扣】【算法学习day.20】
java·数据结构·学习·算法·leetcode·贪心算法
AI视觉网奇1 小时前
sklearn 安装使用笔记
人工智能·算法·sklearn
JingHongB1 小时前
代码随想录算法训练营Day55 | 图论理论基础、深度优先搜索理论基础、卡玛网 98.所有可达路径、797. 所有可能的路径、广度优先搜索理论基础
算法·深度优先·图论
weixin_432702261 小时前
代码随想录算法训练营第五十五天|图论理论基础
数据结构·python·算法·深度优先·图论
小冉在学习1 小时前
day52 图论章节刷题Part04(110.字符串接龙、105.有向图的完全可达性、106.岛屿的周长 )
算法·深度优先·图论
Repeat7151 小时前
图论基础--孤岛系列
算法·深度优先·广度优先·图论基础
小冉在学习1 小时前
day53 图论章节刷题Part05(并查集理论基础、寻找存在的路径)
java·算法·图论