“Crie estrutura de dados da pilha” Respostas de código

Crie estrutura de dados da pilha

// 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
Juan D Khusuma

Crie estrutura de dados da pilha

begin 
  return stack[top]
end procedure
Juan D Khusuma

Crie estrutura de dados da pilha

// 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;
}
Unusual Unicorn

Crie estrutura de dados da pilha

// 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();
    }
}
}
Juan D Khusuma

Crie estrutura de dados da pilha

begin
 if stack is full
    return
 endif
else  
 increment top
 stack[top] assign value
end else
end procedure
Juan D Khusuma

Crie estrutura de dados da pilha

<script>
// javascript Code for Linked List Implementation
 
var root;
 
     class StackNode {
 
        constructor(data) {
            this.data = data;
            this.next = null;
        }
    }
 
     function isEmpty() {
        if (root == null) {
            return true;
        } else
            return false;
    }
 
     function push(data) {
        var newNode = new StackNode(data);
 
        if (root == null) {
            root = newNode;
        } else {
            var temp = root;
            root = newNode;
            newNode.next = temp;
        }
        document.write(data + " pushed to stack<br/>");
    }
 
     function pop() {
        var popped = Number.MIN_VALUE;
        if (root == null) {
            document.write("Stack is Empty");
        } else {
            popped = root.data;
            root = root.next;
        }
        return popped;
    }
 
     function peek() {
        if (root == null) {
            document.write("Stack is empty");
            return Number.MIN_VALUE;
        } else {
            return root.data;
        }
    }
 
    // Driver code
        push(10);
        push(20);
        push(30);
 
        document.write(pop() + " popped from stack<br/>");
 
        document.write("Top element is " + peek());
 
// This code is contributed by Rajput-Ji
</script>
Juan D Khusuma

Crie estrutura de dados da pilha

/* C++ program to implement basic stack
   operations */
#include <bits/stdc++.h>
 
using namespace std;
 
#define MAX 1000
 
class Stack {
    int top;
 
public:
    int a[MAX]; // Maximum size of Stack
 
    Stack() { top = -1; }
    bool push(int x);
    int pop();
    int peek();
    bool isEmpty();
};
 
bool Stack::push(int x)
{
    if (top >= (MAX - 1)) {
        cout << "Stack Overflow";
        return false;
    }
    else {
        a[++top] = x;
        cout << x << " pushed into stack\n";
        return true;
    }
}
 
int Stack::pop()
{
    if (top < 0) {
        cout << "Stack Underflow";
        return 0;
    }
    else {
        int x = a[top--];
        return x;
    }
}
int Stack::peek()
{
    if (top < 0) {
        cout << "Stack is Empty";
        return 0;
    }
    else {
        int x = a[top];
        return x;
    }
}
 
bool Stack::isEmpty()
{
    return (top < 0);
}
 
// Driver program to test above functions
int main()
{
    class Stack s;
    s.push(10);
    s.push(20);
    s.push(30);
    cout << s.pop() << " Popped from stack\n";
    //print all elements in stack :
    cout<<"Elements present in stack : ";
    while(!s.isEmpty())
    {
        // print top element in stack
        cout<<s.peek()<<" ";
        // remove top element in stack
        s.pop();
    }
 
    return 0;
}
Juan D Khusuma

Crie estrutura de dados da pilha

# 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")
Juan D Khusuma

Crie estrutura de dados da pilha

/* Java program to implement basic stack
operations */
class Stack {
    static final int MAX = 1000;
    int top;
    int a[] = new int[MAX]; // Maximum size of Stack
 
    boolean isEmpty()
    {
        return (top < 0);
    }
    Stack()
    {
        top = -1;
    }
 
    boolean push(int x)
    {
        if (top >= (MAX - 1)) {
            System.out.println("Stack Overflow");
            return false;
        }
        else {
            a[++top] = x;
            System.out.println(x + " pushed into stack");
            return true;
        }
    }
 
    int pop()
    {
        if (top < 0) {
            System.out.println("Stack Underflow");
            return 0;
        }
        else {
            int x = a[top--];
            return x;
        }
    }
 
    int peek()
    {
        if (top < 0) {
            System.out.println("Stack Underflow");
            return 0;
        }
        else {
            int x = a[top];
            return x;
        }
    }
    
    void print(){
    for(int i = top;i>-1;i--){
      System.out.print(" "+ a[i]);
    }
  }
}
 
// Driver code
class Main {
    public static void main(String args[])
    {
        Stack s = new Stack();
        s.push(10);
        s.push(20);
        s.push(30);
        System.out.println(s.pop() + " Popped from stack");
        System.out.println("Top element is :" + s.peek());
        System.out.print("Elements present in stack :");
        s.print();
    }
}
Juan D Khusuma

Crie estrutura de dados da pilha

<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>
Juan D Khusuma

Respostas semelhantes a “Crie estrutura de dados da pilha”

Perguntas semelhantes a “Crie estrutura de dados da pilha”

Mais respostas relacionadas para “Crie estrutura de dados da pilha” em JavaScript

Procure respostas de código populares por idioma

Procurar outros idiomas de código