일반적인 링크드 리스트는 Node가 다른 Node를 하나만 가리키고 있지만 이중 연결리스트는 앞 뒤로 하나씩 연결을 가지고 있습니다. 

그래서 탐색을 할때 해당 노드에서 앞에 노드나 뒤에 노드로 쉽게 왔다갔다 할 수 있는 장점이 있습니다. 특정 노드를 탐색하다가 뒤로 마음대로 갈 수 있다는 의미이다. 프로그램을 작성하기전에 이러한 상황이 꼭 필요하고 자주 발생할 것 같다면 이중 연결 리스트를 고려해 보아야 합니다. 

  

아래 Node를 보면 next와 prev 라는 2개의 Node 포인터를 볼 수 있습니다. 하나는 자신의 앞에 있는 노드(next)를 가르키며 다른하나는 자신의 뒤에 있는 노드(prev)를 가르키는 역할을 합니다.

생성자를 통해 기본적으로 포인터에 NULL을 대입 합니다. 그리고 파라미터를 받는 생성자는 파마리터로 받은 ptr을 가지고 해당 노드 다음에 자신을 놓도록 합니다. 포인터를 사용하기 때문에 복잡해 보일 수 있다. 종이에 하나하나 그려가며 코드를 보면 이해가 쉽게 갈 것입니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct Node { 
    int data;
    Node* next, * prev; 
    Node() {
        next = prev = NULL;
        data = 0;
    }
    Node(int i, Node* ptr)//ptr 뒤에 추가
    {
        data = i;
        prev = ptr;
        next = ptr->next;
        next->prev = prev->next = this
    }  
};
cs

 


그리고 이중 연결리스트의 또 다른 장점으로는 노드 자신을 삭제하는게 쉽습니다. 그 이유는 자신의 앞에노드와 뒤에 노드의 정보를 가지고 있기 때문에 포인터를 가지고 자신을 제외한 앞뒤 포인터를 서로 연결 시켜줄 수 있어서 입니다.

아래 예시는 자기 자신의 노드를 삭제하는 함수 입니다. 함수의 첫번째 줄은 자신의 뒤에 노드에 다음을 가르키는 포인터에 자기 자신의 다음 노드의 주소값을 넘겨줍니다. 그러면 뒤에 노드가 자신의 다음 노드를 가르키게 하는 것입니다. 두번째 줄에는 자신의 다음노드의 이전을 가르키고 있는 포인터에 자신이 가르키고 있는 뒷노드의 주소값을 넘겨주는 것입니다. 그리고 마지막으로 delete로 자기자신을 삭제해서 할당받은 메모리를 해제합니다. 간결한 코드이지만 처음이해하는데는 많은 어려움이 있을 수 있습니다.


1
2
3
4
5
void selvDelete() {
     prev->next = next;
     next->prev = prev;
     delete this;
}
cs


일반적으로 간단하게 데이터를 추가하고 탐색하는 경우에는 일반 연결 리스트를 구현하면 됩니다.

연결리스트를 활용하여 구현한 Stack 예제 : http://hijuworld.tistory.com/54


하지만 데이터를 탐색할 때 뒤로 갔다 앞으로 갔다하는 경우가 많고 데이터 삭제가 빈번한 경우라면 이중 연결 리스트로 구현하는 것이 좋습니다.


아래 예제는 이중연결리스트를 구현한 예제입니다.


C++을 기본으로 작성하였으며 데이터를 삽입이나 삭제 할때 가장 앞이나 가장 뒤에서 모두 가능하게 하였습니다.

필요한 기능의 함수가 있다면 DLinkedList 구조체에 추가하여 구현하면 됩니다. 

해당 예제를 가지고 데이터를 앞뒤로 삽입하고 삭제하기 때문에 왠만한 기능을 다 할 수 있습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include<iostream>
 
 
struct Node {
    int data;
    Node* next, * prev;
    Node() {
        next = prev = NULL;
        data = 0;
    }
    Node(int i, Node* ptr)//ptr 뒤에 추가한다.
    {
        data = i;
        prev = ptr;
        next = ptr->next;
        next->prev = prev->next = this
    }    
    void selvDelete() {
        prev->next = next;
        next->prev = prev;
        delete this;
    }
};
 
