์๋ฃ๊ตฌ์กฐ๋ ํฌ๊ฒ ์ ํ ์๋ฃ ๊ตฌ์กฐ, ๋น์ ํ ์๋ฃ ๊ตฌ์กฐ๋ก ๋๋๋ค
์ ํ ์๋ฃ ๊ตฌ์กฐ:
- ๋ฆฌ์คํธ, ์คํ, ํ, ๋ฑ ๋ฑ ๋น์ ํ ์๋ฃ ๊ตฌ์กฐ:
- ๊ทธ๋ํ, ํธ๋ฆฌ, ํ ๋ฑ
๊ณ ์ ๋ ํฌ๊ธฐ
๋ฅผ ๊ฐ๋ ๊ฐ์ ์๋ฃํ
์ ์์๋ค์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋์ด ์๋ ์๋ฃ๊ตฌ์กฐ
- ์ธ๋ฑ์ค(index)๋ฅผ ํตํ ์์์ ๊ทผ ๊ฐ๋ฅ (Random Access)
- ๋ฐ์ดํฐ์ ๊ฐ์๊ฐ ํ์คํ๊ฒ ์ ํด์ ธ ์์ผ๋ฉฐ ์ ๊ทผ์ด ๋น๋ฒํ ๊ฒฝ์ฐ ํจ์จ์
- ํ์ง๋ง ์ฝ์ ๋๋ ์ญ์ ์ ๊ฒฝ์ฐ ์ฐ์์ ์ธ ํํ ์ ์ง๋ฅผ ์ํด shift ์ฐ์ฐ์ ํด์ผํ๊ธฐ ๋๋ฌธ์ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฐ๋ค O(n)
๋ฐฐ์ด์ ํฌ๊ธฐ๋ ์ ์ (static)
์ผ๋ก ์์ฑํ ๋ณํ์ง ์๋๋ค.
์ฒ์ ํฌ๊ธฐ๊ฐ 10์ด๋ผ๋ฉด ์ ์ฅ๋ ๋ฐ์ดํฐ๊ฐ 5๊ฐ์ฌ๋ ์ค์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 10์ผ๋ก ๋ณํ์ง ์๋๋ค
- ์ ํ์ ์ธ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ฉฐ ๋ฉ๋ชจ๋ฆฌ์ Stack ์์ญ์ ํ ๋น๋๋ค.
๊ฐ์ ์๋ฃํ
์ ์์๋ค์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋์ด ์๋ ์๋ฃ๊ตฌ์กฐ
- ์ ์ ๋ฐฐ์ด๊ณผ๋ ๋ค๋ฅด๊ฒ
๊ณ ์ ๋ ํฌ๊ธฐ
๋ฅผ ๊ฐ์ง์ง ์๋๋ค - C++ ์์๋
vector
๊ฐ ์๊ณ java์์๋arraylist
๊ฐ ์กด์ฌํ๋ค
๋์ ๋ฐฐ์ด
๋ก ์์๋ค์ด ๋ฉ๋ชจ๋ฆฌ ์์์ ์ค์ ๋ก ์์ฐจ์ ์ผ๋ก ์ ์ฅ๋์ด ์๋ค
- LIFO (Last In First Out) ๊ตฌ์กฐ์ด๋ค.
- ์ฃผ๋ก ๊ท ํ ์ด์ง ํธ๋ฆฌ๋ ํด์ ํจ์๋ฅผ ์ฌ์ฉํด ๊ตฌํ๋๋ค
- ์์์ ์์น์ ์๋ ์์์ ์ ๊ทผํ๋ ๊ฒ์ด ๋น ๋ฅด๋ค
- ์ฌ์ ๋ถ์ ๋๊ณ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ณ ๋ถ์กฑํ ๊ฒฝ์ฐ ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ค
vector ์ด๋ฆ
vector<int> v; // ๋ฒกํฐ์ ์ ์ธ
// ๋ฒกํฐ์ ์ฝ์
ํ๋ push_back()
v.push_back(1); // ๋ฒกํฐ์ 1 ์ฝ์
v.push_back(2); // ๋ฒกํฐ์ 2 ์ฝ์
v.push_back(3); // ๋ฒกํฐ์ 3 ์ฝ์
v.pop_back(); // ๋ง์ง๋ง ์์ ์ญ์
๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋๋ฆฌ๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํ๊ณ ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ์ฌ ๊ธฐ์กด์ ๋ฐฐ์ด์ ๋ณต์ฌํ๋ ๋ฐฉ์์ด๋ค
- ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์กฐ๊ธ์ฉ ๋๋ฆฌ๋ฉด ๋ฐฐ์ด์ด ์ฆ๊ฐํ ์๋ก ๋ณต์ฌํ๋ ํ์๊ฐ ์ฆ๊ฐํ๊ธฐ ๋๋ฌธ์ ๋นํจ์จ์ ์ด๋ค.
๋ฐฐ์ด์ ๋ฌธ์ ์ ์ ํด๊ฒฐํ๊ธฐ ์ํ ์๋ฃ๊ตฌ์กฐ๋ก
๋นํ์๋ ๋ฐ์ดํฐ์ ์ ์ฌ
๋ผ๋ ์ฅ์ ์ ๊ฐ์ง๋ค
- ๋ฐฐ์ด์์ ์ธ๋ฑ์ค๋ ์ ์ผ๋ฌด์ดํ
์๋ณ์
์ด์ง๋ง ๋ฆฌ์คํธ์์๋ ๋ช ๋ฒ์งธ ๋ฐ์ดํฐ์ธ์ง ์ ๋์ ์๋ฏธ๋ฅผ ๊ฐ์ง๋ค. - ๋น ์๋ฆฌ๋จผํธ๋ ํ์ฉํ์ง ์๋๋ค
- ํฌ๊ฒ ArrayList, LinkedList๋ก ๋๋๋ค
- C: ๋ฆฌ์คํธ ์ง์ x
- JavaScript: ๋ฐฐ์ด์ ๋ฆฌ์คํธ ๊ธฐ๋ฅ ํฌํจ
- Python: ๊ธฐ๋ณธ ๋ฆฌ์คํธ, ๋ฐฐ์ด ์ง์ x
- Java: ๋ฐฐ์ด๊ณผ ๋ฆฌ์คํธ ๋ชจ๋ ์ง์, ArrayList์ LinkedList๋ก ๋๋๋ค
๋ฐฐ์ด์ฒ๋ผ ๋ฐ์ดํฐ๋ค์ด ์์๋๋ก ๋์ด์ ๊ตฌ์กฐ
- ๋ฐฐ์ด์ ํน์ฑ์ ๊ณต์
๋ฐ์ดํฐ ์ ๊ทผ์ด ์ฉ์ดํ์ง๋ง ์ฝ์ , ์ญ์ ๊ฐ ๋๋ฆฌ๋ค
- ๋ฆฌ์คํธ๋ ๋ฐฐ์ด์ฒ๋ผ ํฌ๊ธฐ๊ฐ ์ ํ๋์ด ์๊ธฐ ๋๋ฌธ์ ํฌ๊ธฐ ๋ณ๊ฒฝ์ ๋ง์ ๋น์ฉ์ด ๋ฐ์ํ๋ค.
์๋ฐ์ ๊ฒฝ์ฐ ์๋์ผ๋ก ์ฌ์ด์ฆ๋ฅผ ๊ด๋ฆฌํ๋ค -> ๋์ ๋ฐฐ์ด(Dynamic Array)
์ฐ๊ฒฐ๋ฆฌ์คํธ๋ ๋ ธ๋์ ํฌ์ธํฐ๋ก ๊ตฌ์ฑ๋ ์ฌ๋ฌ๊ฐ์ ๋ ธ๋๊ฐ ์ฐ๊ฒฐ๋ ๊ตฌ์กฐ
- ํฌ๊ธฐ๊ฐ ๊ฐ๋ณ์ ์ธ ๋ฆฌ์คํธ๋ก ๋ฐฐ์ด์ ๋จ์ ์ ๋ณด์ํ๋ค
- ๋ ธ๋๋ฅผ ๊ฐ๋ฅดํค๋ ํฌ์ธํฐ๋ฅผ ์ ์ฅํ ์ ์ฅ๊ณต๊ฐ์ด ๋ฐ๋ก ํ์ํ๋ค
- ๋ฐฐ์ด๊ณผ๋ ๋ค๋ฅด๊ฒ ์์์ ๊ทผ์ด ์๋ ์์ฐจ์ ๊ทผ์ผ๋ก ํ์์ ๋ถ๋ฆฌํ์ง๋ง ์ฝ์ , ์ญ์ ๊ฐ ์ฉ์ดํ๋ค
์ฒซ๋ฒ์งธ ๋ ธ๋๋ฅผ ํค๋(head), ๋ง์ง๋ง ๋ ธ๋๋ฅผ ํ ์ผ(tail)์ด๋ผ๊ณ ํ๋ฉฐ ๊ฐ๊ฐ์ ๊ฐ๋ฅดํค๋ ํฌ์ธํฐ๊ฐ ๋ฐ๋ก ์กด์ฌํ๋ค
#include<stdio.h>
#include<stdlib.h>
typedef struct NODE{
int data;
struct NODE* next
}node;
void addNode(node *, int);
void deleteNode(node *);
int main(int argc, char * argv[])
{
node * head = (node *)malloc(sizeof(node));
head->next = NULL;
node * cur = head->next;
while(cur != NULL)
{
printf("%d\n", cur->data);
cur = cur->next;
}
return 0;
}
void addNode(node * head, int data)
{
node * newnode = (node *)malloc(sizeof(node));
newNode->data = data;
newNode->next = head->next;
head->next = newNode;
}
void deleteNode(node *)
{
node * delete = head->next;
head->next=delete->next;
free(delete);
}
LIFO(Last In Last Out) ํ์ ์ ์ถ ๋ฐฉ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ
- ์คํ์ ๋งจ ์๋ถ๋ถ์ ๊ฐ๋ฅดํค๋ top ํฌ์ธํฐ๊ฐ ์กด์ฌํ๋ค
๋ฐ์ดํฐ์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์คํ์ top์์๋ง ๊ฐ๋ฅํ๋ค
FIFO(First In First Out) ์ ์ ์ ์ถ ๋ฐฉ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ
- ํ์ ์ ์ฅ๋ ๋งจ ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ฅดํค๋ front์ ๋งจ ๋ท ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ฅดํค๋ rear ํฌ์ธํฐ๊ฐ ์กด์ฌํ๋ค
double-ended queue์ ์ค์๋ง๋ก์ ํ์ front์ rear์์ ๋ชจ๋ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ๊ฐ๋ฅํ ํ
ArrayList
- ์ํ๋ ๋ฐ์ดํฐ์ ์์์ ๊ทผ ๊ฐ๋ฅ
- ๋ฆฌ์คํธ์ ํฌ๊ธฐ๊ฐ ์ ํ๋์ด ์์ผ๋ฉฐ, ๋ฆฌ์คํธ์ ํฌ๊ธฐ๋ฅผ ์ฌ์กฐ์ ํ๋ ๊ฒ์ ๋ง์ ๋น์ฉ์ด ๋ฐ์
- ๋ฐ์ดํฐ์ ์ฝ์ , ์ญ์ ์ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฐ๋ค
LinkedList
- ๋ฐ์ดํฐ์ ์ฝ์ , ์ญ์ ๊ฐ ์ฉ์ด
- ์์์ ๊ทผ์ด ๋ถ๊ฐ๋ฅํ๊ณ ์์ฐจ์ ๊ทผ๋ง ๊ฐ๋ฅํ๋ค