๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ

๐Ÿค– data structures & algorithms

Data Structures & Algorithms with Javascript : Stacks

 

2024.07.18 - [๐Ÿค– data structures & algorithms] - Data Structures & Algorithms with Javascript : Lists

2024.07.17 - [๐Ÿค– data structures & algorithms] - Data Structures & Algorithms with Javascript : Arrays

2024.07.17 - [๐Ÿค– data structures & algorithms] - Data Structures & Algorithms with Javascript : Intro

 

์ง€๋‚œ๋ฒˆ ํฌ์ŠคํŒ…์—์„œ๋Š” ๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ์ž๋ฃŒ ๊ตฌ์กฐ์ธ list์— ๋Œ€ํ•ด ์‚ดํŽด๋ดค๋‹ค.
๋ฐ์ดํ„ฐ์˜ ์ •๋ ฌ ๋ฐ ์ €์žฅ ์ˆœ์„œ๊ฐ€ ์ค‘์š”ํ•˜์ง€ ์•Š์œผ๋ฉด list ์ž๋ฃŒ ๊ตฌ์กฐ๋กœ ์ถฉ๋ถ„ํžˆ ๋ฐ์ดํ„ฐ ๊ด€๋ฆฌ๋ฅผ ํ•  ์ˆ˜ ์žˆ๋‹ค.
ํ•˜์ง€๋งŒ ๋” ๋ณต์žกํ•œ ์ž‘์—…์ด ํ•„์š”ํ•œ ๊ฒฝ์šฐ์—๋Š” ๋ถ€์กฑํ•  ์ˆ˜ ์žˆ๋‹ค.

๐Ÿ‘ฉ๐Ÿป‍๐Ÿ’ป ์˜ค๋Š˜์€ ์ข€ ๋” ๋ณต์žกํ•œ ์ž‘์—…์„ ๋„์™€์ค„ ์ž๋ฃŒ ๊ตฌ์กฐ์ธ Stack์— ๋Œ€ํ•ด ์•Œ์•„๋ณด์ž.

๐Ÿฅž Stack ์—ฐ์‚ฐ

์Šคํƒ ์ž๋ฃŒ ๊ตฌ์กฐ๋Š” ๋ฆฌ์ŠคํŠธ ๋งจ ๋์˜ ์—˜๋ฆฌ๋จผํŠธ๋งŒ ์ ‘๊ทผ๊ฐ€๋Šฅํ•˜๋‹ค. 

์Šคํƒ ์—ฐ์‚ฐ์€ ๋ง›์žˆ๋Š” ํŒฌ์ผ€์ดํฌ๋ฅผ ๋งŒ๋“ค์–ด ๋จน์„ ๋•Œ๋ž‘ ๊ฐ™๋‹ค.

ํ•˜๋‚˜์”ฉ ๊ตฌ์›Œ์„œ ์ ‘์‹œ์— ์Œ“์•„ ์˜ฌ๋ฆฌ๊ณ , ์œ„์— ๊ฟ€์ด๋‚˜ ๋ฉ”์ดํ”Œ ์‹œ๋Ÿฝ์„ ๋ฟŒ๋ ค์„œ ์œ„์—์„œ ์•„๋ž˜๋กœ ํ•œ ์žฅ์”ฉ ๋จน๋Š”๋‹ค.

์Šคํƒ ์ž๋ฃŒ๊ตฌ์กฐ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ LIFO (last-in-first-out), ๋งˆ์ง€๋ง‰์— ๋“ค์–ด์˜จ ์—˜๋ฆฌ๋จผํŠธ๋ฅผ ๊ฐ€์žฅ ๋จผ์ € ์ ‘ํ•˜๋Š” ๊ตฌ์กฐ๋‹ค.

๋”ฐ๋ผ์„œ ๋งจ ์œ„์˜ ์—˜๋ฆฌ๋จผํŠธ ์ด์™ธ์˜ ์—˜๋ฆฌ๋จผํŠธ์— ์ ‘๊ทผํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋จผ์ € ๊ทธ ์œ„์— ์žˆ๋Š” ๋ชจ๋“  ์—˜๋ฆฌ๋จผํŠธ๋“ค์„ ์ œ๊ฑฐ ํ›„ ์ ‘๊ทผ ๊ฐ€๋Šฅํ•˜๋‹ค.

 

