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

Education

[๋ถ€์ŠคํŠธ ์ฝ”๋”ฉ ๋‰ด๋น„ ์ฑŒ๋ฆฐ์ง€ 2020] week6_์ƒ˜ํ”Œ๋ฏธ์…˜ : 2๊ฐœ์˜ ์—ฐ๊ฒฐ ๋ฆฌ์ŠคํŠธ ํ•ฉ์น˜๊ธฐ

๋ฐ˜์‘ํ˜•

๐Ÿ’ก ์ƒ˜ํ”Œ๋ฏธ์…˜ (์ œ์ถœ์šฉX)

โ–บ ๋‰ด๋น„ ์—ฌ๋Ÿฌ๋ถ„๋“ค๊ป˜์„œ ๋ฏธ์…˜์„ ์ˆ˜ํ–‰ํ•˜์‹œ๋Š”๋ฐ ๋„์›€์ด ๋  ์ˆ˜ ์žˆ๊ฒŒ ๋ฏธ์…˜์ƒ˜ํ”Œ์„ ๋‹ต์ง€์™€ ํ•จ๊ป˜ ์ œ๊ณตํ•ด๋“œ๋ฆฝ๋‹ˆ๋‹ค. ๋ฏธ์…˜์ƒ˜ํ”Œ์€ ์ œ์ถœ์šฉ์ด ์•„๋‹Œ ์•„๋ž˜์˜ ๋ฏธ์…˜์„ ํ’€๊ธฐ์œ„ํ•ด ์ฐธ๊ณ ํ•˜๊ธฐ ์œ„ํ•œ ๋ฏธ์…˜์ž…๋‹ˆ๋‹ค.

 

โœ”๏ธŽ ์ƒ˜ํ”Œ๋ฏธ์…˜.

 

1. ๋ฏธ์…˜ ์ œ๋ชฉ
2๊ฐœ์˜ ๋ฆฌ์ŠคํŠธ ํ•ฉ์น˜๊ธฐ

 

2. ์ง€์‹œ๋ฌธ

EDWITH CS50 ๊ฐ•์ขŒ๋ฅผ ๋ชจ๋‘ ์ˆ˜๊ฐ•ํ•œ ์—ฌ๋Ÿฌ๋ถ„์€ ์œ ๋Šฅํ•œ ๊ฐœ๋ฐœ์ž๋กœ ํšŒ์‚ฌ์— ์†Œ๋ฌธ์ด๋‚˜ ํ•ต์‹ฌ ๋ถ€์„œ๋กœ ๋ฐฐ์น˜๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ํ•ต์‹ฌ๋ถ€์„œ์˜ ์ฃผ์š” ์ž„๋ฌด ์ค‘ ํ•˜๋‚˜๋Š” ๋‹ค๋ฅธ ๋ถ€์„œ์˜ ์—…๋ฌด๋ฅผ ์ข…ํ•ฉํ•˜๋Š” ์ผ์ž…๋‹ˆ๋‹ค. ๋ถ€์„œ ๋ฐฐ์น˜ ์ฒซ ์—…๋ฌด๋กœ A๋ถ€์„œ์—์„œ ์ˆ˜ํ–‰ํ•œ ์—…๋ฌด์™€ B๋ถ€์„œ์—์„œ ์ˆ˜ํ–‰ํ•œ ์—…๋ฌด๋ฅผ ํ•ฉ์น˜๋Š” ์ผ์„ ๋งก๊ฒŒ ๋˜์—ˆ์Šต๋‹ˆ๋‹ค.


A๋ถ€์„œ์—์„œ๋Š” ๋ฏธ๊ตญ ์ง€์‚ฌ๋“ค์˜ ๋งค์ถœ์ด ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌ๋œ ์ž๋ฃŒ๋ฅผ ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ ํ˜•ํƒœ๋กœ ๋ณด๋‚ด์™”๊ณ , B๋ถ€์„œ์—์„œ๋Š” ํ•œ๊ตญ ์ง€์‚ฌ๋“ค์˜ ๋งค์ถœ์ด ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌ๋œ ์ž๋ฃŒ๋ฅผ ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ ํ˜•ํƒœ๋กœ ๋ณด๋‚ด์™”์Šต๋‹ˆ๋‹ค.


