1010
1111> 编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组 ` char[] ` 的形式给出。
1212
13- ``` go
14- func reverseString (s []byte ) {
15- res := make ([]byte , 0 )
16- reverse (s, 0 , &res)
17- for i := 0 ; i < len (s); i++ {
18- s[i] = res[i]
19- }
13+ ``` c++
14+ void reverseString (vector<char > &s) {
15+ reverse(s, 0, s.size() - 1);
2016}
21- func reverse (s []byte , i int , res *[]byte ) {
22- if i == len (s) {
23- return
24- }
25- reverse (s, i+1 , res)
26- *res = append (*res, s[i])
17+ 18+ void reverse(vector<char > &s, int left, int right) {
19+ if (left >= right) {
20+ return;
21+ }
22+ swap(s[ left++] , s[ right--] );
23+ reverse(s, left, right);
2724}
2825```
2926
@@ -32,58 +29,56 @@ func reverse(s []byte, i int, res *[]byte) {
3229> 给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。
3330> **你不能只是单纯的改变节点内部的值**,而是需要实际的进行节点交换。
3431
35- ``` go
36- func swapPairs (head *ListNode ) *ListNode {
37- // 思路:将链表翻转转化为一个子问题,然后通过递归方式依次解决
38- // 先翻转两个,然后将后面的节点继续这样翻转,然后将这些翻转后的节点连接起来
39- return helper (head)
32+ ```c++
33+ ListNode* swapPairs(ListNode* head) {
34+ return swapper(head);
4035}
41- func helper (head *ListNode )*ListNode {
42- if head==nil ||head.Next ==nil {
43- return head
36+
37+ ListNode* swapper(ListNode *head) {
38+ if (head == nullptr || head->next == nullptr) {
39+ return head;
4440 }
45- // 保存下一阶段的头指针
46- nextHead := head.Next .Next
47- // 翻转当前阶段指针
48- next := head.Next
49- next.Next =head
50- head.Next =helper (nextHead)
51- return next
41+ auto nextHead = head->next->next;
42+ auto newHead = head->next;
43+ newHead->next = head;
44+ head->next = swapper(nextHead);
45+ return newHead;
5246}
5347```
5448
5549[ unique-binary-search-trees-ii] ( https://leetcode-cn.com/problems/unique-binary-search-trees-ii/ )
5650
5751> 给定一个整数 n,生成所有由 1 ... n 为节点所组成的二叉搜索树。
5852
59- ``` go
60- func generateTrees (n int ) []* TreeNode {
61- if n== 0 {
62- return nil
53+ ``` c++
54+ vector<TreeNode *> generateTrees (int n) {
55+ if (n == 0) {
56+ return {};
6357 }
64- return generate (1 ,n)
65- 58+ return generate(1, n);
6659}
67- func generate (start ,end int )[]*TreeNode {
68- if start>end{
69- return []*TreeNode{nil }
60+ 61+ vector<TreeNode * > generate(int start, int end) {
62+ if (start > end) {
63+ // 记得返回nullptr,不可返回空vector
64+ return {nullptr};
7065 }
71- ans := make ([]* TreeNode, 0 )
72- for i := start;i<= end;i++ {
73- // 递归生成所有左右子树
74- lefts := generate (start,i- 1 )
75- rights := generate (i+ 1 , end)
76- // 拼接左右子树后返回
77- for j := 0 ;j< len ( lefts);j++ {
78- for k := 0 ;k< len ( rights);k++ {
79- root := & TreeNode{Val:i}
80- root. Left =lefts[j]
81- root. Right =rights[k]
82- ans= append (ans, root)
66+ vector< TreeNode* > ans;
67+ for (int i = start; i <= end; ++i) {
68+ // 取i作为根节点,生成所有左右子树
69+ auto lefts = generate(start, i - 1);
70+ auto rights = generate(i + 1, end);
71+ // 拼接
72+ for (auto &left : lefts){
73+ for (auto &right : rights){
74+ auto root = new TreeNode(i);
75+ root->left = left;
76+ root->right = right;
77+ ans.push_back( root);
8378 }
8479 }
8580 }
86- return ans
81+ return ans;
8782}
8883```
8984
@@ -96,23 +91,23 @@ func generate(start,end int)[]*TreeNode{
9691> F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
9792> 给定 N,计算 F(N)。
9893
99- ``` go
100- func fib (N int ) int {
101- return dfs (N)
94+ ```c++
95+ unordered_map<int, int> memo;
96+
97+ int fib(int N) {
98+ return fibWithMemo(N);
10299}
103- var m map [ int ] int = make ( map [ int ] int )
104- func dfs ( n int ) int {
105- if n < 2 {
106- return n
100+
101+ int fibWithMemo( int N) {
102+ if (N < 2) {
103+ return N;
107104 }
108- // 读取缓存
109- if m[n]!=0 {
110- return m[n]
105+ if (memo[N] != 0) {
106+ return memo[N];
111107 }
112- ans := dfs (n-2 )+dfs (n-1 )
113- // 缓存已经计算过的值
114- m[n]=ans
115- return ans
108+ auto ret = fibWithMemo(N - 1) + fib(N - 2);
109+ memo[N] = ret;
110+ return ret;
116111}
117112```
118113
0 commit comments