์Šคํƒ ์ž๋ฃŒ ๊ตฌ์กฐ์— ์—˜๋ฆฌ๋จผํŠธ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ์—ฐ์‚ฐ์„ "push", ์ œ๊ฑฐํ•˜๋Š” ์—ฐ์‚ฐ์„ "pop"์ด๋ผ๊ณ  ํ•œ๋‹ค.

์ด ๊ณผ์ •์„ ๊ทธ๋ฆผ์œผ๋กœ ๋ณด์ž๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

 

์—˜๋ฆฌ๋จผํŠธ 1 push, ๋ฐ์ดํ„ฐ ์ƒํƒœ: [1]

์—˜๋ฆฌ๋จผํŠธ 2 push , ๋ฐ์ดํ„ฐ ์ƒํƒœ : [1 ,2]

์—˜๋ฆฌ๋จผํŠธ 3 push , ๋ฐ์ดํ„ฐ ์ƒํƒœ : [1 ,2, 3]

์—˜๋ฆฌ๋จผํŠธ pop , ๋ฐ์ดํ„ฐ ์ƒํƒœ : [1 ,2]

์—˜๋ฆฌ๋จผํŠธ pop , ๋ฐ์ดํ„ฐ ์ƒํƒœ : [1]

์—˜๋ฆฌ๋จผํŠธ 4 push , ๋ฐ์ดํ„ฐ ์ƒํƒœ : [1, 4]

 

 

 

 

์ฃผ์š” ์—ฐ์‚ฐ์ธ push ์™€ pop ๋ง๊ณ ๋„ peek์—ฐ์‚ฐ์ด ์žˆ๋‹ค.

์Šคํƒ ์ž๋ฃŒ ๊ตฌ์กฐ ๋งจ ์œ„์— ์žˆ๋Š” ์—˜๋ฆฌ๋จผํŠธ๋ฅผ ๋ณด๋Š” ์—ฐ์‚ฐ์„ "peek"๋ผ๊ณ  ํ•œ๋‹ค.

pop์€ ๋งจ ์œ„์˜ ์—˜๋ฆฌ๋จผํŠธ๋ฅผ ๋ณด๊ณ  ์ œ๊ฑฐํ•˜๋Š” ๋ฐ˜๋ฉด, peek๋Š” ๋ณด๊ธฐ๋งŒ ํ•˜๋Š” ์—ฐ์‚ฐ์ด๋‹ค.

๐Ÿ—๏ธ Stack ๊ตฌํ˜„

โ€ผ ์˜ˆ์ œ๋Š” ์ฑ…์˜ ๊ตฌํ˜„์„ ์ฐธ๊ณ ํ•˜์—ฌ ํด๋ž˜์Šค๋กœ ์žฌ๊ตฌ์„ฑํ–ˆ์Šต๋‹ˆ๋‹ค!!

class Stack{
	constructor(){
		this.dataStore = [];
        this.top = 0; // ๋งจ ์œ„์˜ ์—˜๋ฆฌ๋จผํŠธ์˜ ์œ„์น˜ ์ธ๋ฑ์Šค
	}
    push(element){
    	this.dataStore[this.top++] =element;
    }
	pop(){
		return this.dataStore[--this.top];
	}
    length(){
    	return this.top;
    }
    clear(){
		this.dataStore = [];
    	this.top = 0;
    }
	peek(){
    	return this.dataStore[this.top-1];
    }
}

const print = (item) => console.log(item);
const stack = new Stack();
stack.push('a');
stack.push('b');
stack.push('c');
print(stack.length()); // 3
print(stack.peek()); // c
const popped = stack.pop();
print(popped); // c
print(stack.peek()); // b
stack.push('d'); 
print(stack.peek()); // d
stack.clear();
print(stack.length()); //0
stack.push('A');
print(stack.peek()); // A

๐Ÿ‹๏ธ  Stack ์‚ฌ์šฉํ•ด๋ณด๊ธฐ 

์ž๋ฆฟ์ˆ˜ ๋ฐ”๊พธ๊ธฐ

์šฐ๋ฆฌ๋Š” 10์ง„์ˆ˜์„ ์‚ฌ์šฉํ•˜๊ณ , ์ปดํ“จํ„ฐ๋Š” 2์ง„์ˆ˜๋กœ ๋™์ž‘ํ•œ๋‹ค.

