Skip to content

Commit 3d6128e

Browse files
YangFongYangFong
committed
feat: add solutions to lcci problems
- No.03.02.Min Stack - No.03.03.Stack of Plates - No.03.04.Implement Queue using Stacks - No.03.05.Sort of Stacks
1 parent 41760dc commit 3d6128e

File tree

13 files changed

+845
-0
lines changed

13 files changed

+845
-0
lines changed

‎lcci/03.02.Min Stack/README.md

+99
Original file line numberDiff line numberDiff line change
@@ -97,6 +97,51 @@ class MinStack {
9797
*/
9898
```
9999

100+
### **C++**
101+
102+
```cpp
103+
class MinStack {
104+
private:
105+
stack<int> stk;
106+
stack<int> minStk;
107+
public:
108+
/** initialize your data structure here. */
109+
MinStack() = default;
110+
111+
void push(int x) {
112+
if (minStk.empty() || minStk.top() >= x) {
113+
minStk.push(x);
114+
}
115+
stk.push(x);
116+
}
117+
118+
void pop() {
119+
int val = stk.top();
120+
stk.pop();
121+
if (val == minStk.top()) {
122+
minStk.pop();
123+
}
124+
}
125+
126+
int top() {
127+
return stk.top();
128+
}
129+
130+
int getMin() {
131+
return minStk.top();
132+
}
133+
};
134+
135+
/**
136+
* Your MinStack object will be instantiated and called as such:
137+
* MinStack* obj = new MinStack();
138+
* obj->push(x);
139+
* obj->pop();
140+
* int param_3 = obj->top();
141+
* int param_4 = obj->getMin();
142+
*/
143+
```
144+
100145
### **TypeScript**
101146

102147
```ts
@@ -188,6 +233,60 @@ func (this *MinStack) GetMin() int {
188233
*/
189234
```
190235

236+
### **Rust**
237+
238+
```rust
239+
use std::collections::VecDeque;
240+
struct MinStack {
241+
stack: VecDeque<i32>,
242+
min_stack: VecDeque<i32>,
243+
}
244+
245+
246+
/**
247+
* `&self` means the method takes an immutable reference.
248+
* If you need a mutable reference, change it to `&mut self` instead.
249+
*/
250+
impl MinStack {
251+
252+
/** initialize your data structure here. */
253+
fn new() -> Self {
254+
Self { stack: VecDeque::new(), min_stack: VecDeque::new() }
255+
}
256+
257+
fn push(&mut self, x: i32) {
258+
self.stack.push_back(x);
259+
if self.min_stack.is_empty() || *self.min_stack.back().unwrap() >= x {
260+
self.min_stack.push_back(x);
261+
}
262+
}
263+
264+
fn pop(&mut self) {
265+
let val = self.stack.pop_back().unwrap();
266+
if *self.min_stack.back().unwrap() == val {
267+
self.min_stack.pop_back();
268+
}
269+
}
270+
271+
fn top(&self) -> i32 {
272+
*self.stack.back().unwrap()
273+
}
274+
275+
fn get_min(&self) -> i32 {
276+
*self.min_stack.back().unwrap()
277+
}
278+
}
279+
280+
/**
281+
* Your MinStack object will be instantiated and called as such:
282+
* let obj = MinStack::new();
283+
* obj.push(x);
284+
* obj.pop();
285+
* let ret_3: i32 = obj.top();
286+
* let ret_4: i32 = obj.get_min();
287+
*/
288+
```
289+
191290
### **...**
192291

193292
```

‎lcci/03.02.Min Stack/README_EN.md

+99
Original file line numberDiff line numberDiff line change
@@ -108,6 +108,51 @@ class MinStack {
108108
*/
109109
```
110110

111+
### **C++**
112+
113+
```cpp
114+
class MinStack {
115+
private:
116+
stack<int> stk;
117+
stack<int> minStk;
118+
public:
119+
/** initialize your data structure here. */
120+
MinStack() = default;
121+
122+
void push(int x) {
123+
if (minStk.empty() || minStk.top() >= x) {
124+
minStk.push(x);
125+
}
126+
stk.push(x);
127+
}
128+
129+
void pop() {
130+
int val = stk.top();
131+
stk.pop();
132+
if (val == minStk.top()) {
133+
minStk.pop();
134+
}
135+
}
136+
137+
int top() {
138+
return stk.top();
139+
}
140+
141+
int getMin() {
142+
return minStk.top();
143+
}
144+
};
145+
146+
/**
147+
* Your MinStack object will be instantiated and called as such:
148+
* MinStack* obj = new MinStack();
149+
* obj->push(x);
150+
* obj->pop();
151+
* int param_3 = obj->top();
152+
* int param_4 = obj->getMin();
153+
*/
154+
```
155+
111156
### **TypeScript**
112157

113158
```ts
@@ -199,6 +244,60 @@ func (this *MinStack) GetMin() int {
199244
*/
200245
```
201246

247+
### **Rust**
248+
249+
```rust
250+
use std::collections::VecDeque;
251+
struct MinStack {
252+
stack: VecDeque<i32>,
253+
min_stack: VecDeque<i32>,
254+
}
255+
256+
257+
/**
258+
* `&self` means the method takes an immutable reference.
259+
* If you need a mutable reference, change it to `&mut self` instead.
260+
*/
261+
impl MinStack {
262+
263+
/** initialize your data structure here. */
264+
fn new() -> Self {
265+
Self { stack: VecDeque::new(), min_stack: VecDeque::new() }
266+
}
267+
268+
fn push(&mut self, x: i32) {
269+
self.stack.push_back(x);
270+
if self.min_stack.is_empty() || *self.min_stack.back().unwrap() >= x {
271+
self.min_stack.push_back(x);
272+
}
273+
}
274+
275+
fn pop(&mut self) {
276+
let val = self.stack.pop_back().unwrap();
277+
if *self.min_stack.back().unwrap() == val {
278+
self.min_stack.pop_back();
279+
}
280+
}
281+
282+
fn top(&self) -> i32 {
283+
*self.stack.back().unwrap()
284+
}
285+
286+
fn get_min(&self) -> i32 {
287+
*self.min_stack.back().unwrap()
288+
}
289+
}
290+
291+
/**
292+
* Your MinStack object will be instantiated and called as such:
293+
* let obj = MinStack::new();
294+
* obj.push(x);
295+
* obj.pop();
296+
* let ret_3: i32 = obj.top();
297+
* let ret_4: i32 = obj.get_min();
298+
*/
299+
```
300+
202301
### **...**
203302

204303
```

‎lcci/03.02.Min Stack/Solution.cpp

+40
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
class MinStack {
2+
private:
3+
stack<int> stk;
4+
stack<int> minStk;
5+
public:
6+
/** initialize your data structure here. */
7+
MinStack() = default;
8+
9+
void push(int x) {
10+
if (minStk.empty() || minStk.top() >= x) {
11+
minStk.push(x);
12+
}
13+
stk.push(x);
14+
}
15+
16+
void pop() {
17+
int val = stk.top();
18+
stk.pop();
19+
if (val == minStk.top()) {
20+
minStk.pop();
21+
}
22+
}
23+
24+
int top() {
25+
return stk.top();
26+
}
27+
28+
int getMin() {
29+
return minStk.top();
30+
}
31+
};
32+
33+
/**
34+
* Your MinStack object will be instantiated and called as such:
35+
* MinStack* obj = new MinStack();
36+
* obj->push(x);
37+
* obj->pop();
38+
* int param_3 = obj->top();
39+
* int param_4 = obj->getMin();
40+
*/

‎lcci/03.02.Min Stack/Solution.rs

+49
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
use std::collections::VecDeque;
2+
struct MinStack {
3+
stack: VecDeque<i32>,
4+
min_stack: VecDeque<i32>,
5+
}
6+
7+
8+
/**
9+
* `&self` means the method takes an immutable reference.
10+
* If you need a mutable reference, change it to `&mut self` instead.
11+
*/
12+
impl MinStack {
13+
14+
/** initialize your data structure here. */
15+
fn new() -> Self {
16+
Self { stack: VecDeque::new(), min_stack: VecDeque::new() }
17+
}
18+
19+
fn push(&mut self, x: i32) {
20+
self.stack.push_back(x);
21+
if self.min_stack.is_empty() || *self.min_stack.back().unwrap() >= x {
22+
self.min_stack.push_back(x);
23+
}
24+
}
25+
26+
fn pop(&mut self) {
27+
let val = self.stack.pop_back().unwrap();
28+
if *self.min_stack.back().unwrap() == val {
29+
self.min_stack.pop_back();
30+
}
31+
}
32+
33+
fn top(&self) -> i32 {
34+
*self.stack.back().unwrap()
35+
}
36+
37+
fn get_min(&self) -> i32 {
38+
*self.min_stack.back().unwrap()
39+
}
40+
}
41+
42+
/**
43+
* Your MinStack object will be instantiated and called as such:
44+
* let obj = MinStack::new();
45+
* obj.push(x);
46+
* obj.pop();
47+
* let ret_3: i32 = obj.top();
48+
* let ret_4: i32 = obj.get_min();
49+
*/

‎lcci/03.03.Stack of Plates/README.md

+60
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,66 @@
4949

5050
```
5151

52+
### **TypeScript**
53+
54+
```ts
55+
class StackOfPlates {
56+
private cap: number;
57+
private stacks: number[][];
58+
59+
constructor(cap: number) {
60+
this.cap = cap;
61+
this.stacks = [];
62+
}
63+
64+
push(val: number): void {
65+
if (this.cap === 0) {
66+
return;
67+
}
68+
const n = this.stacks.length;
69+
const stack = this.stacks[n - 1];
70+
if (stack == null || stack.length === this.cap) {
71+
this.stacks.push([val]);
72+
} else {
73+
stack.push(val);
74+
}
75+
}
76+
77+
pop(): number {
78+
const n = this.stacks.length;
79+
if (n === 0) {
80+
return -1;
81+
}
82+
const stack = this.stacks[n - 1];
83+
const res = stack.pop();
84+
if (stack.length === 0) {
85+
this.stacks.pop();
86+
}
87+
return res;
88+
}
89+
90+
popAt(index: number): number {
91+
if (index >= this.stacks.length) {
92+
return -1;
93+
}
94+
const stack = this.stacks[index];
95+
const res = stack.pop();
96+
if (stack.length === 0) {
97+
this.stacks.splice(index, 1);
98+
}
99+
return res;
100+
}
101+
}
102+
103+
/**
104+
* Your StackOfPlates object will be instantiated and called as such:
105+
* var obj = new StackOfPlates(cap)
106+
* obj.push(val)
107+
* var param_2 = obj.pop()
108+
* var param_3 = obj.popAt(index)
109+
*/
110+
```
111+
52112
### **...**
53113

54114
```

0 commit comments

Comments
 (0)