์—ฌ๋Ÿฌ๋ถ„์˜ ์—…๋ฌด๋Š” ์ด์ œ ๋‘ ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ๋ฅผ ํ•˜๋‚˜์˜ ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ๋กœ ํ•ฉ์น˜์–ด ํ•œ๊ตญ๊ณผ ๋ฏธ๊ตญ ์ง€์‚ฌ๋“ค์˜ ๋งค์ถœ์ด ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌ๋œ ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ๋ฅผ ๋งŒ๋“œ์‹œ๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, A๋ถ€์„œ์—์„œ ๋ณด๋‚ด์˜จ ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ๊ฐ€ 2->6->9->10, B๋ถ€์„œ์—์„œ ๋ณด๋‚ด์˜จ ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ๊ฐ€ 1->5->7->8->11 ์ด๋ผ๋ฉด ์—ฌ๋Ÿฌ๋ถ„์ด ๋งŒ๋“ค ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ๋Š” 1->2->5->6->7->8->9->10->11 ์ด ๋˜์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.


์—…๋ฌด ์ˆ˜ํ–‰์„ ์œ„ํ•ด ์—ฐ๊ฒฐ ๋ฆฌ์ŠคํŠธ๋ฅผ ํ•ฉ์น˜๋Š” ํ•จ์ˆ˜์™€ ํ•ฉ์ณ์ง„ ์—ฐ๊ฒฐ ๋ฆฌ์ŠคํŠธ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“ค์–ด์ฃผ์„ธ์š”.

 

/**
 * ์—ฐ๊ฒฐ ๋ฆฌ์ŠคํŠธ์˜ ํ˜•ํƒœ๋Š” ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.
 * struct ListNode {
 *     int sales;
 *     struct ListNode *next;
 * } ListNode;
 */


struct ListNode* mergeTwoLists(ListNode* list1, ListNode* list2){
    // ํ•จ์ˆ˜๋ฅผ ์ฑ„์›Œ์ฃผ์„ธ์š”!
}

