'자료구조, 알고리즘'에 해당되는 글 10건

  1. 2019.03.29 [BOJ] 8979 올림픽 - 문제 풀이 1
  2. 2018.09.12 정렬 알고리즘 종류
  3. 2018.09.11 검색 알고리즘 종류 2
  4. 2018.09.06 자료구조 그래프(Graph) 1
  5. 2018.09.05 자료구조 힙(Heap)


문제의 조건은 3가지로 단순합니다. 

1. 금메달 수가 더 많은 나라  
2. 금메달 수가 같으면, 은메달 수가 더 많은 나라 
3. 금, 은메달 수가 모두 같으면, 동메달 수가 더 많은 나라  

얼핏보면 if문을 사용하여 조건을 걸어 풀 수 있지만  

'전체 메달 수의 총합은 1,000,000 이하이다.' 라는 입력 전제조건을  활용하여 
금,은,동 메달에 각각 점수를 부여하여 각각의 메달의 최대치(1,000,000)를 획득해도 
그보다 높은 메달 1개 보다 낮은 점수를 부여하여 풀 수있는 알고리즘입니다. 

다음은 score배열에 각각의 메달에 가중치를 부여하여 계산하여 저장하는 구문입니다. 

for (int i = 0; i < country_num; i++)  { 
     score[i][0] = arr[i][0]; // 1) 
     score[i][1] = (arr[i][1] * 1000000000000) + (arr[i][2] * 1000000)+ (arr[i][3] * 1); // 2) 


country_num은 입력받은 국가 개수입니다. 
score 배열은 국가 넘버, 국가 별 점수를 저장한 배열입니다. 
arr는 입력받은 배열입니다. 
1. 첫번째 열이 모두 국가 넘버이기 때문에 score배열 첫번째 행에 모두 저장합니다. 
2. arr배열의 두번째, 세번째, 네번째 열이 금,은,동메달 순이므로 각각에 가중치를 곱한 후 score배열에 저장합니다. 


두번째로 동일 점수에 대한 등수 계산법입니다. 
간단하게 구현 가능합니다. 

int count = 1; 
for (int i = 0; i < country_num; i++){ 
     if (score[i][0] == country){ 
          for (int j = 0; j < country_num; j++){ 
               if (score[i][1] < score[j][1]) count++; 
          
          break; 
     

cout << count; 

두번째로 들어온 입력 (등수를 알고싶은 국가K)을 country변수에 저장한 후 
반복문을 사용하여 배열의 인덱스를 알아냅니다(각 국가가 순서대로 입력되지 않기 때문에) 
인덱스를 알아낸 상태에서 다시 반복문을 사용하여 자신의 점수보다 큰 점수를 count하면 됩니다. 
break 사용 이유는 인덱스를 이미 찾은 상태이므로 더이상 반복문을 실행하지 않아도 되기 때문입니다. 

다음 실행 코드 전체입니다. 

 * score 배열의 자료형을 unsigned long long으로 한 이유는 가중치의 총 합이 10^19이 넘어가는 숫자이기 때문에 long long을 사용해도 범위(-9x10^19~9x10^19)안에 속하지만 가중치에 음수가 없기 때문에 편의상 unsigned long long으로 표현했습니다.

*전체 소스코드 

#include <iostream> 

using namespace std; 

int main() 

     int country_num = 0; 
     int country = 0; 
     int **arr = NULL; 
     unsigned long long **score = NULL; 

     cin >> country_num >> country; 

     arr = new int*[country_num]; 
     score = new unsigned long long*[country_num]; 

     for (int i = 0; i < country_num; i++) { 
          arr[i] = new int[4]; 
          score[i] = new unsigned long long[2]; 
     

     for (int i = 0; i < country_num; i++) 
          for (int j = 0; j < 4; j++) 
               cin >> arr[i][j]; 

     for (int i = 0; i < country_num; i++) { 
          score[i][0] = arr[i][0]; 
          score[i][1] = (arr[i][1] * 1000000000000) + (arr[i][2] * 1000000) + (arr[i][3] * 1); 
     

     int count = 1; 
     for (int i = 0; i < country_num; i++) { 
          if (score[i][0] == country) { 
               for (int j = 0; j < country_num; j++) { 
                    if (score[i][1] < score[j][1]) 
                         count++; 
                    
               break; 
          
     
     cout << count; 

     for (int i = 0; i < country_num; i++) 
          delete[] arr[i]; 
     delete[] arr; 

     return 0; 



질문사항은 댓글로 달아주세요!


'자료구조, 알고리즘' 카테고리의 다른 글

정렬 알고리즘 종류  (0) 2018.09.12
검색 알고리즘 종류  (2) 2018.09.11
자료구조 그래프(Graph)  (1) 2018.09.06
자료구조 힙(Heap)  (0) 2018.09.05
자료구조 이진 탐색 트리(Binary Search Tree)  (0) 2018.09.01
자료구조 트리(Tree)  (0) 2018.08.30
[자료구조] 큐 QUEUE  (0) 2018.08.19
[자료구조] 스택 STACK  (0) 2018.08.19


현재 많은 수의 알고리즘이 존재하지만 그중 실제 구현에서는 몇가지 알고리즘만 사용됩니다.


자바, C++ 등의 언어에서는 라이브러리로 O(n log n) 하한의 정렬 알고리즘을 제공하여 그냥 사용하면 되지만, 정렬 알고리즘을 더 깊게 공부하거나, 효율적인 정렬 알고리즘을 사용하려는 개발자를 위해 정렬 알고리즘에 대한 이해는 필수입니다.


실제 구현 시 사용되는 몇가지 알고리즘에 대해 비교 설명 해보겠습니다.

(각 알고리즘에 대한 상세 설명 및 구현방법은 생략합니다. 추후에 정리해서 올릴게요!)



비교 정렬 알고리즘 성능


이름

최적(Best)

평균(Average)

최악(Worst)

메모리

안정성(Stable)*

퀵(Quick) 정렬

n log n

n log n

n^2

log n ~ n

No

합병(Merge) 정렬

n log n

n log n

n log n

n

Yes

 삽입(Insertion) 정렬

n

n^2

n^2

1

Yes

힙(Heap) 정렬

n log n

n log n

n log n

1

No

Intro Sort

n log n

n log n

n log n

log n

No

 선택(Selection) 정렬

n^2

n^2

n^2

1

No

쉘(Shell) 정렬

n log n

gap에 따라 다름

1

No

거품(Bubble) 정렬

n

n^2

n^2

1

Yes


Stable(안정성) : 같은 값에 대해 정렬 시도 후 위치가 바뀌지 않으면 Stable 하다고 하며, 위치가 서로 바뀔 수 있다면 Not Stable 하다고 합니다.



1. 퀵 정렬(Quick Sort) 

- 분할 및 정복 알고리즘으로, 피벗이라는 요소를 사용하여 배열을 분할 합니다.

- 낮은 오버헤드로 다른 O(n log n) 정렬 알고리즘 보다 빠른 성능을 보입니다.

- 최악의 경우 성능이 O(n^2)입니다만, 드문 경우로써 피벗 요소를 잘 선택하여 O(n log n)의 성능을 얻을 수 있습니다.


2. 합병 정렬(Merge Sort)

- 비교 기반 분할 정복 정렬 알고리즘 입니다.

- Python과 Java의 표준 정렬 루틴에 사용되는 Timsort 알고리즘에 사용됩니다.


3. 힙 정렬(Heap Sort) 

- 특별한 유형의 데이터 구조 이진트리를 생성하여 사용합니다.

- 퀵 정렬보다 대부분 다소 느리지만 최악의 경우 O(n log n)이라는 이점이 있습니다. 


4. 삽입 정렬(Insertion Sort) 

- 작은 데이터 셋(data set)에 널리 사용됩니다. 

- 대부분 정렬 된 목록에 비교적 효율적이며, 더 복잡한 알고리즘의 일부로 사용되는 간단한 정렬 알고리즘입니다.


5. Intro Sort

- 하이브리드 정렬 알고리즘으로 퀵 정렬과 힙 정렬을 결합 하여 구현된 알고리즘입니다.

C++ STL(표준 라이브러리)에서 제공합니다.


6. 쉘 정렬(Shell Sort)

- 적은 수의 코드와 합리적으로 빠르며, 임베디드 및 구형 메인 프레임 메모리에 사용됩니다.


7. 거품 정렬(Bubble Sort)

- 구현하기 가장 간단한 알고리즘이지만 O(n^2)으로 정렬 되지 않은 대형 데이터 셋에서 거의 사용되지 않습니다.

- 거의 정렬된 데이터에서 효율적으로 사용됩니다. O(n)




비 비교 정렬 알고리즘 성능


이름

최적(Best)

평균(Average)

최악(Worst)

메모리

안정성(Stable)

버킷(Bucket) 정렬

-

n+k

(n^2) * k

2^k

Yes

 계수(Counting) 정렬

-

n+r

n+r

n+r

Yes

기수(Radix) 정렬

-

n * (k / d)

n * (k / d)

n+(2^d)

Yes



1. 버킷 정렬(Bucket Sort) 

- 배열을 유한 개수의 버킷으로 분할하여 계산하는 분할 정복 정렬 알고리즘입니다.

- 데이터 셋 요소가 모든 버킷에 고르게 분산될 때 가장 최적한 성능을 보입니다.

- 버킷을 할당하기 위한 메모리가 많이 필요합니다.


2. 계수 정렬(Counting Sort)

- 정수 정렬 알고리즘으로 정수 배열(리스트)에 한정적입니다.

- 숫자 크기(r)에 따라 매우 큰 영향을 받을 수 있으며 n에 비해 r이 매우 커지는 경우 비 효율적입니다.


3. 기수 정렬(Radix Sort)

- 자리수 d에 따라 공간 복잡도가 매우 커질 수 있습니다.





이상 정렬 알고리즘에 대해 비교 분석 해 보았습니다.

질문 또는 오타나 잘못된 정보가 있는 경우 댓글로 달아주세요!

공감♡ 버튼을 눌러주시면 더욱 유용하고 좋은 포스팅으로 찾아 뵙겠습니다.



'자료구조, 알고리즘' 카테고리의 다른 글

[BOJ] 8979 올림픽 - 문제 풀이  (1) 2019.03.29
검색 알고리즘 종류  (2) 2018.09.11
자료구조 그래프(Graph)  (1) 2018.09.06
자료구조 힙(Heap)  (0) 2018.09.05
자료구조 이진 탐색 트리(Binary Search Tree)  (0) 2018.09.01
자료구조 트리(Tree)  (0) 2018.08.30
[자료구조] 큐 QUEUE  (0) 2018.08.19
[자료구조] 스택 STACK  (0) 2018.08.19



안녕하세요 열코입니다.

이번시간에는 기본적인 검색(탐색) 알고리즘 종류들에 대해 알아보도록 하겠습니다.


1. 선형 검색 (Linear Search)

- 배열의 가장 좌측부터 시작하여 찾으려는 값과 하나씩 배열의 각 요소와 비교합니다.

- 찾으려는 값을 발견한다면 배열의 해당 인덱스를 반환(return)합니다.

- 찾으려는 값이 없다면 -1을 반환합니다.

- 시간복잡도 O(n)

- 이진 검색 및 해시 테이블과 같은 다른 검색 알고리즘이 훨씬 빠르기 때문에 실제로 거의 사용하지 않습니다.


- 소스코드


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int search(int arr[], int n, int x) { // 매개변수 : 배열이름, 배열의 길이, 찾으려는 값
 
    int i;
 
    for (i = 0; i < n; i++) { // 배열 전체 순차 탐색
 
        if (arr[i] == x) { // 찾는 값 발견
 
            return i; // 해당 위치(인덱스) 반환
 
        }
 
    }
 
    return -1// 찾으려는 값을 발견하지 못하면 -1 반환
 
}
cs



2. 이진 검색 (Binary Search)

- 검색 반경을 반으로 나눠어 반복하는 검색 방법입니다.

- 정렬 된 배열에서 사용 가능합니다.

- 찾으려는 값을 배열의 중간값과 비교하여 그 값이 더 작다면 우측 배열, 크다면 좌측 배열로 이동하여 반복

- 시간 복잡도 O(log 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
int binarySearch(int arr[], int l, int r, int x) { // 매개변수 : 배열이름, 배열 시작 인덱스, 배열 끝 인덱스, 찾으려는 값
 
   if (r >= l) 
 
   { 
 
        int mid = l + (r - l)/2// 중간 값 선택
 
        if (arr[mid] == x) // 비교하여 찾는 값이라면
 
            return mid; // 해당 인덱스 반환
 
 
        if (arr[mid] > x) // 찾으려는 값보다 크다면
 
            return binarySearch(arr, l, mid-1, x); // 좌측 배열 탐색
 
 
        return binarySearch(arr, mid+1, r, x); // 우측 배열 탐색
 
   }
 
   return -1;  // 찾으려는 값이 없다면 -1 반환
 
cs


- C++ STL에서는 이진 검색을 라이브러리로 제공합니다.

- binary_search(시작위치, 끝위치, 찾으려는값) 식으로 사용합니다.

- lower_bound는 찾으려는 값이 여러개 존재할 때 사용합니다. (upper_bound는 큰 인덱스를 반환)

- 배열(또는 리스트) 안에 찾으려는 값이 1개(단일) 존재한다면 해당 값의 인덱스를 반환합니다.

- 배열 안에 찾으려는 값이 2개 이상 존재한다면 해당 값 중 가장 앞쪽(낮은) 인덱스(num of first position)를 반환합니다.

- 배열 안에 찾으려는 값이 없을 경우 찾으려는 값 다음 위치의 인덱스를 반환합니다.

- 자바에서 Array.binarySearch() 또는 Collections.binarySearch()을 라이브러리로 사용할 수 있습니다.

- 만약 자바에서 이진 탐색을 사용하려면 전에 Array.sort() 메소드를 호출하여 배열을 정렬할 필요가 있습니다.




※ 배열 또는 리스트에서 최소값, 최대값 검색

- 정렬된 배열 또는 리스트에서는 양쪽 끝 값이 최소값 또는 최대값입니다.

- Divide and Conquer를 사용하여 O(log 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
int findPeakUtil(int arr[], int low, int high, int n) 
 
 
    int mid = low + (high - low)/2
 
 
    if ((mid == 0 || arr[mid-1<= arr[mid]) && 
 
            (mid == n-1 || arr[mid+1<= arr[mid])) 
 
        return mid; 
 
 
    else if (mid > 0 && arr[mid-1> arr[mid]) 
 
        return findPeakUtil(arr, low, (mid -1), n); 
 
 
 
    else return findPeakUtil(arr, (mid + 1), high, n); 
 
 
 
int findPeak(int arr[], int n) 
 
 
    return findPeakUtil(arr, 0, n-1, n); 
 
cs



이상 ''에 대해 알아보았습니다.

질문 또는 오타나 잘못된 정보가 있는 경우 댓글로 달아주세요!

메인 페이지로 이동하시면 더 많은 자료를 볼 수 있습니다.





'자료구조, 알고리즘' 카테고리의 다른 글

[BOJ] 8979 올림픽 - 문제 풀이  (1) 2019.03.29
정렬 알고리즘 종류  (0) 2018.09.12
자료구조 그래프(Graph)  (1) 2018.09.06
자료구조 힙(Heap)  (0) 2018.09.05
자료구조 이진 탐색 트리(Binary Search Tree)  (0) 2018.09.01
자료구조 트리(Tree)  (0) 2018.08.30
[자료구조] 큐 QUEUE  (0) 2018.08.19
[자료구조] 스택 STACK  (0) 2018.08.19


※  그래프란 비선형(non-linear) 자료구조이며 노드(node)와 엣지(edge)로 구성되어 있습니다.

- 노드는 꼭짓점(vertex)으로 표현됩니다

- 엣지는 두 노드를 연결하는 (line)으로 표현됩니다.


위 그래프를 V(vertex) = {0, 1, 2, 3, 4}와 E(edges) = {01, 12, 23, 34, 04, 14, 13}으로 표현할 수 있습니다.

그래프는 많은 일상 생활의 문제점을 해결하기 위해 사용됩니다. (네트워크의 표현 등) 


그래프의 표현

그래프를 인접 행렬(Adjacency Matrix) 또는 인접 리스트(Adjacency List)로 표현할 수 있습니다.


1. 인접 행렬 

인접행렬은 2차원 배열(v x v)로 표현될 수 있습니다. 엣지가 존재하는 노드의 짝(i, j)의 배열 값을 1로 설정하고, 엣지가 존재하지 않는 노드의 짝(i, j)의 배열 값을 0으로 설정합니다.가중치 그래프(Weighted Graph)에서는 배열 값을 w(가중치)로 설정 할 수 있습니다.


☞ 소스코드(C++)

#include <iostream>


using namespace std;


int main()

{

// 변수 선언

int vertex, **matrix;


// 정점(vetex) 개수 입력

cin >> vertex;


// 인접 행렬 동적할당 (v x v)

matrix = new int*[vertex]; 

for (int i = 0; i < vertex; i++) {

matrix[i] = new int[vertex];

}


// 인접 행렬 초기화

for (int i = 0; i < vertex; i++) {

for (int j = 0; j < vertex; j++) {

matrix[i][j] = 0;

}

}


// 간선(edge) 입력 (-1 입력 시 종료)

while (1) {

int edge1, edge2;

cin >> edge1 >> edge2;


// 종료 조건

if (edge1 == -1 || edge2 == -1)

break;


// matrix 범위 초과

else if (edge1 > vertex || edge2 > vertex)

continue;


// 이미 연결 된 간선인 경우

else if (matrix[edge1][edge2] == 1 && matrix[edge2][edge1] == 1)

continue;


// 인접 행렬에 입력

matrix[edge1][edge2] = 1;

matrix[edge2][edge1] = 1;

}


// 인접행렬 출력

for (int i = 0; i < vertex; i++) {

for (int j = 0; j < vertex; j++) {

cout << matrix[i][j] << " ";

}

cout << "\n";

}

// 메모리 해제

for (int i = 0; i < vertex; i++) {

delete[] matrix[i];

}

delete[] matrix;


// 프로그램 종료

return 0;

}


2. 인접 리스트

각 꼭짓점(vertex)의 리스트는 헤더(Header)노드를 가집니다. 각 헤더노드들은 배열을 이용하여 연결된 각각의 노드를 순차적으로 가리킵니다.(오름차순)


☞ 소스코드(C++)

#include <stdio.h>

#include <stdlib.h>


// 인접 리스트 구조체 선언

struct AdjListNode

{

    int dest;

    struct AdjListNode* next;

};

 // 인접 리스트 헤더 구조체 선언

struct AdjList

{

    struct AdjListNode *head; 

};

// 그래프 구조체

struct Graph

{

    int V;

    struct AdjList* array;

};

// 새로운 노드 추가

struct AdjListNode* newAdjListNode(int dest)

{

    struct AdjListNode* newNode =

     (struct AdjListNode*) malloc(sizeof(struct AdjListNode));

    newNode->dest = dest;

    newNode->next = NULL;

    return newNode;

}

// 그래프 생성

struct Graph* createGraph(int V)

{

    struct Graph* graph = 

        (struct Graph*) malloc(sizeof(struct Graph));

    graph->V = V;

 

    graph->array = 

      (struct AdjList*) malloc(V * sizeof(struct AdjList));


    int i;

    for (i = 0; i < V; ++i)

        graph->array[i].head = NULL;

 

    return graph;

}

// 엣지 추가

void addEdge(struct Graph* graph, int src, int dest)

{

    struct AdjListNode* newNode = newAdjListNode(dest);

    newNode->next = graph->array[src].head;

    graph->array[src].head = newNode;


    newNode = newAdjListNode(src);

    newNode->next = graph->array[dest].head;

    graph->array[dest].head = newNode;

}

// 그래프 출력

void printGraph(struct Graph* graph)

{

    int v;

    for (v = 0; v < graph->V; ++v)

    {

        struct AdjListNode* pCrawl = graph->array[v].head;

        printf("\n Adjacency list of vertex %d\n head ", v);

        while (pCrawl)

        {

            printf("-> %d", pCrawl->dest);

            pCrawl = pCrawl->next;

        }

        printf("\n");

    }

}

int main()

{

    int V = 5;

    struct Graph* graph = createGraph(V);

    addEdge(graph, 0, 1);

    addEdge(graph, 0, 4);

    addEdge(graph, 1, 2);

    addEdge(graph, 1, 3);

    addEdge(graph, 1, 4);

    addEdge(graph, 2, 3);

    addEdge(graph, 3, 4);

 

    printGraph(graph);

    return 0;

}





정보가 유익하셨다면 아래 공감버튼 눌러주시면 감사하겠습니다.

질문사항은 댓글로 달아주시면 성의껏 답변해드리겠습니다.


'자료구조, 알고리즘' 카테고리의 다른 글

[BOJ] 8979 올림픽 - 문제 풀이  (1) 2019.03.29
정렬 알고리즘 종류  (0) 2018.09.12
검색 알고리즘 종류  (2) 2018.09.11
자료구조 힙(Heap)  (0) 2018.09.05
자료구조 이진 탐색 트리(Binary Search Tree)  (0) 2018.09.01
자료구조 트리(Tree)  (0) 2018.08.30
[자료구조] 큐 QUEUE  (0) 2018.08.19
[자료구조] 스택 STACK  (0) 2018.08.19



이진 힙


이진 힙은 다음 특징(Properties)을 가진 이진 트리입니다.

1. 완전 트리(Complete Tree)이며 배열(Array)안에 저장되기 적합(Suitable)합니다.

2. 이진 힙은 최소(Min) 힙 또는 최대(Max) 힙 중 하나입니다. 최소 힙에서 루트 노드의 값은 모든 노드의 값중 가장 작은 값이며, 최대 힙에서 루트 노드의 값은 모든 노드의 값중 가장 큰 값입니다.


이진 힙의 표현

이진 힙은 완전 이진 트리(Complete Binary Tree)입니다. 이진 힙은 일반적으로(typically) 배열로 표현 됩니다.


루드 노드는 Arr[0] - 배열의 첫번째 요소가 됩니다.

부모 노드의 표현 - Arr[(i-1)/2] 

좌측 자식 노드의 표현 - Arr[(2*i)+1]

우측 자식 노드의 표현 - Arr[(2*i)+2]


이진 힙 배열의 순회 순서는 너비(Level) 순서입니다.


힙의 활용

1. 힙 정렬(Heap Sort) : 힙 정렬은 O(nLog n) 시간 복잡도를 가지는 배열의 정렬 방법입니다.

2. 우선순위 큐(Priority Queue) : 우선순위 큐는 O(log n)의 시간 복잡도를 가지는(삽입, 삭제 등)  이진 힙을 효율적으로 사용할 수 있습니다.

3. 그래프 알고리즘(Graph Algorithm) : 그래프 알고리즘에 우선순위 큐를 효과적으로 사용 할 수 있습니다.


최소 힙의 구현 - 소스코드(C++)

class MinHeap
{
    int *harr; // 힙 요소 포인터
    int capacity; // 최소 힙의 최대 크기
    int heap_size; // 최소 힙의 현재 크기
public:
    MinHeap(int capacity); // 생성자
 
    void MinHeapify(int);
    int extractMin(); 

    int parent(int i) { return (i-1)/2; } // 부모 노드 반환
    int left(int i) { return (2*i + 1); } // 좌측 자식 노드 반환
    int right(int i) { return (2*i + 2); } // 우측 자식 노드 반환
 
    void decreaseKey(int i, int new_val); 
 
    int getMin() { return harr[0]; } // 가장 작은 값(루트 노드) 반환
 
    void deleteKey(int i);
    void insertKey(int k);
};
 
MinHeap::MinHeap(int cap) // 생성자
{
    heap_size = 0;
    capacity = cap;
    harr = new int[cap];
}
 
void MinHeap::insertKey(int k) // 노드 추가
{
    if (heap_size == capacity)
    {
        cout << "\nOverflow: Could not insertKey\n";
        return;
    }
 
    heap_size++; // 사이즈 증가
    int i = heap_size - 1; 
    harr[i] = k;
 
    while (i != 0 && harr[parent(i)] > harr[i]) // 자신의 위치를 검색
    {
       swap(&harr[i], &harr[parent(i)]);
       i = parent(i);
    }
}
 
void MinHeap::decreaseKey(int i, int new_val)
{
    harr[i] = new_val;
    while (i != 0 && harr[parent(i)] > harr[i])
    {
       swap(&harr[i], &harr[parent(i)]);
       i = parent(i);
    }
}
 
int MinHeap::extractMin()
{
    if (heap_size <= 0)
        return INT_MAX;
    if (heap_size == 1)
    {
        heap_size--;
        return harr[0];
    }
 
    int root = harr[0];
    harr[0] = harr[heap_size-1];
    heap_size--;
    MinHeapify(0);
 
    return root;
}
 
void MinHeap::deleteKey(int i)
{
    decreaseKey(i, INT_MIN);
    extractMin();
}
 
void MinHeap::MinHeapify(int i)
{
    int l = left(i);
    int r = right(i);
    int smallest = i;
    if (l < heap_size && harr[l] < harr[i])
        smallest = l;
    if (r < heap_size && harr[r] < harr[smallest])
        smallest = r;
    if (smallest != i)
    {
        swap(&harr[i], &harr[smallest]);
        MinHeapify(smallest);
    }
}





정보가 유익하셨다면 아래 공감버튼 눌러주시면 감사하겠습니다.

질문사항은 댓글로 달아주시면 성의껏 답변해드리겠습니다.


'자료구조, 알고리즘' 카테고리의 다른 글

[BOJ] 8979 올림픽 - 문제 풀이  (1) 2019.03.29
정렬 알고리즘 종류  (0) 2018.09.12
검색 알고리즘 종류  (2) 2018.09.11
자료구조 그래프(Graph)  (1) 2018.09.06
자료구조 이진 탐색 트리(Binary Search Tree)  (0) 2018.09.01
자료구조 트리(Tree)  (0) 2018.08.30
[자료구조] 큐 QUEUE  (0) 2018.08.19
[자료구조] 스택 STACK  (0) 2018.08.19

to Top