struct DLinkedList {
    Node *head;
    Node *tail;
    int count;
    DLinkedList() { //생성자
        count = 0;
        head = new Node(); //더미를 선언해서 가지고 있게한다.
        tail = new Node(); //더미를 선언해서 가지고 있게한다.
        head->next = tail; //서로연결한다.
        tail->prev = head;
    }
    ~DLinkedList() {
        while (head->next != tail)
            head->next->selvDelete();
        delete head;
        delete tail;
    }
    void firstInsert(int i) { //head 다음에 추가한다.
        new Node(i, head);
    }
    void endInsert(int i) { //tail 앞에 추가한다.
        new Node(i, tail->prev);
    }
    void firstDelete() { //head 다음 노드 삭제한다.
        if (head->next == tail)    return;
        head->next->selvDelete();
    }
    void endDelete() { //tail 앞에 제거한다.
        if (tail->prev == head) return;
        tail->prev->selvDelete();
    }
    void printAll() {
        Node* tmp = head;
        while (tmp->next != tail) {
            printf("%d\n", tmp->next->data);
            tmp = tmp->next;
        }
    }
};
 
int main() {
    DLinkedList *list = new DLinkedList();
    list->firstInsert(1); //1을 삽입한다.(가장앞)
    list->firstInsert(3); //3을 삽입한다.(1앞에)
    list->firstInsert(5); //5을 삽입한다.(3앞에)
    list->firstDelete(); //5를 삭제한다
    list->endInsert(100); //100을 삽입한다.(가장뒤에)
    list->endInsert(200); //200을 삽입한다.(100뒤에)
    list->endInsert(300); //300을 삽입한다.(200뒤에)
    list->endDelete(); //300을 삭제한다.
    list->printAll();
    delete list;
}
cs

 이중 연결리스트를 여러번 직접 종이에 그려가며 작성해 보아야 손에 익어서 언제든 작성 할 수 있습니다. 처음부터 코드를 완벽하게 작성하고 실행을 해야합니다. 대충 작성하고 디버깅을 해야지 하고 생각한다면 쉽게 에러를 찾을 수 없습니다. 포인터를 가지고 계속 왔다갔다 하기 때문에 디버깅에 많은 어려움이 있습니다. 연결 리스트 뿐만 아니라 데이터를 포인터로 연결하는 트리나 링큐 등도 디버깅하는데 많은 어려움이 있습니다. 처음부터 주의깊게 프로그래밍하는 것이 좋습니다. 


Posted by 꿈만은공돌
,

C++을 이용하여 LinkedList를 사용하여 Stack을 구현해보도록 하겠습니다.


 스택(Stack)을 설명하자면 다음과 같습니다. 가장 처음 데이터를 1을 넣으면 [1]이 됩니다. 거기에 2를 넣으면 [2, 1] 이 됩니다. 2->1을 가르키고 있는 것이죠. 그리고 4를 넣으면 [4,2,1]이 됩니다. 4->2->1 입니다. 여기에 10을 넣으면 [10, 4, 2, 1] 데이터가 됩니다. 이제 데이터를 꺼내면 10부터 나오게 됩니다. 마지막 넣은 데이터가 가장 처음 나오게 됩니다. 

 Last In First out 으로 줄여서  LIFO 라고 합니다. 

 10을 꺼내게 되면 [4, 2, 1]이 됩니다. 다시 데이터를 꺼내면 4가 나오게 됩니다. [2,1]이 됩니다. 그리고 하나더 꺼내면 2가 나오고 마지막으로 1이 나오게 됩니다.

 비유를 하자면 바닥에 이불을 하나씩 쌓는것을 생각하면 됩니다. 빨간이불을 먼저 쌓고 그다음에 검정이불을 쌓고 마지막으로 하얀이불을 쌓으면 다음에 꺼낼 때 하얀이불이 가장위에 있기때문에 하얀이불부터 꺼낼 수 있습니다.


Stack은이렇듯  LIFO 으로 마지막에 들어온 데이터가 가장 처음에 나오는 방식 입니다.


 연결리스트를 구현할때 Node들을 만들어서 서로 연결해야 합니다. Node는 기본적으로 데이터를 보관할 변수하나와 다른 노드를 가르킬 포인터 변수를 가집니다. 아래 예제에서는 data변수가 데이터를 저장할 변수가 됩니다. 그리고 next가 다른 노드를 가르킬 포인터가 됩니다. 

 그리고 추가로 생성자를 추가시켰습니다. 구조체에도 c++에서는 생성자나 함수등을 포함시킬 수 있습니다. class와의 차이는 모든 변수와 함수가 기본적으로 public입니다. 첫번째 생성자는 기본생성자로 초기화만 시킵니다. 다음생성자는 데이터와 다음 노드를 받습니다. 파라미터로 들어온 ptr 다음 노드로 자신을 가리키게 합니다. 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct Node {
    int data;
    Node* next;
    Node() {
        next = NULL;
        data = 0;
    }
 
    Node(int i, Node* ptr) //ptr 뒤에 추가
    {
        data = i;
        next = ptr->next;
        ptr->next = this
    }    
};
cs


