二叉树的右视图（leetcode199）
C++
#include <vector>
#include <queue>
using namespace std;
// 二叉树的右视图
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};
class Solution {
public:
vector<int> rightSideView(TreeNode *root) {
vector<int> ans;
if(root== nullptr) return ans;
queue<TreeNode*>q;
q.push(root);
while (!q.empty()){
int layer_len = q.size();
for(int i=0;i<layer_len;i++){
TreeNode *data = q.front();
if(data->left) q.push(data->left);
if(data->right) q.push(data->right);
if(i==layer_len-1) ans.push_back(data->val);
q.pop();
}
}
return ans;
}
};Python
from typing import Optional,List
# Definition for a binary tree node.
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution:
def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
if not root:
return []
ans = []
# 定义一个队列，进行层序遍历
item = [root]
while item:
layer_length= len(item)
for i in range(layer_length):
data = item.pop(0)
if data.left:
item.append(data.left)
if data.right:
item.append(data.right)
if i==layer_length-1:
ans.append(data.val)
return ans
反转链表||（leetcode92）
C++
struct ListNode {
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
};
class Solution {
public:
ListNode *reverseBetween(ListNode *head, int left, int right) {
if (right == left) return head;
// 设置虚拟头节点
ListNode *dummy = new ListNode(0, head);
ListNode *p = dummy;
// 寻找到left
while(left>1){
head = head->next;
p = p->next;
left--;
right--;
}
// 头插法反转链表，执行right-left次结束
ListNode * r;
while (right>left){
r = head->next;
head->next = r->next;
r->next = p->next;
p->next=r;
right--;
}
r = dummy->next;
delete dummy;
return r;
}
};Python
from typing import Optional
# Definition for singly-linked list.
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class Solution:
def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
if right==left:
return head
# 思路：找到left,使用头插法反转链表，直到right-left次后结束
# 定义一个虚拟头节点
dummy = ListNode(0,head)
# 指针p指向left的上一个节点，head指向需要反转的节点，r指向待反转节点
p = dummy
while left>1:
head = head.next
p = p.next
left-=1
right-=1
# 头插法反转链表
while right>left:
r = head.next
head.next = r.next
r.next = p.next
p.next = r
right-=1
return dummy.next
if __name__ == '__main__':
# head = ListNode(3,ListNode(5,None))
head = ListNode(1,ListNode(2,ListNode(3,ListNode(4,ListNode(5,None)))))
left = 2
right = 4
s = Solution()
res = s.reverseBetween(head,left,right)
while res:
print(res.val)
res = res.next复原IP地址（leetcode93）
C++
#include <vector>
#include <string>
#include <iostream>
using namespace std;
class Solution {
public:
vector<string> restoreIpAddresses(string s) {
vector<string> ans;
if (s.length()>12 || s.length()<4) return ans;
string ip; // 记录正确的ip
int i = 1; // 用于表示当前正在处理第i个整数
processIpAddresses(s,i,ip,ans);
return ans;
}
void processIpAddresses(string subs, int i, string ip, vector<string> &ans){
// 检查空串和长度是否符合
if(subs.empty() || subs.length()>(5-i)*3)
return;
// 是否为最后一个
if(i==4 && stoi(subs)<=255){
if(subs.length()>1 && subs[0]=='0') return;
ans.push_back(ip+subs);
return;
}
// 切分1至3个字符进行判断
for(int j=1;j<4 && j<subs.length();j++){
string tmp = subs.substr(0,j);
// 不能是0开头的非零整数，不能大于255
if(tmp.length()>1 && tmp[0]=='0')
return;
if (stoi(tmp)>255)
return;
// 符合要求进入下一轮
processIpAddresses(subs.substr(j),i+1,ip+tmp+".",ans);
}
}
};
int main(){
string s = "25525511135";
//string s = "0000";
//string s = "101023";
Solution solution;
vector<string> ans=solution.restoreIpAddresses(s);
for (auto it : ans) {
cout << it << " ";
}
cout << endl;
return 0;
}Python
from typing import List
# 复原ip
class Solution:
def restoreIpAddresses(self, s: str) -> List[str]:
if len(s)>12 or len(s)<4:
return []
ip =''
ans = []
# 处理
self.processIpAddresses(s,1,ip,ans)
return ans
def processIpAddresses(self,subs,i,ip,ans): # subs为第i个整数往后子字符串，i为第i个整数，ans储存结果
if len(subs)==0:
return
if i == 4 and int(subs)<=255:
# 去除0开头的非0整数
if len(subs)>1 and subs[0]=="0":
return
ans.append(ip+subs)
return
# 长度不符合
if len(subs)>(5-i)*3:
return
# 切分1到3个字符作为第i个整数
for j in range(1,4):
tmp = subs[:j]
# 去除0开头的非0整数
if j>1 and tmp[0]=='0':
return
# 判断范围
if int(tmp)>255:
return
# 都满足则进入下一个阶段
self.processIpAddresses(subs[j:],i+1,ip+tmp+".",ans)
if __name__ == '__main__':
# s = "25525511135"
s = "0000"
# s = "101023"
sulution = Solution()
ans = sulution.restoreIpAddresses(s)
print(ans)环形链表（leetcode141）
C++
using namespace std;
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(nullptr) {}
};
class Solution {
public:
bool hasCycle(ListNode *head) {
if(head== nullptr) return false;
// 定义快慢指针
ListNode *fast = head;
ListNode *slow = head;
while(fast && fast->next){
fast = fast->next->next;
slow = slow->next;
if(fast==slow) return true;
}
return false;
}
};Python
from typing import Optional
# 环形链表
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def hasCycle(self, head: Optional[ListNode]) -> bool:
if not head:
return False
# 定义快慢指针
fast = head
slow = head
while fast and fast.next:
fast = fast.next.next
slow = slow.next
if slow==fast:
return True
return False环形链表||（leetcode142）
C++
// 环形链表||
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(nullptr) {}
};
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
if (head == nullptr) return nullptr;
// 定义快慢指针
ListNode *fast = head;
ListNode *slow = head;
while (fast && fast->next){
fast = fast->next->next;
slow = slow->next;
if(fast==slow){
while(head != slow){
slow = slow->next;
head = head->next;
}
return slow;
}
}
return nullptr;
}
};Python
from typing import Optional
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
if not head:
return None
# 定义快慢指针
fast = head
slow = head
while fast and fast.next:
fast = fast.next.next
slow = slow.next
if fast==slow:
while head != slow:
head = head.next
slow = slow.next
return slow
return None
