每日一练——

作者：~小明学编程  

文章专栏：每日一练——Java

格言：目之所及皆为回忆，心之所想皆为过往

今天给大家带来两题力扣的链表练习

两数相加

链接：2. 两数相加 - 力扣（LeetCode）

题目：

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

本题思路全在代码里

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //创建一个新的链表
        ListNode newlist = new ListNode(0);
        //复制我们的新链表头节点以便连接后面的节点
        ListNode cur = newlist;
        //flag作为一个标记用于储存我们的进位1
        int flag = 0;
        //循环直到遍历完两个列表
        while(l1!=null||l2!=null) {
            ListNode ret;//创建一个临时的节点用于存储我们的新节点
            //分别存储我们两个链表临时的val值当遍历完链表其值就为0
            int l1val = l1!=null?l1.val:0;
            int l2val = l2!=null?l2.val:0;
            //分别讨论两种情况，两个val相加的值都大于10或者有进位时加上进位等于10
            if(l1val+l2val>=10||(l1val+l2val==9&&flag==1)) {
                //有进位要加上进位
                if(flag==1) {
                    ret = new ListNode((l1val+l2val+1)%10);
                    
                } else {
                    ret = new ListNode((l1val+l2val)%10);
                }
                //有进位要将flag置为1
                flag = 1;
            //相加不大于等于10
            } else {
                //有进位要加上进位并且将进位重新置0
                if(flag==1) {
                    ret = new ListNode((l1val+l2val)+1);
                    flag--;
                  
                } else {
                    ret = new ListNode(l1val+l2val);
                  
                }
            }
            //连接链表
            cur.next = ret;
            cur = ret;
            //判断链表是否还要继续往后走
            if(l1!=null) l1 = l1.next;
            if(l2!=null) l2 = l2.next;
            
        }
        //当两个链表都走完的时候我们还留有一个进位要再处理一下
        if(flag==1) {
            ListNode ret = new ListNode(1);
            cur.next = ret;
            cur = ret;
        }
        //最后返回我们的首节点
        return newlist.next;
 
    }
}

链表随机节点

链接：382. 链表随机节点 - 力扣（LeetCode）

给你一个单链表，随机选择链表的一个节点，并返回相应的节点值。每个节点 被选中的概率一样。

实现 Solution 类：

Solution(ListNode head) 使用整数数组初始化对象。
int getRandom() 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相等。

代码

import java.util.Random;
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
 //方法一：
// class Solution {
//     ListNode head;
//     public Solution(ListNode head) {
//         this.head = head;
//     }
    
//     public int getRandom() {
//         Random random = new Random();
//         ListNode cur = head;
//         ListNode cur1 = head;
//         int num = 0;
//         while(cur!=null){
//             cur = cur.next;
//             num++;
//         }
//         int ran = random.nextInt(num);
//         while(ran--!=0){
//             cur1 = cur1.next;
//         }
//         return cur1.val;
//     }
// }
//方法二：
class Solution {
    ListNode head;
    public Solution(ListNode head) {
        this.head = head;
    }
    
    public int getRandom() {
        Random random = new Random();
        ListNode cur = head;
        int tem = 1;
        int ans = 0;
        while(cur!=null) {
            if (random.nextInt(tem)==0) {
                ans = cur.val;
            }
            cur = cur.next;
            tem++;
        }
        return ans;
    }
}
 
/**
 * Your Solution object will be instantiated and called as such:
 * Solution obj = new Solution(head);
 * int param_1 = obj.getRandom();
 */

其中方法一的空间复杂度比较高，方法二的空间复杂度只有O(1).