LeetCode笔记204-234中的简单题
刷题笔记
-
- 204 计算质数
- 205 同构字符串
- 206 反转链表
- 217 包含重复
- 217 包含重复Ⅱ
- 225 用队列实现栈
- 226 翻转数组
- 231 二的幂
- 231 用栈实现队列
- 234 回文链表
204 计算质数
题目：统计所有小于非负整数 n 的质数的数量。
思路：
1.最简单的方法：暴力破解。利用双层循环，外层遍历所有数字，内层取小于外层的所有数字，用外层的除以内层的数字，如果余数为0，不是质数。
2.改进的暴力破解：遇到偶数直接跳过，奇数才进行计算。根据规则，只需要计算n的平方根的取余。
3.厄拉多塞
代码：
//1.暴力破解
class Solution {
public:
int countPrimes(int n) {
int count = 0;
for(int i =2;i//2.改进的暴力破解
class Solution {
public:
int countPrimes(int n) {
if(n<3)
return 0;
int count = 1;
for(int i=3;iclass Solution {
public:
int countPrimes(int n) {
int count = 0;
vector sign(n,true);
for(int i=2;i 205 同构字符串
题目：
给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。
思路：
利用哈希表或者红黑树，可以很轻松的解决此类问题。
代码：
class Solution {
public:
bool isIsomorphic(string s, string t) {
mapsmap;
maptmap;
for(int i = 0;i bool:
dic = {}
for i , char in enumerate(s):
if char not in dic:
if t[i] in dic.values():
return False
else:
dic[char] = t[i]
else:
if t[i] != dic[char]:
return False
return True
206 反转链表
题目：反转一个单链表
思路：从head开始，断掉当前节点的指针，将其后面一个节点的指针指向它。
代码：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if(!head)
return head;
if(head->next==NULL)
return head;
if(head->next->next==NULL){
ListNode* temp=head->next;
head->next=NULL;
temp->next=head;
return temp;
}
ListNode* temp1 = head->next;
ListNode* temp2 = temp1->next;
head->next=NULL;
temp1->next=head;
while(temp2->next){
ListNode* temp=temp2;
temp2 = temp2->next;
temp->next = temp1;
temp1=temp;
}
temp2->next=temp1;
return temp2;
}
};
//python代码
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if head == None:
return head;
trueHead=head;
pointer=head.next;
while pointer:
temp = head.next
pointer.next=head
head=pointer
pointer=temp
trueHead.next=None;
return head
217 包含重复
题目：
给定一个整型数组，判断它是否含有重复的元组。
思路：
排个序，再把后一个和前一个比较一下，比较完。。
代码：
class Solution {
public:
bool containsDuplicate(vector& nums) {
if(nums.size()<2)
return false;
sort(nums.begin(),nums.end());
int slow = nums[0];
int fast = nums[1];
for(int i=1;i 217 包含重复Ⅱ
题目：
给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的绝对值最大为 k。
思路：
将元数据一步步填充hashmap，每次遍历再进行一次k值比较。
代码：
class Solution {
public:
bool containsNearbyDuplicate(vector& nums, int k) {
int n = nums.size();
unordered_map map;
for(int i=0;i 225 用队列实现栈
题目：
如题
代码：
class MyStack {
public:
queue q;
int n=0;
/** Initialize your data structure here. */
MyStack() {
}
/** Push element x onto stack. */
void push(int x) {
n++;
q.push(x);
for(int i=0;i 226 翻转数组
题目：
给定一个二叉树，翻转其所有所有子树
思路：
典型的递归题目。DFS或者BFS都行
代码：
//C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if(!root)
return root;
TreeNode* temp = root->left;
root->left = root->right;
root->right = temp;
if(root->left)
invertTree(root->left);
if(root->right)
invertTree(root->right);
return root;
}
};
//python
class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return
root.left,root.right = self.invertTree(root.right),self.invertTree(root.left)
return root
231 二的幂
题目：
给定一个整数，编写一个函数来判断它是否是 2 的幂次方。
思路：
巧妙的方法：将n和(n-1)相与。如果为0，n就是2 的幂次方。
传统方法：不停的除以二，看余数。
代码：
class Solution {
public:
bool isPowerOfTwo(int n) {
return n > 0 ? !(n & n-1) : false;
}
};
class Solution {
public:
bool isPowerOfTwo(int n) {
if(n==0)
return false;
int temp;
while(n!=1)
{
temp=n%2;
if(temp==0)
n=n/2;
else
return false;
}
return true;
}
};
231 用栈实现队列
题目：
用栈实现队列。
思路：
用两个栈来回倒腾
代码：
class MyQueue {
public:
stack s1;
stack s2;
/** Initialize your data structure here. */
MyQueue() {
}
/** Push element x to the back of queue. */
void push(int x) {
while(!s2.empty())
{
int temp = s2.top();
s1.push(temp);
s2.pop();
}
s1.push(x);
}
/** Removes the element from in front of queue and returns that element. */
int pop() {
while(!s1.empty())
{
int temp = s1.top();
s2.push(temp);
s1.pop();
}
int temp = s2.top();
s2.pop();
while(!s2.empty())
{
int temp = s2.top();
s1.push(temp);
s2.pop();
}
return temp;
}
/** Get the front element. */
int peek() {
while(!s1.empty())
{
int temp = s1.top();
s2.push(temp);
s1.pop();
}
int temp = s2.top();
while(!s2.empty())
{
int temp = s2.top();
s1.push(temp);
s2.pop();
}
return temp;
}
/** Returns whether the queue is empty. */
bool empty() {
if(s1.empty())
return true;
else
return false;
}
};
234 回文链表
题目：
请判断一个链表是否为回文链表。
思路：
用快慢指针进行比较；或者放进双端队列比较。
代码：
class Solution {
public:
bool isPalindrome(ListNode* head) {
if(!head || !head->next)
return true;
ListNode* pre=NULL;
ListNode* fast=head;
ListNode* slow=head;
ListNode* s=NULL;
while(fast!=NULL && fast->next!=NULL)
{
pre = slow;
slow = slow->next;
fast = fast->next->next;
pre->next = s;
s = pre;
}
ListNode* temp = slow;
if(fast != NULL)
temp = temp->next;
slow = pre;
while(temp!=NULL)
{
if(temp->val != slow->val)
return false;
else{
temp = temp->next;
slow = slow->next;
}
}
return true;
}
};