Utwórz strukturę danych stosu
begin
return stack[top]
end procedure
Juan D Khusuma
begin
return stack[top]
end procedure// C++ program for linked list implementation of stack
#include <bits/stdc++.h>
using namespace std;
// A structure to represent a stack
class StackNode {
public:
int data;
StackNode* next;
};
StackNode* newNode(int data)
{
StackNode* stackNode = new StackNode();
stackNode->data = data;
stackNode->next = NULL;
return stackNode;
}
int isEmpty(StackNode* root)
{
return !root;
}
void push(StackNode** root, int data)
{
StackNode* stackNode = newNode(data);
stackNode->next = *root;
*root = stackNode;
cout << data << " pushed to stack\n";
}
int pop(StackNode** root)
{
if (isEmpty(*root))
return INT_MIN;
StackNode* temp = *root;
*root = (*root)->next;
int popped = temp->data;
free(temp);
return popped;
}
int peek(StackNode* root)
{
if (isEmpty(root))
return INT_MIN;
return root->data;
}
// Driver code
int main()
{
StackNode* root = NULL;
push(&root, 10);
push(&root, 20);
push(&root, 30);
cout << pop(&root) << " popped from stack\n";
cout << "Top element is " << peek(root) << endl;
cout<<"Elements present in stack : ";
//print all elements in stack :
while(!isEmpty(root))
{
// print top element in stack
cout<<peek(root)<<" ";
// remove top element in stack
pop(&root);
}
return 0;
}
// This is code is contributed by rathbhupendra// C program for array implementation of stack
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
// A structure to represent a stack
struct Stack {
int top;
unsigned capacity;
int* array;
};
// function to create a stack of given capacity. It initializes size of
// stack as 0
struct Stack* createStack(unsigned capacity)
{
struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
stack->capacity = capacity;
stack->top = -1;
stack->array = (int*)malloc(stack->capacity * sizeof(int));
return stack;
}
// Stack is full when top is equal to the last index
int isFull(struct Stack* stack)
{
return stack->top == stack->capacity - 1;
}
// Stack is empty when top is equal to -1
int isEmpty(struct Stack* stack)
{
return stack->top == -1;
}
// Function to add an item to stack. It increases top by 1
void push(struct Stack* stack, int item)
{
if (isFull(stack))
return;
stack->array[++stack->top] = item;
printf("%d pushed to stack\n", item);
}
// Function to remove an item from stack. It decreases top by 1
int pop(struct Stack* stack)
{
if (isEmpty(stack))
return INT_MIN;
return stack->array[stack->top--];
}
// Function to return the top from stack without removing it
int peek(struct Stack* stack)
{
if (isEmpty(stack))
return INT_MIN;
return stack->array[stack->top];
}
// Driver program to test above functions
int main()
{
struct Stack* stack = createStack(100);
push(stack, 10);
push(stack, 20);
push(stack, 30);
printf("%d popped from stack\n", pop(stack));
return 0;
}// C# program to implement basic stack
// operations
using System;
namespace ImplementStack {
class Stack {
private int[] ele;
private int top;
private int max;
public Stack(int size)
{
ele = new int[size]; // Maximum size of Stack
top = -1;
max = size;
}
public void push(int item)
{
if (top == max - 1) {
Console.WriteLine("Stack Overflow");
return;
}
else {
ele[++top] = item;
}
}
public int pop()
{
if (top == -1) {
Console.WriteLine("Stack is Empty");
return -1;
}
else {
Console.WriteLine("{0} popped from stack ", ele[top]);
return ele[top--];
}
}
public int peek()
{
if (top == -1) {
Console.WriteLine("Stack is Empty");
return -1;
}
else {
Console.WriteLine("{0} popped from stack ", ele[top]);
return ele[top];
}
}
public void printStack()
{
if (top == -1) {
Console.WriteLine("Stack is Empty");
return;
}
else {
for (int i = 0; i <= top; i++) {
Console.WriteLine("{0} pushed into stack", ele[i]);
}
}
}
}
// Driver program to test above functions
class Program {
static void Main()
{
Stack p = new Stack(5);
p.push(10);
p.push(20);
p.push(30);
p.printStack();
p.pop();
}
}
}# Python program for implementation of stack
# import maxsize from sys module
# Used to return -infinite when stack is empty
from sys import maxsize
# Function to create a stack. It initializes size of stack as 0
def createStack():
stack = []
return stack
# Stack is empty when stack size is 0
def isEmpty(stack):
return len(stack) == 0
# Function to add an item to stack. It increases size by 1
def push(stack, item):
stack.append(item)
print(item + " pushed to stack ")
# Function to remove an item from stack. It decreases size by 1
def pop(stack):
if (isEmpty(stack)):
return str(-maxsize -1) # return minus infinite
return stack.pop()
# Function to return the top from stack without removing it
def peek(stack):
if (isEmpty(stack)):
return str(-maxsize -1) # return minus infinite
return stack[len(stack) - 1]
# Driver program to test above functions
stack = createStack()
push(stack, str(10))
push(stack, str(20))
push(stack, str(30))
print(pop(stack) + " popped from stack")begin
if stack is empty
return
endif
else
store value of stack[top]
decrement top
return value
end else
end procedure<script>
/* javascript program to implement basic stack
operations
*/
var t = -1;
var MAX = 1000;
var a = Array(MAX).fill(0); // Maximum size of Stack
function isEmpty() {
return (t < 0);
}
function push(x) {
if (t >= (MAX - 1)) {
document.write("Stack Overflow");
return false;
} else {
t+=1;
a[t] = x;
document.write(x + " pushed into stack<br/>");
return true;
}
}
function pop() {
if (t < 0) {
document.write("Stack Underflow");
return 0;
} else {
var x = a[t];
t-=1;
return x;
}
}
function peek() {
if (t < 0) {
document.write("Stack Underflow");
return 0;
} else {
var x = a[t];
return x;
}
}
function print() {
for (i = t; i > -1; i--) {
document.write(" " + a[i]);
}
}
push(10);
push(20);
push(30);
document.write(pop() + " Popped from stack");
document.write("<br/>Top element is :" + peek());
document.write("<br/>Elements present in stack : ");
print();
// This code is contributed by Rajput-Ji
</script>begin
if top < 1
return true
else
return false
end procedure// Java Code for Linked List Implementation
public class StackAsLinkedList {
StackNode root;
static class StackNode {
int data;
StackNode next;
StackNode(int data) { this.data = data; }
}
public boolean isEmpty()
{
if (root == null) {
return true;
}
else
return false;
}
public void push(int data)
{
StackNode newNode = new StackNode(data);
if (root == null) {
root = newNode;
}
else {
StackNode temp = root;
root = newNode;
newNode.next = temp;
}
System.out.println(data + " pushed to stack");
}
public int pop()
{
int popped = Integer.MIN_VALUE;
if (root == null) {
System.out.println("Stack is Empty");
}
else {
popped = root.data;
root = root.next;
}
return popped;
}
public int peek()
{
if (root == null) {
System.out.println("Stack is empty");
return Integer.MIN_VALUE;
}
else {
return root.data;
}
}
// Driver code
public static void main(String[] args)
{
StackAsLinkedList sll = new StackAsLinkedList();
sll.push(10);
sll.push(20);
sll.push(30);
System.out.println(sll.pop()
+ " popped from stack");
System.out.println("Top element is " + sll.peek());
}
}// C# Code for Linked List Implementation
using System;
public class StackAsLinkedList {
StackNode root;
public class StackNode {
public int data;
public StackNode next;
public StackNode(int data) { this.data = data; }
}
public bool isEmpty()
{
if (root == null) {
return true;
}
else
return false;
}
public void push(int data)
{
StackNode newNode = new StackNode(data);
if (root == null) {
root = newNode;
}
else {
StackNode temp = root;
root = newNode;
newNode.next = temp;
}
Console.WriteLine(data + " pushed to stack");
}
public int pop()
{
int popped = int.MinValue;
if (root == null) {
Console.WriteLine("Stack is Empty");
}
else {
popped = root.data;
root = root.next;
}
return popped;
}
public int peek()
{
if (root == null) {
Console.WriteLine("Stack is empty");
return int.MinValue;
}
else {
return root.data;
}
}
// Driver code
public static void Main(String[] args)
{
StackAsLinkedList sll = new StackAsLinkedList();
sll.push(10);
sll.push(20);
sll.push(30);
Console.WriteLine(sll.pop() + " popped from stack");
Console.WriteLine("Top element is " + sll.peek());
}
}
/* This code contributed by PrinciRaj1992 */