Skip to content

Commit e09b73c

Browse files
begeekmyfriendbegeekmyfriend
committed
Add C++ implementation
Signed-off-by: begeekmyfriend <begeekmyfriend@gmail.com>
1 parent bdc5450 commit e09b73c

File tree

7 files changed

+295
-169
lines changed

7 files changed

+295
-169
lines changed

‎0076_minimum_window_substring/window_substring.cc

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
#include <bits/stdc++.h>
2+
3+
using namespace std;
4+
5+
class Solution {
6+
public:
7+
string minWindow(string s, string t) {
8+
vector<int> count(128);
9+
for (char c : t) {
10+
count[c]++;
11+
}
12+
13+
int l = 0, r = 0;
14+
int need_to_meet = t.length();
15+
int start, min_len = INT_MAX;
16+
while (r < s.length()) {
17+
if (--count[s[r++]] >= 0) {
18+
need_to_meet--;
19+
}
20+
21+
while (need_to_meet == 0) {
22+
if (r - l < min_len) {
23+
start = l;
24+
min_len = r - l;
25+
}
26+
if (++count[s[l++]] > 0) {
27+
need_to_meet++;
28+
}
29+
}
30+
}
31+
32+
return min_len == INT_MAX ? "" : s.substr(start, min_len);
33+
}
34+
};

‎0102_binary_tree_level_order_traversal/bst_bfs.c

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -69,23 +69,23 @@ static inline void list_del(struct list_head *entry)
6969
entry->next = entry->prev = NULL;
7070
}
7171

72-
static struct queue_node *node_new(struct list_head *free_list, struct TreeNode *node)
72+
static struct queue_node *node_new(struct TreeNode *node, struct list_head *free_list)
7373
{
74-
struct queue_node *new;
74+
struct queue_node *qn;
7575
if (list_empty(free_list)) {
76-
new = malloc(sizeof(*new));
76+
qn = malloc(sizeof(*qn));
7777
} else {
78-
new = list_first_entry(free_list, struct queue_node, link);
79-
list_del(&new->link);
78+
qn = list_first_entry(free_list, struct queue_node, link);
79+
list_del(&qn->link);
8080
}
81-
new->node = node;
82-
return new;
81+
qn->node = node;
82+
return qn;
8383
}
8484

85-
static void node_free(struct list_head *free_list, struct queue_node *node)
85+
static void node_free(struct queue_node *qn, struct list_head *free_list)
8686
{
87-
list_del(&node->link);
88-
list_add(&node->link, free_list);
87+
list_del(&qn->link);
88+
list_add(&qn->link, free_list);
8989
}
9090

9191
/**
@@ -110,7 +110,7 @@ static int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColu
110110
memset(*returnColumnSizes, 0, BST_MAX_LEVEL * sizeof(int));
111111

112112
/* Add root node */
113-
struct queue_node *new = node_new(&free_list, root);
113+
struct queue_node *new = node_new(root, &free_list);
114114
list_add_tail(&new->link, &q);
115115

116116
int i, level = 0;
@@ -119,21 +119,21 @@ static int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColu
119119
int size = (*returnColumnSizes)[level];
120120
results[level] = malloc(size * sizeof(int));
121121
for (i = 0; i < size; i++) {
122-
struct queue_node *n = list_first_entry(&q, struct queue_node, link);
123-
results[level][i] = n->node->val;
122+
struct queue_node *qn = list_first_entry(&q, struct queue_node, link);
123+
results[level][i] = qn->node->val;
124124

125-
if (n->node->left != NULL) {
126-
new = node_new(&free_list, n->node->left);
125+
if (qn->node->left != NULL) {
126+
new = node_new(qn->node->left, &free_list);
127127
list_add_tail(&new->link, &q);
128128
(*returnColumnSizes)[level + 1]++;
129129
}
130-
if (n->node->right != NULL) {
131-
new = node_new(&free_list, n->node->right);
130+
if (qn->node->right != NULL) {
131+
new = node_new(qn->node->right, &free_list);
132132
list_add_tail(&new->link, &q);
133133
(*returnColumnSizes)[level + 1]++;
134134
}
135135

136-
node_free(&free_list, n);
136+
node_free(qn, &free_list);
137137
}
138138
level++;
139139
}

‎0103_binary_tree_zigzag_level_order_traversal/bst_zigzag.c

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -68,23 +68,23 @@ static inline void list_del(struct list_head *entry)
6868
entry->next = entry->prev = NULL;
6969
}
7070

71-
static struct queue_node *node_new(struct list_head *free_list, struct TreeNode *node)
71+
static struct queue_node *node_new(struct TreeNode *node, struct list_head *free_list)
7272
{
73-
struct queue_node *new;
73+
struct queue_node *qn;
7474
if (list_empty(free_list)) {
75-
new = malloc(sizeof(*new));
75+
qn = malloc(sizeof(*qn));
7676
} else {
77-
new = list_first_entry(free_list, struct queue_node, link);
78-
list_del(&new->link);
77+
qn = list_first_entry(free_list, struct queue_node, link);
78+
list_del(&qn->link);
7979
}
80-
new->node = node;
81-
return new;
80+
qn->node = node;
81+
return qn;
8282
}
8383

