C#으로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 C# 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: stack_example.cs

using System;

namespace StackExample
{
    class SimpleStack
    {
        private const int MAX = 5;
        private int top;
        private int[] data;

        public SimpleStack()
        {
            top = -1;
            data = new int[MAX];
        }

        public void Push(int num)
        {
            if (top < MAX - 1)
            {
                data[++top] = num;
            }
            else
            {
                Console.WriteLine("스택이 가득 찼습니다.");
            }
        }

        public int Pop()
        {
            if (top >= 0)
            {
                return data[top--];
            }
            else
            {
                Console.WriteLine("스택이 비어있습니다.");
                return -1;
            }
        }

        static void Main(string[] args)
        {
            SimpleStack s = new SimpleStack();
            int num;

            Console.Write("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ");
            while (int.TryParse(Console.ReadLine(), out num) && num != 0)
            {
                s.Push(num);
                Console.Write("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ");
            }

            Console.Write("스택에서 정수를 꺼냅니다: ");
            while ((num = s.Pop()) != -1)
            {
                Console.Write($"{num} ");
            }
            Console.WriteLine();
        }
    }
}

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 5 7 3 스택이 비어있습니다.

C 언어로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 C 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: stack_example.c

#define _CRT_SECURE_NO_WARNINGS // 경고를 무시하는 매크로
#include <stdio.h>               // 표준입출력 라이브러리 헤더파일
#include <stdlib.h>              // 표준 라이브러리 헤더파일

#define MAX 5                    // 스택의 최대 크기 정의

// Stack 구조체 정의
typedef struct
{
    int top;                    // 스택의 최상단 인덱스를 가리킴
    int data[MAX];              // 스택에 저장되는 데이터 배열
} Stack;

// 스택에 데이터 삽입(push) 함수
void push(Stack* s, int num)
{
    if (s->top < MAX - 1)
    {
        s->data[++s->top] = num; // 데이터 삽입 및 top 인덱스 증가
    }
    else
    {
        printf("스택이 가득 찼습니다.\n"); // 스택이 가득 찬 경우 메시지 출력
    }
}

// 스택에서 데이터 추출(pop) 함수
int pop(Stack* s)
{
    if (s->top >= 0)
    {
        return s->data[s->top--]; // 데이터 추출 및 top 인덱스 감소
    }
    else
    {
        printf("스택이 비어있습니다.\n"); // 스택이 비어있는 경우 메시지 출력
        return -1;
    }
}

int main(void)
{
    Stack s;                    // Stack 구조체 변수 선언
    s.top = -1;                 // 스택 초기화 (top을 -1로 설정)
    int num;

    printf("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ");
    while (scanf("%d", &num) && num != 0)
    {
        push(&s, num);          // 스택에 입력한 정수를 삽입
        printf("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ");
    }

    printf("스택에서 정수를 꺼냅니다: ");
    while ((num = pop(&s)) != -1) // 스택이 비어있지 않을 동안 반복
    {
        printf("%d ", num);      // 스택에서 추출한 정수 출력
    }
    printf("\n");

    return 0;
}

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 5 7 3 스택이 비어있습니다.

이 예제에서는 스택이라는 자료 구조를 사용하여 사용자로부터 입력받은 정수를 저장하고, 저장된 정수를 스택의 규칙에 따라 출력합니다. 스택은 Last In First Out (LIFO) 규칙을 따르는 자료 구조로, 마지막에 들어온 데이터가 가장 먼저 나가게 됩니다.

소스 코드에서는 Stack이라는 구조체를 사용하여 스택을 구현하고 있으며, push와 pop이라는 함수를 사용하여 스택에 정수를 저장하고 추출합니다. 사용자로부터 0이 입력될 때까지 정수를 입력받아 스택에 저장하며, 0이 입력되면 스택이 비어있지 않을 때까지 스택에서 정수를 추출하여 출력합니다.

Java로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 Java 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: StackExample.java

import java.util.Scanner;

public class StackExample {
    private static final int MAX = 5;
    private int top;
    private int[] data;

    public StackExample() {
        top = -1;
        data = new int[MAX];
    }

    public void push(int num) {
        if (top < MAX - 1) {
            data[++top] = num;
        } else {
            System.out.println("스택이 가득 찼습니다.");
        }
    }