์Šคํƒ ๊ตฌ์กฐ๋ฅผ ํ™œ์šฉํ•ด ์ž๋ฆฟ์ˆ˜๋ฅผ ๋ฐ”๊พธ๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์‰ฝ๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค.

 

๋…ผ๋ฆฌ ํ๋ฆ„

 

1. ๊ฐ€์žฅ ์˜ค๋ฅธ์ชฝ ์ˆซ์ž n์˜ ์ž๋ฆฟ์ˆ˜๋Š” n% b์ด๋‹ค. ์ด ์ˆซ์ž๋ฅผ ์Šคํƒ์— ์Œ“๊ณ ,

2. n์„ n/b๋กœ ๋Œ€์ฒด

3. n=0 ๊ฐ€ ๋  ๋•Œ๊นŒ์ง€ 1,2๋ฅผ ๋ฐ˜๋ณต

4. ์ž๋ฆฟ์ˆ˜๋ฅผ ๋ณ€๊ฒฝํ•œ ์ˆ˜๊ฐ€ ์—†์„ ๋•Œ๊นŒ์ง€ ์Šคํƒ์—์„œ pop ํ•œ๋‹ค.

 

๊ตฌํ˜„

function mulBase(num, base){
	let stack = new Stack();
	do {
		stack.push(num % base);
		num = Math.floor(num /= base);
	} while (num > 0);
	let convertedNum = '';
    while(s.length()>0){
		convertedNum+= stack.pop();
	}
	return convertedNum;
}

// 10์ง„์ˆ˜ 32๋ฅผ 2์ง„์ˆ˜๋กœ ์ˆซ์ž ๋ณ€๊ฒฝ
const num32base2 = mulBase(32,2);
print(num32base2) // 100000
const num125base8 = mulBase(125,8);
print(num125base8) // 175

// ๋‚ด์žฅ ํ•จ์ˆ˜ toString()์œผ๋กœ ๊ฐ™์€ ๊ฑธ ํ™•์ธ
print((32).toString(2)); // 100000
print((125).toString(8)); //175

ํŒฐ๋ฆฐ๋“œ๋กฌ

ํŒฐ๋ฆฐ๋“œ๋กฌ(ํšŒ๋ฌธ)์€ ์•ž์œผ๋กœ ์ฝ๋‚˜ ๋’ค๋กœ ์ฝ๋‚˜ ๊ฐ™์€ ๋ฌธ์ž๋ฅผ ๋œปํ•œ๋‹ค.

'ํ† ๋งˆํ† ', '๋‹ค์‹œ ํ•ฉ์ฐฝํ•ฉ์‹œ๋‹ค', '์†Œ์ฃผ๋งŒ ๋ณ‘๋งŒ ์ฃผ์†Œ', '์—ฌ๋ณด ์•ˆ๊ฒฝ ์•ˆ ๋ณด์—ฌ', 1001 ๋“ฑ์ด ํŒฐ๋ฆฐ๋“œ๋กฌ์ด๋‹ค.

์Šคํƒ์„ ํ™œ์šฉํ•ด์„œ ๋ฌธ์ž๊ฐ€ ํŒฐ๋ฆฐ๋“œ๋กฌ์ธ์ง€ ์—ฌ๋ถ€๋ฅผ ํ™•์ธํ•  ์ˆ˜ ์žˆ๋‹ค.

 

 

๋…ผ๋ฆฌ ํ๋ฆ„

 

1. ์›๋ณธ ๋ฌธ์ž์—ด์—์„œ ๋ฌธ์ž ํ•˜๋‚˜์”ฉ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์Šคํƒ์— ์Œ“๋Š”๋‹ค.

2. ๋ชจ๋“  ๋ฌธ์ž์—ด์„ ์ถ”๊ฐ€ํ•˜๋ฉด ์Šคํƒ์€ ์›๋ณธ ๋ฌธ์ž์—ด์„ ์—ญ์ˆœ์œผ๋กœ ๊ตฌ์„ฑ๋œ ๋ฆฌ์ŠคํŠธ๋‹ค.

3. ์Šคํƒ์—์„œ ํ•˜๋‚˜์”ฉ pop ํ•ด์„œ ํ•ฉ์นœ ๋ฌธ์ž์—ด์ด ์›๋ณธ๊ณผ ๊ฐ™๋‹ค๋ฉด ํŒฐ๋ฆฐ๋“œ๋กฌ์ด๋‹ค.

 

