- ๊ตฌํ์ด ์ฝ๊ณ ๋จ์ํฉ๋๋ค.
- random access๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
- ๋ฆฌ์คํธ์ ์ค๊ฐ์ ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๊ฑฐ๋ ์ญ์ ํ ๊ฒฝ์ฐ ๋ค์์ ๋ฐ์ดํฐ๋ฅผ ์ฎ๊ฒจ์ผ ํฉ๋๋ค.
- ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์์ต๋๋ค.-reallocation ํ์
- ๊ฐ๊ฐ์ ํญ๋ชฉ๋ค์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋ฉ๋๋ค.
- ๋ค๋ฅธ ๋ฐ์ดํฐ์ ์ด๋์์ด ์ค๊ฐ์ ์ฝ์ ์ด๋ ์ญ์ ๊ฐ ๊ฐ๋ฅํ๋ฉฐ,
- ํฌ๊ธฐ์ ์ ํ์ด ์์ต๋๋ค.
- random access๊ฐ ๋ถ๊ฐ๋ฅํ์ฌ ํ์ํ ๋ ธ๋์ ์ ๊ทผ์ด ๋ถํธํฉ๋๋ค.
- ๊ฐ๊ฐ์ ํญ๋ชฉ๋ค์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋์ง ์์ผ๋ฉฐ ์ฐ๊ฒฐ๋ ๋ค์ ์ฃผ์๊ฐ ํจ๊ป ์ ์ฅ๋ฉ๋๋ค
- Array๋ ๊ฐ๊ฐ์ ํญ๋ชฉ๋ค์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋ฉ๋๋ค.
- Linked List๋ ๊ฐ๊ฐ์ ํญ๋ชฉ๋ค์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋์ง ์์ต๋๋ค.
- ๋ฉ์ธ ๋ฉ๋ชจ๋ฆฌ ์์ ๋ฐ์ดํฐ๋ค์ ํฉ์ด์ ธ ์กด์ฌํฉ๋๋ค.
- ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ์ฌ ํ๋์ ์๋ฃ์์ ๋ค์ ์๋ฃ๋ฅผ ์ฝ๊ฒ ๊ฐ๋ฆฌํฌ ์ ์์ต๋๋ค.
- ๋ฐ์ดํฐ ํ๋์ ํฌ์ธํฐ์ธ ๋งํฌ ํ๋๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
#include <stdio.h>
#include <stdlib.h>
typedef struct node {
int data;
struct node* next; //์๊ธฐ ์ฐธ์กฐ ๊ตฌ์กฐ์ฒด
} NODE;
- ํ์ํ ๋๋ง๋ค ๋ ธ๋์ ๋น ๊ณต๊ฐ์ ๋ง๋ค์ด ์ค๋๋ค
NODE* create(int data) {
NODE* new_node = (NODE*)malloc(sizeof(NODE));
new_node->next = NULL;
new_node->data = data;
}
- ๋จผ์ ์ ๊ทผ์ ์๊ฐํ๊ณ ์ฝ์ ์ ์๊ฐํฉ๋๋ค.
- ์ฐ๊ฒฐ๋ฆฌ์คํธ๊ฐ ๋น์ด์์ ๊ฒฝ์ฐ
- ๊ฐ์ฅ ์์ ์ฝ์ ํ ๊ฒฝ์ฐ
- ๊ฐ์ฅ ๋ค์ ์ฝ์ ํ ๊ฒฝ์ฐ
- ์ค๊ฐ์ ์ฝ์ ํ ๊ฒฝ์ฐ
//ํด๋น ํจ์๋ data ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ค์ ์ ์ ํ ์์น์ ์ฝ์
ํฉ๋๋ค.
//๋ฐ์ดํฐ๋ฅผ ๋ค์ด๋์ data ๋ง๋ค๊ธฐ
//๋
ธ๋ ์ค๊ฐ ์ฝ์
์ ํ ๊ฒฝ์ฐ ์ปค์ ๋๊ฐ ๋ง๋๋ ์ด์
//๊ณผ์ -> ์ฝ์
์ด์ ๋
ธ๋์ ์์น์ ์ฝ์
์ดํ ๊ทธ๋ค์ ๋
ธ๋์ ์์น๋ ์์์ผ ํ๋ค
//1.์ฝ์
ํ๋ ค๋ ์๋ก์ด ๋
ธ๋ ์์ฑ
//2.์ฝ์
ํ๋ ค๋ ์ด์ ๋
ธ๋๊น์ง ์ด๋
//3.์ฝ์
๋
ธ๋์ link๋ฅผ ์ด์ ๋
ธ๋์ link๋ก ์ ์ฅ
//4.์ด์ ๋
ธ๋์ link๋ฅผ ์ฝ์
๋
ธ๋์ ์ฃผ์๋ก ์ ์ฅ
NODE* insert(NODE* head, int data) {
NODE* node, * p, * q;
node = create(data);
p = head;
q = head;
//์ปค์ =์ํ๋ ์์น๋ก ์ฎ๊ฒจ์ฃผ๊ธฐ ์์: q new data p
while (p != NULL) {
//p data๊ฐ ์ฒ์์ผ๋ก data๋ณด๋ค ํฌ๋ฉด ํ์ถ
if (p->data > data) { //์ ์ ํ ์์น ์ฐพ๊ธฐ
break;
}
//ํ์นธ์ฉ ์ด๋
q = p;
p = p->next;
}
//p๊ฐ ๋งจ ์์ ์๋ค๋ฉด ์ฆ head ์์ ์๋ค๋ฉด
//๋ง์ฝ head์ ์๋ฌด๊ฒ๋ ์๋ค ํด๋ ์ด if๋ฌธ์ผ๋ก ๋ค์ด๊ฐ๋ค
if (p == head) {
node->next = head;//node๊ฐ head๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ํ๋ค
head = node;//head๋ ๋งจ์์ ์์ด์ผ ํ๊ธฐ ๋๋ฌธ์ head๋ฅผ ๋งจ ์์ผ๋ก ์ด๋
}
//์ ์ผ ์์ ์๋๊ฒ ์๋๋ผ๋ฉด
else {
node->next = p;
q->next = node;
}
return head;
}
- ๋จผ์ ์ ๊ทผ์ ํ๊ณ ์ญ์ ๋ฅผ ์๊ฐํฉ๋๋ค.
- ์ฐ๊ฒฐ๋ฆฌ์คํธ๊ฐ ๋น์ด์์ ๊ฒฝ์ฐ
- ๊ฐ์ฅ ์ฒซ๋ฒ์จฐ์ ๋ ธ๋๋ฅผ ์ญ์ ํ ๊ฒฝ์ฐ
- ๊ฐ์ฅ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ์ญ์ ํ ๊ฒฝ์ฐ
- ์ค๊ฐ ๋ ธ๋๋ฅผ ์ญ์ ํ ๊ฒฝ์ฐ
- ์ญ์ ํ ๋ ธ๋๊ฐ ์๋ ๊ฒฝ์ฐ
//ํด๋น ํจ์๋ data ๊ฐ์ ๊ฐ์ง ๋
ธ๋๋ฅผ ์ญ์ ํฉ๋๋ค.
NODE* deleteNode(NODE* head, int data) {
NODE* p, * q;
p = head;
q = head;
//์ ๊ทผ
while (p != NULL) {
if (p->data == data) { //์ญ์ ํ ๋
ธ๋๋ฅผ ์ฐพ์ ๊ฒฝ์ฐ
break;
}
q = p;
p = p->next;
}
if (p == NULL) { //์ปค์๊ฐ ๋๊น์ง ์ด๋ํ ๊ฒ์ ์ญ์ ํ ๋
ธ๋๊ฐ ์๋ค๋ ๊ฒ์
๋๋ค.
return head;
}
else if (p == head) { //์ญ์ ๋
ธ๋๊ฐ ๊ฐ์ฅ ์์ ์์ ๊ฒฝ์ฐ
head = head->next;
free(p);
return head;
}
else { // ์ญ์ ๋
ธ๋๊ฐ ์ค๊ฐ์ ์๋ ๊ฒฝ์ฐ
q->next = p->next; //์ญ์ ๋
ธ๋ ์ด์ ๋
ธ๋์ ์ญ์ ๋
ธ๋ ๋ค์๋
ธ๋๋ฅผ ์ฐ๊ฒฐํฉ๋๋ค.
free(p);
return head;
}
}
์ฌ์ง ์ถ์ฒ
http://dorson23.blogspot.com/2018/02/c-1-linkedlist.html
https://server-engineer.tistory.com/130