“Utwórz strukturę danych stosu” Kod odpowiedzi

Utwórz strukturę danych stosu

begin 
  return stack[top]
end procedure
Juan D Khusuma

Utwórz strukturę danych stosu

// 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

Utwórz strukturę danych stosu

// 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

Utwórz strukturę danych stosu

// 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

Utwórz strukturę danych stosu

# 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

Utwórz strukturę danych stosu

begin
 if stack is empty
    return
 endif
else
 store value of stack[top]
 decrement top
 return value
end else
end procedure
Juan D Khusuma

Utwórz strukturę danych stosu

<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

Utwórz strukturę danych stosu

begin
 if top < 1
    return true
 else
    return false
end procedure
Juan D Khusuma

Utwórz strukturę danych stosu

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

Utwórz strukturę danych stosu

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

Odpowiedzi podobne do “Utwórz strukturę danych stosu”

Pytania podobne do “Utwórz strukturę danych stosu”

Więcej pokrewnych odpowiedzi na “Utwórz strukturę danych stosu” w Java

Przeglądaj popularne odpowiedzi na kod według języka

Przeglądaj inne języki kodu