๐ก ์ฐ๋์ด ์ฐ์ด๋ผ๋ ๋ป์ด ์ด๋ฐ ๊ฒ์ ๋งํ๋ ๊ฒ์ธ๊ฐ.. ๋๋ฌด ๋๋ฌด ์ด๋ ต๋ค..
๋ฌธ์
๐ก ๋ฐฐ์ด [1, 2, 3, 7, 9]์์ ๋ฐฐ์ด [2, 3, 7, 9]๋ก ๋ณ๊ฒฝํ์์ค
๋น์ฐํ ์๋ ๋ฌธ์ ๊ธฐ์ ๋์ถฉ ๋ด๊ฐ ๋ง๋ค์๋ค.
ํด๋ต
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node *prev;
struct Node *next;
} Node;
Node *head, *tail;
void insert(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data;
Node* cur;
cur = head->next;
while(cur->data < data && cur != tail) {
cur = cur->next;
}
Node* prev = cur->prev;
prev->next = node;
node->prev = prev;
cur->prev = node;
node->next = cur;
}
void removeFront() {
Node* node = head->next;
head->next = node->next;
Node* next = node->next;
next->prev = head;
free(node);
}
void show() {
Node* cur = head->next;
while (cur != tail) {
printf("%d ", cur->data);
cur = cur->next;
}
}
int main(void) {
head = (Node*) malloc(sizeof(Node));
tail = (Node*) malloc(sizeof(Node));
head->next = tail;
head->prev = head;
tail->next = tail;
tail->prev = head;
insert(2);
insert(1);
insert(3);
insert(9);
insert(7);
removeFront();
show();
return 0;
}
์ค๋ช
์ผ๋จ ํจ์๋ง๋ค ์ค๋ช ์ด ํ์ํ ๊ฒ ๊ฐ์์ ํจ์๋ณ๋ก ์ค๋ช ์ ์ ์ด๋ณด๊ฒ ๋ค.
๋ด๊ฐ ์ดํดํ๊ธฐ ์ด๋ ค์ ๋ ์ด์ ๊ฐ ‘์๋ฐฉํฅ’์ด๋ผ๋ ๊ฒ์ ์ ์ดํด๋ฅผ ๋ชปํด์ ์ดํดํ๊ธฐ ๋ ์ด๋ ค์ ๋ค.
main ํจ์
prevnext↔prevnext
head | tail |
main ํจ์์์ insert ํจ์๋ฅผ ํธ์ถํ๊ธฐ ์ ์๋ ์์ ๊ฐ์ ๋ชจ์์ธ ๊ฒ์ด๋ค.
head->next = tail; // head์ next๋ tail์ด๋ค.
head->prev = head; // head์ prev๊ฐ์ head ์์ ์ด๋ค.
tail->next = tail; // tail์ next๋ tail์ด๋ค. tail์ next๊ฐ ์๋ค.
tail->prev = head; // tail์ prev๋ ์๋ฐฉํฅ์ด๋ฏ๋ก head์ด๋ค.
insert ํจ์
์ด๋ฒ์๋ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ ธ๋๋ฅผ ์ฝ์ ํด๋ณด๋ ค๊ณ ํ๋ค.
void insert(int data) {
Node* node = (Node*) malloc(sizeof(Node));
node->data = data; // node์ ๋ฐ์ดํฐ๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์์จ data๋ก ์ด๊ธฐํ ํ๋ค.
Node* cur; // cur ๋ณ์๋ฅผ ์ด๊ธฐํ ํด์ค๋ค.
cur = head->next; // head์ next๊ฐ ์ฒซ๋ฒ์งธ ์์์ด๋ค.
while(cur->data < data && cur != tail) {
/* ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ธฐ ์ํด cur์ ํ์ฌ data๊ฐ ๋ค์ด์จ data๋ณด๋ค ์๊ณ
cur์ด tail์ด ์๋์ฌ์ผ cur์ next๋ฅผ ๋ค์ next๋ก ์ด๋ํด์ค๋ค.
์) cur->data = 5์ด๊ณ ์ฝ์
ํ data๊ฐ 6์ด๋ผ๋ฉด ์ ๋ ฌํ์ง ์๋๋ค.
์) cur->data = 5์ด๊ณ ์ฝ์
ํ data๊ฐ 4๋ผ๋ฉด ์ ๋ ฌํ๋ค. */
cur = cur->next;
}
Node* prev = cur->prev; // prev๋ฅผ ์ฝ์
ํ ๋
ธ๋์ ๋ฐ๋ก ์์ชฝ ๋
ธ๋๋ก ์๋ฆฌ๋ฅผ ์ก์์ค๋ค.
prev->next = node; // ํ์ฌ ์ฝ์
ํ ๋
ธ๋
node->prev = prev; // ํ์ฌ ์ฝ์
ํ ๋
ธ๋์ ์์ชฝ์ ์๋ ๋
ธ๋
cur->prev = node; // ๋ค์ชฝ์ ์๋ ๋
ธ๋๊ฐ prev
node->next = cur; // ์ฝ์
ํ ๋
ธ๋์ ๋ฐ๋ก ๋ค์ ๋ค์ด๊ฐ ๋
ธ๋
}
์.. ํฌ์คํ ์ ํ๊ธฐ๋ ํ์ง๋ง ๋ฐฑํ๋ก ์ดํด๊ฐ ๊ฐ์ง๋ ์๋๋ค. (โโผฬดโฬห๏ธทหโผฬดโฬโ)
๊ฐ์์์๋ ๋นจ๋ฆฌ ๋์ด๊ฐ๊ณ .. ์ผ๋จ ์ฃผ์์ผ๋ก ์ค๋ช ์ ๋ค ์จ ๋์์ผ๋ ๊ณ์ ์ฝ์ด๋ณด๋ฉฐ ์ดํดํ๋ ๋ฐฉ๋ฒ๋ฐ์ ์๋ ๊ฒ ๊ฐ๋ค.
removeํจ์
์ด๋ฒ์๋ ์ฒซ๋ฒ์งธ ๋ ธ๋๋ฅผ ์ญ์ ํด ๋ณด๋ ค๊ณ ํ๋ค.
void removeFront() {
Node* node = head->next; // node๋ head์ next๊ฐ ๋ ์ ์๊ฒ ํ๋ค.
head->next = node->next; // head์ next๋ node์ next๊ฐ ๋๊ฒ ํ์ฌ ๋ค์ ๋
ธ๋๋ฅผ ๊ฐ๋ฆฌํฌ ์ ์๊ฒ ํ๋ค.
Node* next = node->next; // next๋ node์ next๊ฐ ๋๊ฒ ํ๋ค.
next->prev = head; // next์ prev๋ head๊ฐ ๋๊ฒ ํ๋ค.
free(node); // node์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ํด์ ์์ผ์ค๋ค.
}
์ ์ ๋ง ์ด๋ ต๋ค..
๋ง์น๋ฉฐ..
์ ๋ง 8๋ถ์ง๋ฆฌ ๊ฐ์๋ฅผ ์ฌ์ฏ์๊ฐ ๋๊ฒ ์ดํดํ๋ ค๊ณ ํ๋ฉด์ ๊ณ์ ๋๋ ค๋ดค๋๋ฐ ์ด๋ ๊ฒ ์ดํด๊ฐ ๋์ง ์๋ ๊ฒ์ ๋์ ๋ฌธ์ ์ธ ๊ฒ์ธ๊ฐ..๊ป๊ป
์ ์๋… ๋๋ฌด ๋น ๋ฅด๊ณ ์ค๋ช ์ด ๋ถ์กฑํด์..