每日一练 —2021.12.10

---

一、相同的树

1、程序简介

• 给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
• 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

• 输入：p = [1,2,3], q = [1,2,3]
• 输出：true

示例 2：

• 输入：p = [1,2], q = [1,null,2]
• 输出：false

示例 3：

• 输入：p = [1,2,1], q = [1,1,2]
• 输出：false

提示：

• 两棵树上的节点数目都在范围 [0, 100] 内
• $-10^4<=Node.val<=10^4$

2、程序代码

# -*- coding: utf-8 -*-
"""
Created on Tue Dec  7 12:44:27 2021
Function:
@author: 小梁aixj
"""
class TreeNode(object):
    def __init__(self, x):
        self.val=x
        self.left=None
        self.right=None
class Solution(object):
    def isSameTree(self, p, q):
        if p==q:
            return True
        try:
            left=right=True
            if p.val==q.val:
                left=self.isSameTree(p.left, q.left)
                right=self.isSameTree(p.right, q.right)
                return (left and right)
        except:
            return False
        return False
#%%
s=Solution()
print(s.isSameTree(p=[1,2,3], q=[1,2,3]))
print(s.isSameTree(p=[1,2], q=[1,' ',2]))
print(s.isSameTree(p=[1,2,1], q=[1,1,3]))

3、运行结果

二、两两交换链表中的节点

1、程序简介

• 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
• 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

• 输入：head = [1,2,3,4]
• 输出：[2,1,4,3]

示例 2：

• 输入：head = []
• 输出：[]

示例 3：

• 输入：head = [1]
• 输出：[1]

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

进阶：

• 你能在不修改链表节点值的情况下解决这个问题吗?（也就是说，仅修改节点本身。）

2、程序代码

# -*- coding: utf-8 -*-
"""
Created on Fri Dec  3 15:31:48 2021
Function:
@author: 小梁aixj
"""

class ListNode(object):
    def __init__(self, x):
        self.val=x
        self.next=None
class LinkList:
    def __init__(self):
        self.head=None
    def initList(self, data):
        self.head=ListNode(data[0])
        r=self.head
        p=self.head
        for i in data[1:]:
            node=ListNode(i)
            p.next=node
            p=p.next
        return r
    def convert_list(self,head):
        ret=[]
        if head==None:
            return
        node=head
        while node != None:
            ret.append(node.val)
            node=node.next
        return ret
class Solution(object):
    def swapPairs(self, head):
        dummyHead=ListNode(-1)
        dummyHead.next=head
        prev, p = dummyHead, head
        while p != None and p.next != None:
            q, r=p.next, p.next.next
            prev.next=q
            q.next=p
            p.next=r
            prev=p
            p=r
        return dummyHead.next
#%%
l=LinkList()
head=[1,2,3,4]
l1=l.initList(head)
s=Solution()
print(l.convert_list(s.swapPairs(l1)))

3、运行结果

---

三、整数转罗马数字

1，程序简介

• 罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000

• 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。
• 27 写做 XXVII, 即为 XX + V + II 。
• 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

1. I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
2. X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
3. C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给你一个整数，将其转为罗马数字。

示例 1:

• 输入: num = 3
• 输出: “III”

示例 2:

• 输入: num = 4

• 输出: “IV”

示例 3:

• 输入: num = 9

• 输出: “IX”

示例 4:

• 输入: num = 58

• 输出: “LVIII”

• 解释: L = 50, V = 5, III = 3.

示例 5:

• 输入: num = 1994

• 输出: “MCMXCIV”

• 解释: M = 1000, CM = 900, XC = 90, IV = 4.

提示：

• 1 <= num <= 3999

以下程序实现了这一功能，请你填补空白处内容：

struct rmap
{
	char *r;
	int v;
} units[] = {
	{"M", 1000},
	{"CM", 900},
	{"D", 500},
	{"CD", 400},
	{"C", 100},
	{"XC", 90},
	{"L", 50},
	{"XL", 40},
	{"X", 10},
	{"IX", 9},
	{"V", 5},
	{"IV", 4},
	{"I", 1}};
#include <string.h>
char result[64];
char *intToRoman(int num)
{
	result[0] = 0;
	int ri = 0;
	int i = 0;
	while (num)
	{
        ______________
		else
		{
			i++;
		}
	}
	return result;
}

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Fri Dec 10 18:52:20 2021
Function:
@author: 小梁aixj
"""
from math import floor
class Solution:
    def intToRoman(self, num: int) -> str:
        f = 1000
        f2 = 1000
        sym = ['M', 'D', 'C', 'L', 'X', 'V', 'I']
        fsi = 0
        s = [2, 5]
        si = 0
        s2 = [10, 1]
        si2 = 0
        roman = []
        while num > 0:
            d = floor(num/f)
            r = num % f
            d2 = floor(num/f2)
            r2 = num % f2
            if d > 0:
                if d == 4:
                    roman.append(sym[fsi])
                    roman.append(sym[fsi-1])
                    num = r
                elif d2 == 9:
                    roman.append(sym[fsi+1])
                    roman.append(sym[fsi-1])
                    num = r2
                else:
                    i = 0
                    while i < d:
                        roman.append(sym[fsi])
                        i += 1
                    num = r
            f = f/s[si]
            si += 1
            si %= 2
            f2 = f2/s2[si2]
            si2 += 1
            si2 %= 2
            fsi += 1
        return ''.join(roman)
# %%
s = Solution()
print(s.intToRoman(num = 3))
print(s.intToRoman(num = 4))
print(s.intToRoman(num = 9))
print(s.intToRoman(num = 58))
print(s.intToRoman(num = 1994))

3，运行结果