๊ฐ์ธ ๊ณต๋ถ ๊ณผ์ ์ ๊ธฐ๋กํฉ๋๋ค.
๐ What I Will Learn
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ํ์์ฑ๊ณผ ์ฌ์ฉ์ ๋ํด ํ์ตํ๋ค
- C์ธ์ด๋ฅผ ํ์ฉํ์ฌ ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํด๋ณธ๋คโฆ
์ฐ๊ฒฐ ๋ฆฌ์คํธ(Linked List)
1๏ธโฃ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ํ์์ฑ
- ์ผ๋ฐ์ ์ผ๋ก ๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์์ฐจ์ ์ผ๋ก ์ ์ฅํ๊ณ , ๋์ดํ ์ ์์ง๋ง
- ๋ฐฐ์ด์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋ถํ์ํ๊ฒ ๋ญ๋น๋ ์ ์๋๋ฏ๋ก
- ์ด๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ก ๋์ฒดํ ์ ์๋ค
โ๏ธ ๋ฐฐ์ด ๊ธฐ๋ฐ ๋ฆฌ์คํธ๋?
- ๋ฐ์ดํฐ๋ฅผ ์์ฐจ์ ์ผ๋ก ์ ์ฅ, ์ฒ๋ฆฌํ ๋๋ ๋ฐฐ์ด ๊ธฐ๋ฐ์ ๋ฆฌ์คํธ๋ฅผ ์ด์ฉ
#include <stdio.h>
#define INF 10000
int arr[INF];
int count = 0;
void addBack(int data) {
arr[count] = data;
count++;
}
void addFirst(int data) {
for (int i = count; i >= 1; i--) {
arr[i] = arr[i - 1];
}
arr[0] = data;
count++;
}
void show() {
for (int i = 0; i < count; i++) {
printf("%d ", arr[i]);
}
}
int main(void) {
addFirst(4);
addFirst(5);
addFirst(1);
addBack(7);
addBack(6);
addBack(8);
show();
system("pause");
return 0;
}
๊ทธ๋ ๋ค๋ฉด?! ํน์ ํ ์์น์ ์์๋ฅผ ์ญ์ ํ๋ ํจ์๋ ์ด๋ป๊ฒ ๋ง๋ค ์ ์์๊น?
// ํน์ ํ index๋ฅผ ๋ฐ์์ ํด๋น index ์์น์ ๋ท ์์๋ฅผ ์์ผ๋ก ๋น๊ธฐ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํ
void removeAt(int index) {
for (int i = index; i < count - 1; i++) {
arr[i] = arr[i + 1];
}
count--;
}
โ๏ธ ๋ฐฐ์ด ๊ธฐ๋ฐ ๋ฆฌ์คํธ์ ํน์ง
- ๋ฐฐ์ด๋ก ๋ง๋ค์์ผ๋ฏ๋ก ํน์ ํ ์์น์ ์์์ ์ฆ์ ์ ๊ทผํ ์ ์๋ค๋ ์ฅ์
index
๋ฅผ ํ์ฉ
- ๋ฐ์ดํฐ๊ฐ ๋ค์ด๊ฐ ๊ณต๊ฐ์ ๋ฏธ๋ฆฌ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋นํ๋ค๋ ๋จ์
#define INF 10000
- ์ํ๋ ์์น๋ก์ ์ฝ์
๋๋ ์ญ์ ๊ฐ ๋นํจ์จ์
- for๋ฌธ์ผ๋ก ์์ผ๋ก ๋น๊ธฐ๊ฑฐ๋ ๋ค๋ก ๋ฐ์ด์ ์ถ๊ฐ ๋๋ ์ญ์ ํ๋ ์์ ์ฝ๋
2๏ธโฃ ์ฐ๊ฒฐ ๋ฆฌ์คํธ
- ์ผ๋ฐ์ ์ผ๋ก ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๊ตฌ์กฐ์ฒด์ ํฌ์ธํฐ๋ฅผ ํจ๊ป ์ฌ์ฉํ์ฌ ๊ตฌํ
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๋ฆฌ์คํธ์ ์ค๊ฐ ์ง์ ์ ๋ ธ๋๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ ์ ์์ด์ผ ํจ
- ํ์ํ ๋ ๋ง๋ค ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋น ๋ฐ๋๋ค
๐ ์ฐธ๊ณ !
- ํฌ์ธํฐ๋? โฌ ๏ธํด๋ฆญ
- ๊ตฌ์กฐ์ฒด๋?
โ๏ธ ๋จ์ผ ์ฐ๊ฒฐ๋ฆฌ์คํธ
- ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๋ฐ์ดํฐ
data
์ ๋ค์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋next
๋ก ๊ตฌ์ฑ๋์ด ์๋ค - ํฌ์ธํฐ๋ฅผ ์ด์ฉํด ๋จ๋ฐฉํฅ์ ์ผ๋ก ๋ค์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํจ๋ค
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์์ ๋
ธ๋๋ฅผ
ํค๋(Head)
๋ผ๊ณ ํ๋ฉฐ ๋ณ๋๋ก ๊ด๋ฆฌํ๋ค - ๋ค์ ๋
ธ๋๊ฐ ์๋ ๋ ๋
ธ๋์ ๋ค์ ์์น ๊ฐ์ผ๋ก
**NULL
**์ ์ถ๊ฐํ๋ค
โ๏ธ ๋จ์ผ ์ฐ๊ฒฐ๋ฆฌ์คํธ ๊ตฌํ
1) ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๊ตฌ์กฐ์ฒด ๋ง๋ค๊ธฐ
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int data;
struct Node *next; // ๋ค์ ๋
ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ๋ณ์. ํฌ์ธํฐ ๋ณ์
} Node;
Node *head; // ํฌ์ธํฐ ๋ณ์๋ฅผ ํ์ฉํด ๋์ ํ ๋น์ด ์ด๋ฃจ์ด์ง๋๋ก ํ๋ค
2) ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๊ตฌ์กฐ์ฒด ์ฌ์ฉํด๋ณด๊ธฐ
malloc()
ํจ์๋ก ๋์ ํ ๋นํ๊ธฐ
int main(void) {
head = (Node*) malloc(sizeof(Node));
Node *node1 = (Node*) malloc(sizeof(Node));
node1->data = 1;
Node *node2 = (Node*) malloc(sizeof(Node));
node2->data = 2;
head->next = node1;
node1->next = node2;
node2->next = NULL;
Node *cur = head->next;
while (cur != NULL) {
printf("%d ", cur->data);
cur = cur->next;
}
system("pause");
return 0;
}
- ๊ฒฐ๊ณผ๋ 1, 2๊ฐ ์ถ๋ ฅ๋๋ฉฐ ์๋์ ๊ทธ๋ฆผ์ ๋ชจ์์ด ์์ฑ
3) ๋ ธ๋ ์ฝ์
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ฝ์ ํจ์ ๊ตฌํ
void addFront(Node *root, int data) {
Node *node = (Node*) malloc(sizeof(Node));
node->data = data;
node->next = root->next;
root->next = node;
}
4) ๋ ธ๋ ์ญ์
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ญ์ ํจ์ ๊ตฌํ
void removeFront(Node *root) {
Node *front = root->next;
root->next = front->next;
free(front);
}
5) ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ํด์
free()
ํจ์๋ก ๋ ธ๋๋ฅผ ํ๋์ฉ ์ ๊ทผํด์ ํด์ ํด์ผ ํจ
void freeAll(Node *root) {
Node *cur = head->next;
while (cur != NULL) {
Node *next = cur->next;
free(cur);
cur = next;
}
}
6) ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ ์ฒด ์ถ๋ ฅ ํจ์
void showAll(Node *root) {
Node *cur = head->next;
while (cur != NULL) {
printf("%d ", cur->data);
cur = cur->next;
}
}
7) ์์ฑ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ฌ์ฉํ๊ธฐ
int main(void) {
head = (Node*) malloc(sizeof(Node));
head->next = NULL;
addFront(head, 2);
addFront(head, 1);
addFront(head, 7);
addFront(head, 9);
addFront(head, 8);
removeFront(head);
showAll(head);
freeAll(head);
system("pause");
return 0;
}
โ๏ธ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ํน์ง
- ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ๋ฐฐ์ด์ ๋นํด ๊ฐ๋จํ๋ค๋ ์ฅ์
- ๋ฐฐ์ด๊ณผ ๋ค๋ฅด๊ฒ ํน์ ์ธ๋ฑ์ค๋ก ์ฆ์ ์ ๊ทผํ์ง ๋ชปํ๊ณ , ์์๋ฅผ ์ฐจ๋ก๋๋ก ๊ฒ์ํด์ผ ํ๋ค๋ ๋จ์
- ์ถ๊ฐ์ ์ธ ํฌ์ธํฐ ๋ณ์๊ฐ ์ฌ์ฉ๋๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋ญ๋น๋๋คโฆ..
โจ tl;dr
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๋ฐ์ดํฐ๋ฅผ ์ ํ์ ์ผ๋ก ์ ์ฅํ๊ณ ์ฒ๋ฆฌํ๋ ํ ๋ฐฉ๋ฒ์ด๋ค
- ๊ธฐ์กด์ ๋ฐฐ์ด์ ์ด์ฉํ์ ๋ ๋ณด๋ค ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ๋ง์ ๊ฒฝ์ฐ์ ํจ์จ์ ์ด๋ค
- ๋ค๋ง, ํน์ ์ธ๋ฑ์ค์ ๋ฐ๋ก ์ฐธ์กฐํด์ผ ํ ๋๊ฐ ๋ง๋ค๋ฉด ๋ฐฐ์ด์ ์ด์ฉํ๋ ๊ฒ์ด ํจ์จ์ ์ด๋คโฆ.