基本语法
长度
- python
s = "hello world"
li = [1,3,2]
len(s)
len(li)
- c++
s.length()
li.size()
- java
li.length
标准化输入&输出
- python
print("Hi")
- c++
在C++中，标准的输入输出是使用iostream库，cin为标准输入，cout为标准输出，cerr为输出警告和报告错误消息。clog是用来输出程序运行的一般信息。
int v1,v2;
cin >> v1 >> v2;
cout << v1 + v2 << endl;
- java
Java遵循标准I/O的模型，提供了Syetem.in，System.out，以及System.err。- System.out是一个已经预先处理过的，被包装成PrintStream的对象。
- System.err和System.out一样，也是一个PrintStream
- 但是System.in不是，它是一个未经处理的InputStream。
也就是说，可以直接使用System.out和System.err打印输出到控制台，但是使用System.in直接读取数据不可以，必须先做处理。
所以先只看输出吧……
System.out.println("Hello") //输出信息后追加一个换行
System.out.print("world") //输出之后不追加换行
for 循环
- python
for i in range(len(prices)):
# do something
for p in prices:
# do something
- c++
for (int i = 0; i < prices.size(); i ++){
// do something
}
for (int p: prices){
// do something
}
// 看一下auto的用法
// 遍历字符串
std::string str = “hello, world”;
for(auto ch : str) {
std::cout << ch << std::endl;
}
// 遍历数组
int arr[] = {1, 2, 3, 4};
for(auto i : arr) {
std::cout<< i << std::endl;
}
//遍历stl vector，通过引用可修改内存
std::vector<std::string> str_vec = {"i", "like", "google"};
for(auto& it : str_vec) {
it = “c++”;
}
// 遍历stl map
std::map<int, std::string> hash_map = {{1, “c++”}, {2, “java”}, {3, “python”}};
for(auto it : hash_map) {
std::cout << it.first << “\t” << it.second << std::endl;
}
- java
for (int i = 0; i < prices.length; i++){
//do something
}
无穷
- python
a = float('inf')
b = float('-inf') # b = - float('inf')
- c++
int a = INT_MAX;
int b = INT_MIN;
- java
int a = Integer.MAX_VALUE
int b = Integer.MIN_VALUE
整除
- python
3 // 2 # 1
3 / 2 # 1.5
- c++
3 / 2 // 1
- java
3 / 2 // 1
比较两个数的大小（abs同理）
- python
min_num = min(a, b)
max_num = max(a, b)
- c++
int min_num = min(a, b);
int max_num = max(a, b);
- java
int min_num = Math.min(a, b);
int max_num = Math.max(a, b);
bool
- python
used = [False] * len(nums)
- c++
vector<bool> used(nums.size(), false);
- java
boolean[] used= new boolean[nums.length]; # 默认false
数据结构
数组
- python
path = []
path.append(root.val)
del path[-1]
- c++
vector<int> path;
path.push_back(root -> val);
path.pop_back();
- java
// 双端队列
Deque<Integer> path = new ArrayDeque<>();
path.addLast(root.val);
path.removeLast();
二维数组
- python
arr = [[0] * n for _ in range(k)]
- c++
// 方法1
//申请空间
int** a = new int*[rows];
for(int i = 0; i < rows; i++)
a[i] = new int[columns];
//释放空间
for(int i = 0; i < rows; i++)
delete []a2[i];
delete []a2;
// 方法2 静态初始化
int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
int a2[3][4] = {
{0, 1, 2, 3} , /* 初始化索引号为 0 的行 */
{4, 5, 6, 7} , /* 初始化索引号为 1 的行 */
{8, 9, 10, 11} /* 初始化索引号为 2 的行 */
};
// 方法3 vector
int N = 5, M = 6;
vector<vector<int> > obj(N, vector<int>(M)); //定义二维动态数组5行6列
// 遍历
for(int i = 0; i< obj.size(); i++)//输出二维动态数组
{
for(int j = 0; j < obj[i].size(); j++)
{
cout << obj[i][j] << " ";
}
cout << "\n";
}
- java
// new出来的会初始化到0
// 方法1 固定大小
int[][] arr=new int[3][2];
// 方法2 每个一维数组的长度不固定
int[][] arr=new int[3][];
arr[0] = new int[2];
arr[1]= new int[3];
arr[2]=new int[1];
// 方法3 静态初始化
int[][] arr={{1,2,3},{4,6},{6}}
// 遍历
public static void printArray(int[][] arr){
for(int x = 0; x < arr.length; x ++){
for(int y = 0; y < arr[x].length; y ++){
System.out.print(arr[x][y]);
}
System.out.println();
}
//别的方法
ArrayList<ArrayList<Integer>> resSet = ArrayList<ArrayList<Integer>>();
ArrayList<Integer> res = new ArrayList<Integer>(3);
res.add(1);
res.add(2);
res.add(3);
resSet.add(res);
队列
- python
from collections import deque
queue = deque([root])
n = len(queue)
curr = queue.popleft()
if curr.left is not None:
queue.append(curr.left)
- c++
queue<TreeNode*> nodeQueue;
nodeQueue.push(root);
int n = nodeQueue.size();
TreeNode* curr = nodeQueue.front();
nodeQueue.pop();
if (curr->left != NULL){
nodeQueue.push(curr->left);
}
- java
Queue<TreeNode> queue = new LinkedList<TreeNode>(); // Queue
queue.offer(root); // offer
int n = queue.size();
TreeNode curr = queue.poll();
if (curr.left != null){
queue.offer(curr.left);
}
树
- python
# 节点为空
if root is None:
- c++
// 节点为空
if (root == NULL)
- java
// 节点为空
if (root == null)
哈希映射 map
- python
# 一般做法，使用dict()
# 但如果key不存在，直接索引报错；需要收到设置默认值
words = ['hello', 'world', 'nice', 'world']
counter = dict()
for kw in words:
# 如果不存在，返回默认值；如果存在，返回该值
counter[kw] = counter.setdefault(kw, 0) + 1
freq = counter.pop('hello')
del counter['nice']
# 高阶做法，使用defaultdict()，可接受factory_function，自动设定默认值
from collections import defaultdict
dd = defaultdict(list)
dd['hh']#defaultdict(<type 'list'>, {'hh': []})
dd['hh'].append('haha')#defaultdict(<type 'list'>, {'hh': ['haha']})
# 遍历
for (key, value) in dd.items():
if key == value:
# do something
- c++
int类型自动默认成0，而且遍历是会自动由小到大排序
// 定义一个map对象
map<int, string> mapStudent;
// 插入
mapStudent.insert(pair<int, string>(000, "student_zero"));
mapStudent[123] = "student_first";
// 查看大小
int nSize = mapStudent.size();
// 操作
for(const auto& p : mapStudent)
cout << p.first << ": " << p.second << "\n";
// 删除
int n = mapStudent.erase("123"); //如果刪除了會返回1，否則返回0
// 遍历
map<int, int> m;
m[1] = 0;
m[3] = 2;
m[2] = 3;
for (auto [k, v] : m){
cout << k << " " << v << endl;
}
// 1 0
// 2 3
// 3 2
// 从int到set的映射{1:{1,2,3}, 2:{2,3,4}}
unordered_map<int, unordered_set<int>> dp;
for (auto position : stones)
dp[position] = unordered_set<int>();
// 在dp中找元素值，如果没找到，就返回dp.end()
dp.find(position + step - 1) != dp.end()
- java
// 从int到set的映射{1:{1,2,3}, 2:{2,3,4}}
HashMap<Integer, HashSet<Integer>> dp =
new HashMap<Integer, HashSet<Integer>>(stones.length);
for (int i = 0; i < stones.length; i++) {
dp.put(stones[i], new HashSet<Integer>() );
}
// 返回该key的value
dp.get(0)
// 判断是否含有某元素
dp.containsKey(stone + step)
集合 set
- python
s = set()
s.add(1) #s={1}
s.remove(1)
len(s) > 0
- c++
// 第一种
set<int> s;
s.insert(8);
s.erase(8);
// 第二种
unordered_set<int> s;
s.insert(8);
if s.empty() // true or false
- java
HashSet<Integer> s = new HashSet<Integer>();
s.add(8);
if s.isEmpty()// true or false
排序
- python
num = sorted(num)
- c++
// vector<int> &nums
sort(nums.begin(), nums.end());
- java
// int[] nums
Arrays.sort(num);
边界
- java
# int[] A;
if (A == null) || A.length == 0) return -1;
网友评论