๊ตฌํ˜„

function isPalindrome(word){
 	const stack = new Stack();
	for(let i=0; i< word.length; i++){
		stack.push(word[i]);
	}
	let reversedWord = '';
	while(stack.length() > 0){
    	reversedWord += stack.pop();
    }
	return word === reversedWord;
}

print(isPalindrome('hello')); //false
print(isPalindrome('racecar')); //true

 

์žฌ๊ท€

ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ์ ‘ํ•œ ์‚ฌ๋žŒ์ด๋ผ๋ฉด "์Šคํƒ"์ด๋ผ๋Š” ๋ง์„ ์ข…์ข… ๋“ค์—ˆ์„ ๊ฒƒ์ด๋‹ค. ์Šคํƒ ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ, ์ฝœ ์Šคํƒ, ์Šคํƒ ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น ๋“ฑ๋“ฑ.

์Šคํƒ์€ ์žฌ๊ท€๋ฅผ ๊ตฌํ˜„ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋˜๊ธฐ๋„ ํ•œ๋‹ค. ์žฌ๊ท€์˜ ๊ฐ€์žฅ ๋Œ€ํ‘œ์ ์ธ ์˜ˆ๋Š” ํŒฉํ† ๋ฆฌ์–ผ (factorial)์ด๋‹ค.

5! = 5 * 4 * 3 * 2 * 1 = 120

 

ํŒฉํ† ๋ฆฌ์–ผ์€ base(์‹œ์ž‘์ )์ธ 5 ์ž์‹ ์„ 1์”ฉ ๊ฐ์†Œํ•˜๋ฉด์„œ 1์ด ๋  ๋•Œ๊นŒ์ง€ ์ž์‹ ์˜ ๊ฐ’์„ ๊ณฑํ•œ ๊ฒƒ์ด๋‹ค.

์ฝ”๋“œ๋กœ ์ด๋ฅผ ์˜ฎ๊ฒจ๋ณด์ž๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

function recursiveFactorial(n) { 
	if (n === 0) {
		return 1; }
	else {
		return n * factorial(n-1);
	} 
}

 

ํŒฉํ† ๋ฆฌ์–ผ์˜ ๋™์ž‘์„ ์Šคํƒ์œผ๋กœ ๋‚˜ํƒ€๋‚ด๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

๊ฐ ๋ฃจํ”„์—์„œ n์ด 1์ด ๋  ๋•Œ๊นŒ์ง€ ์Šคํƒ์— push๋ฅผ ํ•˜๊ณ , ์Šคํƒ์„ pop ํ•˜๋ฉด์„œ ์ด์ „ ๊ฐ’์— ๊ณ„์‚ฐ์„ ํ•ด์ฃผ๋ฉด ์œ„์˜ ์žฌ๊ท€ ํ•จ์ˆ˜์™€ ์œ ์‚ฌํ•˜๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค.

function factorial(n){
	let stack = new Stack();
    while(n>1){
    	stack.push(n--);
    }
    let product = 1;
    while(stack.length() > 0){
    	product *= stack.pop();
    }
    return product;
}

print(factorial(5)); // 120
print(recursiveFactorial(5)); // 120

 

๐Ÿ€ ๋งˆ์น˜๋ฉด์„œ

์˜ค๋Š˜์€ ์Šคํƒ ์ž๋ฃŒ ๊ตฌ์กฐ์— ๋Œ€ํ•ด ์‚ดํŽด๋ดค๋‹ค.
๊ธฐ๋ณธ์ ์ธ ๋‚ด์šฉ์„ ๋‹ค๋ค„์„œ ๊ฐ€๋ณ๊ฒŒ ์ฝ๊ณ  ์ •๋ฆฌํ•  ์ˆ˜ ์žˆ๋˜ ์žฅ์ธ ๊ฑฐ ๊ฐ™๋‹ค.
๋‹ค์Œ์—๋Š” ๊ฑฐ์˜ ์ง๊ฟ์ฒ˜๋Ÿผ ๋ถ™์–ด ๋‹ค๋‹ˆ๋Š” ํ(queue)์— ๋Œ€ํ•ด ์‚ดํŽด๋ณด์ž.

๐Ÿ“š Reference

- Data Structures and Algorithms Using Javaโ€ Script by Michael McMillian (O’Reilly). Copyright 2014 Michael McMillan, 978-1-449-36493-9