연결 리스트(LinkedList)를 가지고 구현한 스택(stack) 코드입니다. 기본적으로 .cpp로 C++ 컴파일을 해야한다.

Stack에 생성자를 보면 new Node로 더미노드를 만들어서 head에 넣는 것을 볼 수 있습니다. 이는 pop과 push등을 할때 더미노드가 있어야 코드가 더 간결해집니다.

소멸자도 반드기 구현해줘야 합니다. 그래야 사용하지 않는 메모리를 heap에서 계속 점유하고 있기 때문에 프로그램이 계속 돌다가 메모리가 부족한 현상이 발생 할 수도 있습니다.

push 함수는 head 다음에 새로운 노드를 추가시킵니다. pop은 head 다음 노드를 꺼내는 역할을 합니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include<stdio.h>
 
struct Node {
    int data;
    Node* next;
    Node() {
        next = NULL;
        data = 0;
    }
 
    Node(int i, Node* ptr) //ptr 뒤에 추가
    {
        data = i;
        next = ptr->next;
        ptr->next = this
    }    
};
 
struct Stack {
    Node *head;
    int count;
    Stack() { //생성자
        head = new Node(); //더미노드
        count = 0;
    }
 
    ~Stack() { //소멸자
        while (count!=0) {
            pop();
        }
        delete head;
    }
 
    void pop() { //데이터 제거
        Node *tmp = head;
        head = head->next; 
        delete tmp; 
        count--;
    }
 
    void push(int i) { //데이터 삽입
        new Node(i, head);
        count++;
    }
 
    void printAll() { //모두 출력
        Node *cur = head;
        while (cur->next) {
            cur = cur->next;
            printf("%d\n", cur->data);
        }
    }
};
 
int main() {
    Stack *stack = new Stack();
    stack->push(1);
    stack->push(3);
    stack->push(5);
    stack->push(7);
    stack->printAll();
    delete stack;
}
cs

이제까지 단일 연결리스트에 대해서 알아 보았습니다. 

단일 연결리스트 vs 이중 연결 리스트


단일 연결 리스트는 Node가 다른 Node를 하나만 가리키고 있지만 이중 연결리스트는 앞 뒤로 하나씩 연결을 가지고 있습니다. 


그런데 이중연결리스트는 탐색을 할때 해당 노드에서 앞에 노드나 뒤에 노드로 쉽게 왔다갔다 할 수 있는 장점이 있습니다. 특정 노드를 탐색하다가 뒤로 마음대로 갈 수 있다는 의미이다. 프로그램을 작성하기전에 이러한 상황이 꼭 필요하고 자주 발생할 것 같다면 이중 연결 리스트를 고려해 보아야 합니다. 


이중 연결리스트 : http://hijuworld.tistory.com/55




Posted by 꿈만은공돌
,


알고리즘 문제를 풀다보면 특정 구간에 합이나 최대값, 최소값 등 정보를 얻어야 할 때가 있다.


데이터의 숫자가 얼마 안되면 배열에 값을 넣어두고 특정 구간을 차례로 탐색하며 값을 연산하여 구하면된다.


아래 예를 보자.8개의 숫자 중 특정 구간의 합을 구하는 문제이다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<stdio.h>
 