84-
static void node_free(struct list_head *free_list, struct queue_node *node)
84+
static void node_free(struct queue_node *qn, struct list_head *free_list)
8585
{
86-
list_del(&node->link);
87-
list_add(&node->link, free_list);
86+
list_del(&qn->link);
87+
list_add(&qn->link, free_list);
8888
}
8989

9090
/**
@@ -109,7 +109,7 @@ static int** zigzagLevelOrder(struct TreeNode* root, int* returnSize, int** retu
109109
memset(*returnColumnSizes, 0, BST_MAX_LEVEL * sizeof(int));
110110

111111
/* Add root node */
112-
struct queue_node *new = node_new(&free_list, root);
112+
struct queue_node *new = node_new(root, &free_list);
113113
list_add_tail(&new->link, &q);
114114

115115
int i, level = 0;
@@ -118,25 +118,25 @@ static int** zigzagLevelOrder(struct TreeNode* root, int* returnSize, int** retu
118118
int size = (*returnColumnSizes)[level];
119119
results[level] = malloc(size * sizeof(int));
120120
for (i = 0; i < size; i++) {
121-
struct queue_node *n = list_first_entry(&q, struct queue_node, link);
121+
struct queue_node *qn = list_first_entry(&q, struct queue_node, link);
122122
if (level & 0x1) {
123-
results[level][size - i - 1] = n->node->val;
123+
results[level][size - i - 1] = qn->node->val;
124124
} else {
125-
results[level][i] = n->node->val;
125+
results[level][i] = qn->node->val;
126126
}
127127

128-
if (n->node->left != NULL) {
129-
new = node_new(&free_list, n->node->left);
128+
if (qn->node->left != NULL) {
129+
new = node_new(qn->node->left, &free_list);
130130
list_add_tail(&new->link, &q);
131131
(*returnColumnSizes)[level + 1]++;
132132
}
133-
if (n->node->right != NULL) {
134-
new = node_new(&free_list, n->node->right);
133+
if (qn->node->right != NULL) {
134+
new = node_new(qn->node->right, &free_list);
135135
list_add_tail(&new->link, &q);
136136
(*returnColumnSizes)[level + 1]++;
137137
}
138138

139-
node_free(&free_list, n);
139+
node_free(qn, &free_list);
140140
}
141141
level++;
142142
}

‎0117_populating_next_right_pointers_in_each_node_ii/connect.c

Lines changed: 83 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,6 @@
11
#include <stdio.h>
22
#include <stdlib.h>
33

4-
struct TreeLinkNode {
5-
int val;
6-
struct TreeLinkNode *left;
7-
struct TreeLinkNode *right;
8-
struct TreeLinkNode *next;
9-
};
104

115
#define container_of(ptr, type, member) \
126
((type *)((char *)(ptr) - (size_t)&(((type *)0)->member)))
@@ -17,16 +11,22 @@ struct TreeLinkNode {
1711
#define list_first_entry(ptr, type, field) list_entry((ptr)->next, type, field)
1812
#define list_last_entry(ptr, type, field) list_entry((ptr)->prev, type, field)
1913

20-
#define list_for_each(p, head) \
21-
for (p = (head)->next; p != (head); p = p->next)
22-
23-
#define list_for_each_safe(p, n, head) \
24-
for (p = (head)->next, n = p->next; p != (head); p = n, n = p->next)
25-
2614
struct list_head {
2715
struct list_head *next, *prev;
2816
};
2917

18+
struct Node {
19+
int val;
20+
struct Node *left;
21+
struct Node *right;
22+
struct Node *next;
23+
};
24+
25+
struct queue_node {
26+
struct Node *node;
27+
struct list_head link;
28+
};
29+
3030
static inline void INIT_LIST_HEAD(struct list_head *list)
3131
{
3232
list->next = list->prev = list;
@@ -67,87 +67,72 @@ static inline void list_del(struct list_head *entry)
6767
entry->next = entry->prev = NULL;
6868
}
6969

70-
struct bfs_node {
71-
struct TreeLinkNode *node;
72-
struct list_head link;
73-
};
74-
75-
static struct bfs_node *node_fetch(struct list_head *free_list, struct TreeLinkNode *node)
70+
static struct queue_node *node_new(struct Node *node, struct list_head *free_list)
7671
{
77-
struct bfs_node *bn = list_first_entry(free_list, struct bfs_node, link);
78-
list_del(&bn->link);
79-
bn->node = node;
80-
return bn;
72+
struct queue_node *qn;
73+
if (list_empty(free_list)) {
74+
qn = malloc(sizeof(*qn));
75+
} else {
76+
qn = list_first_entry(free_list, struct queue_node, link);
77+
list_del(&qn->link);
78+
}
79+
qn->node = node;
80+
return qn;
8181
}
8282

83-
static void queue(struct list_head *parents, struct list_head *children, struct list_head *free_list)
83+
static void node_free(struct queue_node *qn, struct list_head *free_list)
8484
{
85-
struct list_head *p, *n;
86-
struct TreeLinkNode *prev = NULL;
87-
list_for_each_safe(p, n, parents) {
88-
struct bfs_node *new;
89-
struct bfs_node *parent = list_entry(p, struct bfs_node, link);
90-
struct TreeLinkNode *lch = parent->node->left;
91-
struct TreeLinkNode *rch = parent->node->right;
92-
if (lch != NULL) {
93-
if (prev != NULL) {
94-
prev->next = lch;
95-
}
96-
prev = lch;
97-
new = node_fetch(free_list, lch);
98-
list_add_tail(&new->link, children);
99-
}
100-
if (rch != NULL) {
101-
if (prev != NULL) {
102-
prev->next = rch;
103-
}
104-
prev = rch;
105-
new = node_fetch(free_list, rch);
106-
list_add_tail(&new->link, children);
107-
}
108-
109-
/* return */
110-
list_del(p);
111-
list_add(p, free_list);
112-
}
85+
list_del(&qn->link);
86+
list_add_tail(&qn->link, free_list);
11387
}
11488

115-
static void connect(struct TreeLinkNode *root)
89+
struct Node *connect(struct Node *root)
11690
{
11791
if (root == NULL) {
118-
return;
92+
return root;
11993
}
12094

12195
struct list_head free_list;
122-
struct list_head q0;
123-
struct list_head q1;
124-
struct bfs_node nodes[4096];
96+
struct list_head q;
12597
INIT_LIST_HEAD(&free_list);
126-
INIT_LIST_HEAD(&q0);
127-
INIT_LIST_HEAD(&q1);
98+
INIT_LIST_HEAD(&q);
12899

129-
int i;
130-
for (i = 0; i < 4096; i++) {
131-
list_add(&nodes[i].link, &free_list);
132-
}
100+
int i, level_size = 1;
101+
struct queue_node *new = node_new(root, &free_list);
102+
list_add_tail(&new->link, &q);
103+
104+
while (!list_empty(&q)) {
105+
struct Node *prev = NULL;
106+
int size = level_size;
107+
for (i = 0; i < size; i++) {
108+
struct queue_node *qn = list_first_entry(&q, struct queue_node, link);
109+
if (prev != NULL) {
110+
prev->next = qn->node;
111+
}
112+
prev = qn->node;
133113

134-
int level = 0;
135-
struct bfs_node *new = node_fetch(&free_list, root);
136-
list_add_tail(&new->link, &q0);
114+
if (qn->node->left != NULL) {
115+
new = node_new(qn->node->left, &free_list);
116+
list_add_tail(&new->link, &q);
117+
level_size++;
118+
}
119+
if (qn->node->right != NULL) {
120+
new = node_new(qn->node->right, &free_list);
121+
list_add_tail(&new->link, &q);
122+
level_size++;
123+
}
137124

138-
while (!list_empty(&q0) || !list_empty(&q1)) {
139-
if (level & 0x1) {
140-
queue(&q1, &q0, &free_list);
141-
} else {
142-
queue(&q0, &q1, &free_list);
125+
node_free(qn, &free_list);
143126
}
144-
level++;
145127
}
128+
129+
return root;
146130
}
147131

148132
int main(int argc, char **argv)
149133
{
150-
struct TreeLinkNode root, n1[2], n2[4], n3[8];
134+
struct Node root, n1[2], n2[4], n3[8];
135+
#if 0
151136
root.val = 5;
152137
n1[0].val = 4;
153138
n1[1].val = 8;
@@ -188,6 +173,32 @@ int main(int argc, char **argv)
188173
n3[7].left = NULL;
189174
n3[7].right = NULL;
190175
n3[7].next = NULL;
176+
#else
177+
root.val = 1;
178+
n1[0].val = 2;
179+
n1[1].val = 3;
180+
n2[0].val = 4;
181+
n2[1].val = 5;
182+
n2[3].val = 7;
183+
184+
root.left = &n1[0];
185+
root.right = &n1[1];
186+
n1[0].left = &n2[0];
187+
n1[0].right = &n2[1];
188+
n1[0].next = NULL;
189+
n1[1].left = NULL;
190+
n1[1].right = &n2[3];
191+
n1[1].next = NULL;
192+
n2[0].left = NULL;
193+
n2[0].right = NULL;
194+
n2[0].next = NULL;
195+
n2[1].left = NULL;
196+
n2[1].right = NULL;
197+
n2[1].next = NULL;
198+
n2[3].left = NULL;
199+
n2[3].right = NULL;
200+
n2[3].next = NULL;
201+
#endif
191202

192203
connect(&root);
193204
return 0;

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy