c/stack.cpp at master · misa-bot/c · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<bits/stdc++.h>
usingnamespacestd;
#defineMAX1000
classStack {
int top;

public:
int a[MAX];

Stack() { top = -1; }
boolpush(int x);
intpop();
intpeek();
boolisEmpty();
};

boolStack::push(int x)
{
if (top >= (MAX - 1)) {
 cout << " OVERFLOW";
returnfalse;
 }
else {
 a[++top] = x;
 cout << x << " PUSHED\n";
returntrue;
 }
}

intStack::pop()
{
if (top < 0) {
 cout << "UNDERFLOW";
return0;
 }
else {
int x = a[top--];
return x;
 }
}
intStack::peek()
{
if (top < 0) {
 cout << "EMPTY";
return0;
 }
else {
int x = a[top];
return x;
 }
}

boolStack::isEmpty()
{
return (top < 0);
}

intmain()
{
classStack s;
 s.push(10);
 s.push(20);
 s.push(30);
 cout << s.pop() << " POPPED\n";

return0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<bits/stdc++.h>
usingnamespacestd;
#defineMAX1000
classStack {
int top;

public:
int a[MAX];

Stack() { top = -1; }
boolpush(int x);
intpop();
intpeek();
boolisEmpty();
};

boolStack::push(int x)
{
if (top >= (MAX - 1)) {
 cout << " OVERFLOW";
returnfalse;
 }
else {
 a[++top] = x;
 cout << x << " PUSHED\n";
returntrue;
 }
}

intStack::pop()
{
if (top < 0) {
 cout << "UNDERFLOW";
return0;
 }
else {
int x = a[top--];
return x;
 }
}
intStack::peek()
{
if (top < 0) {
 cout << "EMPTY";
return0;
 }
else {
int x = a[top];
return x;
 }
}

boolStack::isEmpty()
{
return (top < 0);
}

intmain()
{
classStack s;
 s.push(10);
 s.push(20);
 s.push(30);
 cout << s.pop() << " POPPED\n";

return0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<bits/stdc++.h>
usingnamespacestd;
#defineMAX1000
classStack {
int top;

public:
int a[MAX];

Stack() { top = -1; }
boolpush(int x);
intpop();
intpeek();
boolisEmpty();
};

boolStack::push(int x)
{
if (top >= (MAX - 1)) {
 cout << " OVERFLOW";
returnfalse;
 }
else {
 a[++top] = x;
 cout << x << " PUSHED\n";
returntrue;
 }
}

intStack::pop()
{
if (top < 0) {
 cout << "UNDERFLOW";
return0;
 }
else {
int x = a[top--];
return x;
 }
}
intStack::peek()
{
if (top < 0) {
 cout << "EMPTY";
return0;
 }
else {
int x = a[top];
return x;
 }
}

boolStack::isEmpty()
{
return (top < 0);
}

intmain()
{
classStack s;
 s.push(10);
 s.push(20);
 s.push(30);
 cout << s.pop() << " POPPED\n";

return0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<bits/stdc++.h>
usingnamespacestd;
#defineMAX1000
classStack {
int top;

public:
int a[MAX];

Stack() { top = -1; }
boolpush(int x);
intpop();
intpeek();
boolisEmpty();
};

boolStack::push(int x)
{
if (top >= (MAX - 1)) {
 cout << " OVERFLOW";
returnfalse;
 }
else {
 a[++top] = x;
 cout << x << " PUSHED\n";
returntrue;
 }
}

intStack::pop()
{
if (top < 0) {
 cout << "UNDERFLOW";
return0;
 }
else {
int x = a[top--];
return x;
 }
}
intStack::peek()
{
if (top < 0) {
 cout << "EMPTY";
return0;
 }
else {
int x = a[top];
return x;
 }
}

boolStack::isEmpty()
{
return (top < 0);
}

intmain()
{
classStack s;
 s.push(10);
 s.push(20);
 s.push(30);
 cout << s.pop() << " POPPED\n";

return0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<bits/stdc++.h>
usingnamespacestd;
#defineMAX1000
classStack {
int top;

public:
int a[MAX];

Stack() { top = -1; }
boolpush(int x);
intpop();
intpeek();
boolisEmpty();
};

boolStack::push(int x)
{
if (top >= (MAX - 1)) {
 cout << " OVERFLOW";
returnfalse;
 }
else {
 a[++top] = x;
 cout << x << " PUSHED\n";
returntrue;
 }
}

intStack::pop()
{
if (top < 0) {
 cout << "UNDERFLOW";
return0;
 }
else {
int x = a[top--];
return x;
 }
}
intStack::peek()
{
if (top < 0) {
 cout << "EMPTY";
return0;
 }
else {
int x = a[top];
return x;
 }
}

boolStack::isEmpty()
{
return (top < 0);
}

intmain()
{
classStack s;
 s.push(10);
 s.push(20);
 s.push(30);
 cout << s.pop() << " POPPED\n";

return0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<bits/stdc++.h>
usingnamespacestd;
#defineMAX1000
classStack {
int top;

public:
int a[MAX];

Stack() { top = -1; }
boolpush(int x);
intpop();
intpeek();
boolisEmpty();
};

boolStack::push(int x)
{
if (top >= (MAX - 1)) {
 cout << " OVERFLOW";
returnfalse;
 }
else {
 a[++top] = x;
 cout << x << " PUSHED\n";
returntrue;
 }
}

intStack::pop()
{
if (top < 0) {
 cout << "UNDERFLOW";
return0;
 }
else {
int x = a[top--];
return x;
 }
}
intStack::peek()
{
if (top < 0) {
 cout << "EMPTY";
return0;
 }
else {
int x = a[top];
return x;
 }
}

boolStack::isEmpty()
{
return (top < 0);
}

intmain()
{
classStack s;
 s.push(10);
 s.push(20);
 s.push(30);
 cout << s.pop() << " POPPED\n";

return0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<bits/stdc++.h>
usingnamespacestd;
#defineMAX1000
classStack {
int top;

public:
int a[MAX];

Stack() { top = -1; }
boolpush(int x);
intpop();
intpeek();
boolisEmpty();
};

boolStack::push(int x)
{
if (top >= (MAX - 1)) {
 cout << " OVERFLOW";
returnfalse;
 }
else {
 a[++top] = x;
 cout << x << " PUSHED\n";
returntrue;
 }
}

intStack::pop()
{
if (top < 0) {
 cout << "UNDERFLOW";
return0;
 }
else {
int x = a[top--];
return x;
 }
}
intStack::peek()
{
if (top < 0) {
 cout << "EMPTY";
return0;
 }
else {
int x = a[top];
return x;
 }
}

boolStack::isEmpty()
{
return (top < 0);
}

intmain()
{
classStack s;
 s.push(10);
 s.push(20);
 s.push(30);
 cout << s.pop() << " POPPED\n";

return0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include<bits/stdc++.h>
usingnamespacestd;
#defineMAX1000
classStack {
int top;

public:
int a[MAX];

Stack() { top = -1; }
boolpush(int x);
intpop();
intpeek();
boolisEmpty();
};

boolStack::push(int x)
{
if (top >= (MAX - 1)) {
 cout << " OVERFLOW";
returnfalse;
 }
else {
 a[++top] = x;
 cout << x << " PUSHED\n";
returntrue;
 }
}

intStack::pop()
{
if (top < 0) {
 cout << "UNDERFLOW";
return0;
 }
else {
int x = a[top--];
return x;
 }
}
intStack::peek()
{
if (top < 0) {
 cout << "EMPTY";
return0;
 }
else {
int x = a[top];
return x;
 }
}

boolStack::isEmpty()
{
return (top < 0);
}

intmain()
{
classStack s;
 s.push(10);
 s.push(20);
 s.push(30);
 cout << s.pop() << " POPPED\n";

return0;
}