int data[8= { 1,22,4,8,11,23,6,14 }; //데이터
 
int segSum(int start, int end) { //start부터 end까지의 합
    int sum = 0;
    for (int i = start-1; i < end; i++) {
        sum += data[i];        
    }
    return sum;
}
 
int main() {
    //부분합 구하기
    printf("%d\n", segSum(18));
    printf("%d\n", segSum(88));
    printf("%d\n", segSum(13));
    printf("%d\n", segSum(35));
}
 
cs


데이터의 갯수가  적고 조회하는 횟수도 적다면 위와같은 코드는 문제가 될 것 이 없다.

하지만 데이터의 갯수가 100,000 개이고 부분합읠 조회하는 횟수가 100,000 이라고 하면 최악의 경우 

for문의 반복 횟수가 100,000 * 100,000 이란 어마어마한 숫자가 된다. 


그래서 이를 해결하기 위해 세그먼트 트리(Segment Tree)라는 바이너리 트리를 이용한다.


leaf 노드(가장 끝단에 있는 노드들)에 데이터를 저장하고 부모노드는 자식노드의 합 또는 최대값, 최소값 등을 저장한다.



위의 데이터를 세그먼트 트리로 만들면 아래와 같다.

각 노드에는 leaf노드들의 시작과 끝 번호를 가지고 있어서 해당 구간의 데이터를 요청하면 lead노드까지 탐색해보지 않고 값을 반환 하기 때문에 탐색시간이 빨라진다.


아래 코드는 위의 배열을 탐색하는 코드를 세그먼트 트리를 이용하여 구현한 것이다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include<stdio.h>
 
int data[8= { 1,22,4,8,11,23,6,14};
int index = 0;
 
struct SegTree {
    SegTree *left;    //왼쪽 노드
    SegTree *right; //오른쪽 노드
    int s, e, m;    //시작, 끝, 중간
    int sum;        //자식들의 합
    SegTree() {        //빈생성자
        s = e = m = sum = 0;
        left = right = NULL;
    }
    SegTree(int start, int end) { //생성자
        s = start;
        e = end;
        m = (s + e) / 2//중간값 계산
        if (start == end) { //leaf노드
            sum = data[index++]; //데이터 저장
            return//leaf노드라 더이상 쪼갤필요없어서 종료
        }
        //쪽개기
        left = new SegTree(s, m); //왼쪽 노드
        right = new SegTree(m + 1, e); //오른쪽 노드
        sum = left->sum + right->sum; //자식들의 합
    }
    int serch(int start, int end) {        //start부터 end까지의 합 계산
        if (start > e || s > end)    return 0;    //범위 초과
        if (start <= s && e <= end) return sum; //범위 안에 있음
        return right->serch(start, end) + left->serch(start, end);
    }    
};
 
int main() {
    SegTree *tree = new SegTree(18); //세그먼트 트리 생성
    printf("%d\n", tree->serch(88));
    printf("%d\n", tree->serch(13));
    printf("%d\n", tree->serch(18));
    printf("%d\n", tree->serch(35));
}
 
cs


3에서 5의 합을 구하는 것을 아래 그림을 참고하도록 하자.

구하려는 3~5의 구간을 가지고 노드가 가지고 있는 s와 e 값을 가지고 비교하며 값을 구한다.



Posted by 꿈만은공돌
,

이진탐색(2진탐색)은 정렬된 데이터에서 원하는 데이터를 빠르게 찾는 방식이다.


예를들어 1부터 100까지 숫자가 있다면 75를 찾아 보자.


일반적인 방식은 1부터 하나하나 데이터를 비교해가며 찾아야 한다.


O(N)에 복잡도를 가진다.


하지만 2진탐색을 사용하면 가장 중간데이터인 50부터 찾아서 비교해보고 50보다 찾아야 할 데이터인 75보다 작다.


그래서 50보다 큰수이기 때문에 50과 가장끝 데이터인 100중 가장 중간 데이터인 75를 비교해본다.


이렇게 중간데이터를 가지고 대소비교를 해가면서 데이터를 찾으면 


O(logN) 의 복잡도를 가진다.


훨씬 빠른 데이터 탐색을 할 수 있다.


코드 구현역시 간단한 편이다.




아래는 이진탐색 예제 코드이다.


아래와 같이 반복문을 가지고 시작과 끝부분의 데이터를 바꿔가며 찾는 방식이 있으며 재귀함수로도 구현이 가능 하다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include<stdio.h>
 
//size 크기의 data배열안에서 d를 찾기
//값이없으면 -1반환
//값이 있으면 data배열의 index 반환
int binarySearch(int data[], int size, int d)
{
    int s = 0//시작
    int e = size - 1//끝
    int m;
    while (s <= e) {
        m = (s + e) / 2;
        if (data[m] == d) return m;
        else if (data[m] > d) e = m - 1;
        else s = m + 1;
    }
    return -1;
}
 
int main() {
    int data[] = { 1,3,6,8,11,23,111,114,213 };
    int dataSize = sizeof(data) / sizeof(int);
    int ans = binarySearch(data, dataSize, 114);
    printf("%d\n", ans);
}
 
cs

Posted by 꿈만은공돌
,


병합정렬 위키 링크 


병합정렬은 O(NlogN) 에 시간복잡도를 가진다.

1,000 개의 데이터를 정렬 한다면 1,000 X log1,000 = 1,000 X 10 = 10,000 이다.

만약 1,000,000개의 데이터를 정렬 한다면 1,000,000 X log1,000,000 = 1,000,000 X 20 = 20,000,000 이다.

2천만으로 1ms정도 안에 처리가 가능한 수준이다.


버블 정렬이나 선택정렬 등은 O(N^2) 의 시간 복잡도를 가진다. 

1,000개의 데이터를 정렬 한다면 1,000 X 1,000 = 1,000,000 이 된다.

1,000,000개의 데이터를 정렬 한다면 1,000,000 X 1,000,000 = 1,000,000,000,000 이다.

1조나 되기때문에 1ms에 처리가 불가능 하다.

 

데이터에 숫자가 많으면 버블 정렬에 비해 속도가 엄청 빠르다.

하지만 임시 메모리를 두고 데이터를 복사해야하기 때문에 메모리 사용이 버블 정렬에 비해 크다.


데이터의 갯수가 1,000 개 수준이라면 버블 정렬을 이용해도 되지만 그 이상 만개가 된다면 병합정렬이나 퀵정렬을 고려해보아야 한다.




퀵정렬에 비해 병합정렬은 코드가 간단해서 구현하기가 쉬운편이고 퀵정렬에 비해 속도가 안정적이다.


병합정렬은 데이터를 반씩 쪼개서 반씩 정렬을 하는 방식이다.


4 1 2 3 을 오름차순 정렬 한다고 하면


4 과 1를 정렬하면 1 4 가 되고 

2와 3을 정렬 하면 2 3 이된다.

1 4 와  2 3을 정렬 하는데

각각 앞에서 부터 정렬을 시작한다.

1과 2를 비교하여 1이 작기 때문에 1을 넣고 그다음 4와 2를 비교하여 2가 작기 떄문에 1 2 로 저장하고

4와 3을 비교하여 3이 작기 때문에 1 2 3 이되고 마지막 4를 추가하여 1 2 3 4 가 된다.


모든 경우를 비교하지 않기때문에 속도가 빠르다.


기본적으로 병합정렬은 재귀함수로 구현한다.


반으로 쪼개서 다시 재귀함수로 호출하고


호출한 결과를 가지고 정렬을 한다.


이걸 계속 반복하는 방식이다.


- 바로 쓸 수 있는 병합 정렬(Merge Sort) 코드 오름차순 정렬 -


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void mergeSort(int data[], int s, int e) {
    int tmp[10000];
    int i = s;
    int k = s;
    int m = (s + e)/2;
    int j = m + 1;
    if (s >= e) return//쪼갤수 없음, 되돌아가기
    mergeSort(data, s, m); //분할
    mergeSort(data, m+1, e); //분할
    while ((i <= m) && (j <= e)) { //병합
        if (data[i] < data[j]) tmp[k++= data[i++];
        else tmp[k++= data[j++];
    }
    while (i <= m) tmp[k++= data[i++]; //나머지 병합
    while (j <= e)  tmp[k++= data[j++]; //나머지 병합
    for (i = s; i <= e; i++) data[i] = tmp[i]; //복사
}
cs



- 실제 사용 예제 -


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include<stdio.h>
void mergeSort(int data[], int s, int e) {
    int tmp[10000];
    int i = s;
    int k = s;
    int m = (s + e) / 2;
    int j = m + 1;
    if (s >= e) return//쪼갤수 없음, 되돌아가기
    mergeSort(data, s, m); //분할
    mergeSort(data, m + 1, e); //분할
    while ((i <= m) && (j <= e)) { //병합
        if (data[i] < data[j]) tmp[k++= data[i++];
        else tmp[k++= data[j++];
    }
    while (i <= m) tmp[k++= data[i++]; //나머지 병합
    while (j <= e)  tmp[k++= data[j++]; //나머지 병합
    for (i = s; i <= e; i++) data[i] = tmp[i]; //복사
}
 
int main() {
    int data[] = { 1,5,2,4,3,7,-1,10,};
    mergeSort(data, 0sizeof(data) / sizeof(int)-1);
    for (int i = 0; i < sizeof(data) / sizeof(int); i++) {
        printf("%d ", data[i]);
    }
    printf("\n");
}
cs



Posted by 꿈만은공돌
,

1부터 n까지 합을 구하는 방법을 for문으로 하는 방식과 단순 재귀함수를 이용하는 방식을 이전 블로그(http://hijuworld.tistory.com/3)에서 다뤘는데 이번에는 분할 정복 방식을 이용해서 구하는 함수에 대해서 알아 보겠습니다.



1
2
3
4
5
6
7
8
int divSum(int n) {
    if (n == 1)
        return 1;
    if (n % == 1)
        return divSum(n - 1+ n;
    else
        return divSum(n / 2)*+ (n / 2)*(n / 2);
}
cs


1부터 n까지 합을 반으로 쪼개면 다음과 같습니다.

뒷부분에 공통적으로  이 개 존재합니다. 이를 하나로 묶으면


 이 공통적으로 존재하기 때문에 하나로 묶으면 아래와 같이 정리가 됩니다.





앞부분  은 처음 구하려고 한 1 부터 N까지에  절반인 1부터  까지의 합니다.


그래서 아래와 같은 점화식을 구할 수 있습니다.





해당 점화식을 코드로 옮긴 것은 위의 코드 입니다.


해당 함수의 빅오는  와 같습니다.

for문을 이용해서 합을 구하는 방식은 O(n) 입니다.

아래 코드를 가지고 테스트를 해보면 해당 분할 정복 방식이 코드는 복잡해 보이지만 속도 면에서는 월등히 압서는 것을 볼 수 있습니다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <iostream>
#include <time.h>
using std::cout;
using std::endl;
 
int divSum(int n)  //분할 정복 방식
{
    if (n == 1)
        return 1;
    if (n % == 1)
        return divSum(n - 1+ n;
    else
        return divSum(n / 2)*+ (n / 2)*(n / 2);
}
int forSum(int n) // for 이용 방식
{
    int sum=0;
    for (int i = 1; i <= n; i++)
        sum += i;
    return sum;
}
int main() {
    clock_t start, end;
    double result;
    //분할 정복 방식
    start = clock(); 
    divSum(200000000);
    divSum(200000000);
    divSum(200000000);
    divSum(200000000);
    divSum(200000000);
    divSum(200000000);
    divSum(200000000);
    end = clock(); 
    result = (double)(end - start);
    printf("분할정복 시간 측정 : %f\n", result);
 
    //for문 이용방식
    start = clock();
    forSum(200000000);
    forSum(200000000);
    forSum(200000000);
    forSum(200000000);
    forSum(200000000);
    forSum(200000000);
    forSum(200000000);
    end = clock();
    result = (double)(end - start);
    printf("for 시간 측정 : %f\n", result);
    return 0;
}
cs


-실행 결과 - 

분할정복 시간 측정 : 0.000000

for 시간 측정 : 2746.000000

계속하려면 아무 키나 누르십시오 . . .


측정 결과를 보면 분할정복 방식은 1ms 미만이라 0으로 나오며 for문을 이용한 방식은 2746ms로 시간차이가 많이 나는 것을 알 수 있습니다.


많은 양의 숫자를 더할때는 분할 정복을 이용하는 것을 추천 합니다.



참고 서적 : 프로그래밍 대회에서 배우는 알고리즘 문제해결전략 (저자 구종만 지음, 인사이트 출판)


Posted by 꿈만은공돌
,


1부터 n까지 합을 구하는 두 가지 함수 코드 비교 입니다.


작성 언어는 C++이면 c언어에서 사용할 때는 cout endl 함수를 printf 로 변경하시면 됩니다.


sum 함수와 recursive 함수의 경우 언어에 상관없이 가져다 쓰시면 됩니다.


- 예  제 -

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include<iostream>
using std::cout;
using std::endl;
 
int sum(int n) { //1부터n까지의 합(for)
    int sum = 0;    //초기화
    for (int a = 1; a <= n; a++)
        sum += a;
    return sum;
}
 
int recursiveSum(int n) { //1부터n까지의 합(재귀)
    if (n == 1//탈출 조건
        return 1;
    else
        return n + recursiveSum(n - 1); //재귀호출
}
 
int main() {
    cout << "sum(for) : " << sum(4000)<<endl;
    cout << "sum(재귀) : " << recursiveSum(4000<< endl;
    return false;
}



Posted by 꿈만은공돌
,