    public int pop() {
        if (top >= 0) {
            return data[top--];
        } else {
            System.out.println("스택이 비어있습니다.");
            return -1;
        }
    }

    public static void main(String[] args) {
        StackExample s = new StackExample();
        int num;

        Scanner scanner = new Scanner(System.in);
        System.out.print("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ");
        while ((num = scanner.nextInt()) != 0) {
            s.push(num);
            System.out.print("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ");
        }
        scanner.close();

        System.out.print("스택에서 정수를 꺼냅니다: ");
        while ((num = s.pop()) != -1) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 5 7 3 스택이 비어있습니다.

Python으로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 Python 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: stack_example.py

class Stack:
    MAX = 5

    def __init__(self):
        self.top = -1
        self.data = [0] * self.MAX

    def push(self, num):
        if self.top < self.MAX - 1:
            self.top += 1
            self.data[self.top] = num
        else:
            print("스택이 가득 찼습니다.")

    def pop(self):
        if self.top >= 0:
            num = self.data[self.top]
            self.top -= 1
            return num
        else:
            print("스택이 비어있습니다.")
            return -1

def main():
    s = Stack()
    num = None

    while True:
        num = int(input("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): "))
        if num == 0:
            break
        s.push(num)

    print("스택에서 정수를 꺼냅니다: ", end="")
    while (num := s.pop()) != -1:
        print(num, end=" ")
    print()

if __name__ == "__main__":
    main()

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 5 7 3 스택이 비어있습니다.

JavaScript로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 JavaScript 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: stack_example.js

class Stack {
  constructor() {
    this.MAX = 5;
    this.top = -1;
    this.data = new Array(this.MAX).fill(0);
  }

  push(num) {
    if (this.top < this.MAX - 1) {
      this.top++;
      this.data[this.top] = num;
    } else {
      console.log("스택이 가득 찼습니다.");
    }
  }

  pop() {
    if (this.top >= 0) {
      const num = this.data[this.top];
      this.top--;
      return num;
    } else {
      console.log("스택이 비어있습니다.");
      return -1;
    }
  }
}

function main() {
  const s = new Stack();
  let num;

  const readline = require("readline");
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  function askQuestion() {
    rl.question("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ", (input) => {
      num = parseInt(input);
      if (num === 0) {
        rl.close();
        printStack();
      } else {
        s.push(num);
        askQuestion();
      }
    });
  }

  function printStack() {
    process.stdout.write("스택에서 정수를 꺼냅니다: ");
    while ((num = s.pop()) !== -1) {
      process.stdout.write(`${num} `);
    }
    console.log();
  }

  askQuestion();
}

main();

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 5 7 3 스택이 비어있습니다.

C++로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 C++ 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: stack_example.cpp

#include <iostream>
#include <vector>

const int MAX = 5;

class Stack {
public:
    Stack() : top(-1), data(MAX) {}

    void push(int num) {
        if (top < MAX - 1) {
            data[++top] = num;
        } else {
            std::cout << "스택이 가득 찼습니다.\n";
        }
    }

    int pop() {
        if (top >= 0) {
            return data[top--];
        } else {
            std::cout << "스택이 비어있습니다.\n";
            return -1;
        }
    }

private:
    int top;
    std::vector<int> data;
};

int main() {
    Stack s;
    int num;

    std::cout << "0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ";
    while (std::cin >> num && num != 0) {
        s.push(num);
        std::cout << "0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ";
    }

    std::cout << "스택에서 정수를 꺼냅니다: ";
    while ((num = s.pop()) != -1) {
        std::cout << num << ' ';
    }
    std::cout << '\n';

    return 0;
}

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 5 7 3 스택이 비어있습니다.

Go로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 Go 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: stack_example.go

package main

import "fmt"

const MAX = 5

type Stack struct {
    top  int
    data [MAX]int
}

func (s *Stack) push(num int) {
    if s.top < MAX-1 {
        s.top++
        s.data[s.top] = num
    } else {
        fmt.Println("스택이 가득 찼습니다.")
    }
}

func (s *Stack) pop() int {
    if s.top >= 0 {
        val := s.data[s.top]
        s.top--
        return val
    } else {
        fmt.Println("스택이 비어있습니다.")
        return -1
    }
}

func main() {
    s := Stack{top: -1}
    var num int

    fmt.Print("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ")
    for fmt.Scan(&num); num != 0; fmt.Scan(&num) {
        s.push(num)
        fmt.Print("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ")
    }

    fmt.Print("스택에서 정수를 꺼냅니다: ")
    for num = s.pop(); num != -1; num = s.pop() {
        fmt.Printf("%d ", num)
    }
    fmt.Println()
}

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 5 7 3 스택이 비어있습니다.

Rust로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 Rust 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: stack_example.rs

use std::io;

const MAX: usize = 5;

struct Stack {
    top: i32,
    data: [i32; MAX],
}

impl Stack {
    fn new() -> Stack {
        Stack { top: -1, data: [0; MAX] }
    }

    fn push(&mut self, num: i32) {
        if self.top < (MAX - 1) as i32 {
            self.top += 1;
            self.data[self.top as usize] = num;
        } else {
            println!("스택이 가득 찼습니다.");
        }
    }

    fn pop(&mut self) -> i32 {
        if self.top >= 0 {
            let val = self.data[self.top as usize];
            self.top -= 1;
            val
        } else {
            println!("스택이 비어있습니다.");
            -1
        }
    }
}

fn main() {
    let mut s = Stack::new();
    let mut num = String::new();

    print!("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ");
    while io::stdin().read_line(&mut num).unwrap() > 0 {
        let num: i32 = num.trim().parse().unwrap();
        if num == 0 {
            break;
        }
        s.push(num);
        num.clear();
        print!("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ");
    }

    print!("스택에서 정수를 꺼냅니다: ");
    while (num = s.pop().to_string()) != "-1" {
        print!("{} ", num);
    }
    println!();
}

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 5 7 3 스택이 비어있습니다.

TypeScript로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 TypeScript 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: stack_example.ts

import * as readline from 'readline';

const MAX: number = 5;

class Stack {
  private top: number;
  private data: number[];

  constructor() {
    this.top = -1;
    this.data = new Array(MAX).fill(0);
  }

  push(num: number): void {
    if (this.top < MAX - 1) {
      this.top += 1;
      this.data[this.top] = num;
    } else {
      console.log("스택이 가득 찼습니다.");
    }
  }

  pop(): number {
    if (this.top >= 0) {
      const val = this.data[this.top];
      this.top -= 1;
      return val;
    } else {
      console.log("스택이 비어있습니다.");
      return -1;
    }
  }
}

const main = (): void => {
  const s = new Stack();
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  const getInput = (): void => {
    rl.question("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ", (num) => {
      const numInt = parseInt(num);
      if (numInt === 0) {
        console.log("스택에서 정수를 꺼냅니다: ");
        let result: number;
        while ((result = s.pop()) !== -1) {
          console.log(result);
        }
        rl.close();
      } else {
        s.push(numInt);
        getInput();
      }
    });
  };

  getInput();
};

main();

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 
5
7
3
스택이 비어있습니다.

Kotlin으로 구현한 간단한 스택(Stack) 예제

이번 아티클에서는 Kotlin 언어를 사용하여 간단한 스택(Stack)을 구현하고, 사용자로부터 입력받은 정수를 스택에 저장한 후, 스택에서 추출하여 출력하는 예제를 살펴보겠습니다.

코드: StackExample.kt

import java.util.Scanner

const val MAX = 5

class Stack {
    private var top: Int = -1
    private val data = IntArray(MAX)

    fun push(num: Int) {
        if (top < MAX - 1) {
            top++
            data[top] = num
        } else {
            println("스택이 가득 찼습니다.")
        }
    }

    fun pop(): Int {
        return if (top >= 0) {
            val value = data[top]
            top--
            value
        } else {
            println("스택이 비어있습니다.")
            -1
        }
    }
}

fun main() {
    val stack = Stack()
    val scanner = Scanner(System.`in`)
    var num: Int

    println("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ")
    do {
        num = scanner.nextInt()
        if (num != 0) {
            stack.push(num)
            println("0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): ")
        }
    } while (num != 0)

    println("스택에서 정수를 꺼냅니다: ")
    var result: Int
    while (stack.pop().also { result = it } != -1) {
        print("$result ")
    }
    println()
}

실행 결과:

0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 3
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 7
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 5
0에서 9 사이의 정수를 입력하세요. (0을 입력하면 종료합니다.): 0
스택에서 정수를 꺼냅니다: 
5 7 3 스택이 비어있습니다.