void append(ListNode* l, int data) {
    // ํ•จ์ˆ˜๋ฅผ ์ฑ„์›Œ์ฃผ์„ธ์š”.
void printMergedLinkedList(ListNode* list3) {
    // ํ•จ์ˆ˜๋ฅผ ์ฑ„์›Œ์ฃผ์„ธ์š”!
}

int main() {
ListNode* listA = (ListNode*)malloc(sizeof(ListNode));
ListNode* listB = (ListNode*)malloc(sizeof(ListNode));

append(listA, 2);
append(listA, 6);
append(listA, 9);
append(listA, 10);
printList(listA);

append(listB, 1);
append(listB, 5);
append(listB, 7);
append(listB, 8);
append(listB, 11);
printList(listB);

ListNode* result = mergeTwoLists(listA, listB);
printList(result);
}

 

main ํ•จ์ˆ˜์—๋Š” ์œ„์™€ ๊ฐ™์ด ์ •๋ ฌ๋œ ์—ฐ๊ฒฐ ๋ฆฌ์ŠคํŠธ 2๊ฐœ๊ฐ€ ๋ฏธ๋ฆฌ ๋งŒ๋“ค์–ด์ ธ ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•ฉ๋‹ˆ๋‹ค. ์—ฌ๋Ÿฌ๋ถ„์ด ์ž‘์„ฑํ•˜์‹  ํ•จ์ˆ˜ mergeTwoLists ํ•จ์ˆ˜, append ํ•จ์ˆ˜ ๊ทธ๋ฆฌ๊ณ  printMergedLinkedList๋ฅผ ์ˆœ์„œ๋Œ€๋กœ ํ˜ธ์ถœํ•˜๋ฉด ์ •๋ ฌ๋œ ๊ฒฐ๊ณผ ์ถœ๋ ฅ์ด ๋‚˜์˜ค๋„๋ก ์ž‘์„ฑํ•ด ์ฃผ์„ธ์š”.

A ๋ถ€์„œ์™€ B ๋ถ€์„œ์—์„œ ๋ณด๋‚ด๋Š” ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ๋Š” ๋ชจ๋‘ ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌ๋˜์–ด ์žˆ๋Š” ์ƒํƒœ์ด๋ฉฐ, A ๋ถ€์„œ์—์„œ ๋ณด๋‚ด์˜จ ๋ฆฌ์ŠคํŠธ์™€ B ๋ถ€์„œ์—์„œ ๋ณด๋‚ด์˜จ ๋ฆฌ์ŠคํŠธ์˜ ๊ธธ์ด๋Š” ๋‹ค๋ฅผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ž…๋ ฅ๊ฐ’: ์ •๋ ฌ๋œ 2๊ฐœ์˜ ์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ(Main ํ•จ์ˆ˜์— ๋ฌธ์ œ์™€ ๊ฐ™์ด ์„ ์–ธ๋˜์–ด ์žˆ๋‹ค๊ณ  ๊ฐ€์ •)
์ถœ๋ ฅ๊ฐ’: ์ •๋ ฌ๋œ ๋ฆฌ์ŠคํŠธ๊ฐ€ ์ถœ๋ ฅ๋˜๊ฒŒ ํ•ด์ฃผ์„ธ์š”.


์œ„์˜ ๋ฌธ์ œ๋ผ๋ฉด, ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ถœ๋ ฅ ๊ฐ’์ด ๋‚˜์™€์•ผ ํ•ฉ๋‹ˆ๋‹ค.
2 6 9 10
1 5 7 8 11
1 2 5 6 7 8 9 10 11

 

3. ํ•ต์‹ฌ ๊ฐœ๋…
#์—ฐ๊ฒฐ๋ฆฌ์ŠคํŠธ #๋ฆฌ์ŠคํŠธ ์‚ฝ์ž… #๋ฆฌ์ŠคํŠธ ํ•ฉ์น˜๊ธฐ #๋ฆฌ์ŠคํŠธ ์ถœ๋ ฅ #๋ณ‘ํ•ฉ์ •๋ ฌ

 


๐Ÿ”” ๋‹ต์•ˆ

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
    int data;
    struct node* next;
}ListNode;

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode* head = (ListNode *)malloc(sizeof(ListNode));
    ListNode* pt = head;

    l1 = l1->next;
    l2 = l2->next;

    while (l1!=NULL && l2!=NULL) {
        if (l1->data <= l2->data) {
            pt->next = l1;
            l1 = l1->next;
        } else {
            pt->next = l2;
            l2 = l2->next;
        }
        pt = pt->next;
    }
    if (l1 != NULL)
        pt->next = l1;
    if (l2 != NULL)
        pt->next = l2;
    return head;
}

void append(ListNode* l, int data) {
    ListNode* item = (ListNode*)malloc(sizeof(ListNode));
    item->data = data;
    item->next = NULL;

    ListNode* temp = (ListNode*)malloc(sizeof(ListNode));    
    temp = l;
    while(temp->next != NULL) {
        temp=temp->next;
    }
    temp->next = item;
}

void printList(ListNode* l) {
    while(l->next != NULL) {
        printf("%d ", l->next->data);
        l = l->next;
    }
    printf("\n");
}

int main() {
    ListNode* listA = (ListNode*)malloc(sizeof(ListNode));
    ListNode* listB = (ListNode*)malloc(sizeof(ListNode));

    append(listA, 2);
    append(listA, 6);
    append(listA, 9);
    append(listA, 10);
    printList(listA);

    append(listB, 1);
    append(listB, 5);
    append(listB, 7);
    append(listB, 8);
    append(listB, 11);
    printList(listB);

    ListNode* result = mergeTwoLists(listA, listB);
    printList(result);
}
๋ฐ˜์‘ํ˜•