배움 저장소

[Data Structures] 챕터12. 그래프

시옷지읏 — Sat, 23 Dec 2023 15:29:05 +0900

트리와 달리 그래프는 한 정점(Vertex)가 여러 다른 정점을 가리킬 수 있다
그래프는 두 정점이 서로를 가르킬 수 있다
연결된 상태를 간선(Edge)으로 표시한다

인접 행렬(Adjacent Matrix Graph)

인접행렬은 정점간 연결관계를 행렬로 표시한다
2차원 배열을 사용하여 정점의 연결 관계를 나타낸다. X행의 X 정점과 다른 정점과 연결 여부를 표시한다
인접 행렬로 그래프 그리기 https://graphonline.ru/en/create_graph_by_matrix

visited_ 값은 traversal을 확인할 때 사용한다.

깊이 우선 탐색(Depth First Search)

방문한 정점을 깊이 파고든다
스택을 활용한다

너비 우선 탐색(Breadth First Search)

중심이 되는 정점과 연결되어있는 정점을 모두 방문한 뒤 다음 레벨로 파고든다
큐를 활용한다

구현하기

InsertEdge

void InsertEdge(int u, int v) // 여기서 u, v는 인덱스
{
    assert(u < n_ && v < n_);

    matrix_[u][v] = 1;
}

DepthFirstTraversal

void DepthFirstTraversal(int v) // v는 인덱스
{
    if (visited_[v]) return;

    visited_[v] = true;

    cout << vertices_[v].item << " ";

    for (int c = 0; c < n_; ++c)
        if (matrix_[v][c])
            DepthFirstTraversal(c);
}

IterDFS

void IterDFT()
{
    ResetVisited();

    int v = 0;

    Stack<int> s;
    s.Push(v);
    visited_[v] = true;

    while (!s.IsEmpty())
    {
        v = s.Top();
        s.Pop();

        cout << vertices_[v].item << " ";

        for (int c = n_-1; 0<= c; --c)
        {
            if (matrix_[v][c] && !visited_[c])
            {
                visited_[c] = true;
                s.Push(c);
            }
        }

        cout << "Stack :";
        s.Print();
    }
}

BreadthFirstTraversal

void BreadthFirstTraversal()
{
    int v = 0; // 0번에서 시작

    Queue<int> q;

    ResetVisited();

    visited_[v] = true;
    q.Enqueue(v);
    while (!q.IsEmpty())
    {
        v = q.Front();
        q.Dequeue();

        cout << v << " ";

        for (int c = 0; c < n_; ++c)
            if (matrix_[v][c] && !visited_[c])
            {
                visited_[c] = true;
                q.Enqueue(c);
            }

        cout << "Queue: ";
        q.Print();
    }
}

인접리스트(Adjacent List)

InsertEdge

기존의 Node를 뒤로 밀어넣는다

void InsertEdge(int u, int v) // 여기서 u, v는 인덱스
{
    assert(u < n_ && v < n_);

    Node* temp = new Node{ v, list_[u] };
    list_[u] = temp;
}

구현하기

DepthFirstTraversal

void DepthFirstTraversal(int v) // v는 인덱스
{
    if (visited_[v]) return;
    visited_[v] = true;

    cout << vertices_[v].item << " ";

    Node* current = list_[v];
    while (current)
    {
        DepthFirstTraversal(current->vertex);
        current = current->next;
    }
}

IterDFT

void IterDFT()
{
    ResetVisited();

    int v = 0;

    Stack<int> s;
    visited_[v] = true;
    s.Push(v);

    while (!s.IsEmpty())
    {
        v = s.Top();
        s.Pop();
        cout << vertices_[v].item << " ";

        Node* linked = list_[v];
        while (linked)
        {
            if (!visited_[linked->vertex])
            {
                visited_[linked->vertex] = true;
                s.Push(linked->vertex);
            }
            linked = linked->next;
        }

        cout << "Stack:";
        s.Print();
        cout << endl;
    }
}

BreathFirstTraversal

void BreadthFirstTraversal()
{
    ResetVisited();

    int v = 0;

    Queue<int> q;
    visited_[v] = true;
    q.Enqueue(v);

    while (!q.IsEmpty())
    {
        v = q.Front();
        q.Dequeue();

        cout << vertices_[v].item << " ";

        Node* linked = list_[v];
        while (linked)
        {
            if (!visited_[linked->vertex])
            {
                visited_[linked->vertex] = true;
                q.Enqueue(linked->vertex);
            }
            linked = linked->next;
        }

        cout << "Queue: ";
        q.Print();
        cout << endl;
    }
}

[Data Structures] 챕터11. 해슁(Hashing)

시옷지읏 — Fri, 22 Dec 2023 22:38:41 +0900

보간탐색

인덱스와 값의 크기는 비례하다고 가정
작은 값은 작은 인덱스부터 탐색한다. 큰 값은 큰 인덱스부터 탐색한다

첫 값부터 마지막 값 사이의 길이 : 첫 값부터 x값까지 길이 = 인덱스 길이 : Position 길이

(arr[high] - arr[low]) : (x - arr[low]) = (high - low) : (pos - low)

이 때 버림을 활용하여 index 값이

int InterpolationSearch(int arr[], int low, int high, int x)
{
    rec_count++;

    if (low <= high && x >= arr[low] && x <= arr[high])
    {
        int pos = (low + high) / 2; // 이진 탐색 (중간)

        // (arr[high] - arr[low]) : (x - arr[low]) = (high - low) : (pos - low) 
        float tofloor = (high - low) * (x - arr[low]) / (arr[high] - arr[low]);
        pos = int(tofloor) + low;

        if (arr[pos] == x)
            return pos;

        if (arr[pos] < x)
            return InterpolationSearch(arr, pos + 1, high, x);

        if (arr[pos] > x)
            return InterpolationSearch(arr, low, pos - 1, x);
    }

    return -1;
}

색인 순차 탐색

원 배열을 각 m개로 나누고 나누어진 배열의 첫 값을 인덱스 배열에 등록한다. 인덱스 배열의 개수는 n/m이다.
인덱스 배열을 참고하여 값을 찾으면 인덱스 배열에 있는 n/m개를 순회하고 나누어진 배열의 원소 m개를 탐색한다.
값 8을 찾기 위해 인덱스 요약 표를 보자. 인덱스 0부터 3 사이가 8의 자리이다. 해당 범위만 탐색하면 효율적이다

시간복잡도

시간복잡도 : O( m + n/m )
이 때 이진탐색( https://hoplite.tistory.com/163 )을 활용하면 시간복잡도는 O ( log(m) + n/m )
위는 인덱스 배열의 개수를 n/m이라 가정. 인덱스 배열의 개수를 m이라고 가정하면 위의 식은 변형되어야 한다

구현하기

#include <iostream>

using namespace std;

int SequentialSearch(int arr[], int start, int stop, int x)
{
    for (int i = start; i < stop; i++)
    {
        if (arr[i] == x)
            return i;
    }

    return -1;
}

int main()
{
    int arr[] = { 1, 2, 8, 13, 22, 45, 55, 75, 88 };
    int n = sizeof(arr) / sizeof(arr[0]);

    int keys[] = { 1, 13, 55 };
    int kn = sizeof(keys) / sizeof(keys[0]);

    int indices[] = { 0, 3, 6, n }; // 마지막에 n 하나 더 추가

    /* 풀이 */

    return 0;
}

내풀이

int main()
{
    
    for (int x : {1, 2, 8, 13, 22, 45, 55, 75, 88, 99, -1, 47, 101, 1000, 7, 10, 50, 60 })
    {
        if (x < arr[0] || x > arr[n - 1])
            cout << x << " was not found" << endl;
        else
        {
            int found = -1;
            for (int i = 1; i < kn; ++i)
            {
                if (keys[i - 1] <= x && x < keys[i])
                    found = SequentialSearch(arr,indices[i - 1], indices[i], x);
            }

            if (keys[kn - 1] <= x)
                found = SequentialSearch(arr, indices[kn - 1], n, x);

            if (found != -1)
                cout << x << " was found at " << found << endl;
            else
                cout << x << " was not found" << endl;
        }
    }
    
}

추천풀이

int main()
{
    ...
    for (int x : {1, 2, 8, 13, 22, 45, 55, 75, 88, 99, -1, 47, 101, 1000, 7, 10, 50, 60 })
    {
        if (x < arr[0] || x > arr[n - 1])
            cout << x << " was not found" << endl;
        else
        {
            // 인덱스 테이블에서 검색할 범위 결정
            int kIdx = 0;
            while (kIdx < kn - 1 && keys[kIdx + 1] <= x)
                kIdx++;

            // 색인 표의 범위에 따라서 선형 탐색
            // indices[kIdx] 이상 indices[kIdx+1] 미만에 대해 검색
            // 이때 indices 배열 마지막에 추가로 n을 저장해뒀기 때문에 kIdx+1 사용 가능
            int found = SequentialSearch(arr, indices[kIdx], indices[kIdx + 1], x);
            if (found >= 0)
                cout << x << " was found at " << found << endl;
            else
                cout << x << " was not found" << endl;
        }
    }
    ...
}

해쉬 테이블

key 값과 value 값을 함께 저장한다.
각 값은 key 값을 index로 배열에 저장한다.
key 값의 범위가 아주 넓고 삽입되는 아이템의 개수가 적을 때 모든 경우의 수를 담는 배열을 만드는 건 비효율적이다
이 때 key 값을 정해진 배열 범위로 변환하는 함수를 Hash Function이라 한다 예) 나머지 연산자

충돌 : 빈 공간이 남아있지만 중복된 Hash 값 때문에 예전 값을 잊어버리는 경우 / 덮어쓸 수 없는 경우

팁

size_t = unsigned long long : 부호가 없는 64비트 정수

키값이 비슷하더라도 변환된 해쉬값은 아주 달라지는 것이 일반적이다

예) Hash Calculator Online — String & File Hash Generator (pelock.com)

- "apple"의 md2 해쉬값 8015C9542CAC74759F9F7196394CC25D
- "apple1"의 md2 해쉬값 BC3BFE69BCDC1DD4EA055ADF80D3BAA6 <- "1" 차이로 크게 달라짐

Hash로 저장하기

아래 구현에서 동일한 Hash값이 만들어지는 서로 다른 두 Item이 삽입되면 이전에 저장된 값을 잊어버린다

void Insert(const Item& item)
{
    size_t index = HashFunc(item.key); // 키를 인덱스로 사용
    table_[index] = item;
}

V Get(const K& key)
{
    size_t index = HashFunc(key);
    return table_[index].value;
}

// 정수 -> 해쉬값
size_t HashFunc(const int& key)
{
    return key % capacity_;
}

충돌 처리하기(중복된 Hash 값 처리하기)

1. 개방 주소법(Open Addressing)

개방 주소법은 빈공간을 찾아 값을 저장한다
선형조사법이라고도 한다 (한 칸씩 이동하여 값을 확인)

Insert

void Insert(const Item& item)
{
    size_t index = HashFunc(item.key); // 키를 인덱스로 사용
	
    // int()의 초기값은 0
    while (table_[index].key != 0)
        ++index;

    table_[index] = item;
}

Get

내구현

V Get(const K& key)
{
    size_t index = HashFunc(key);
    while (index < capacity_ && table_[index].key != key)
        ++index;

    return index < capacity_ ? table_[index].value : 0;
}

추천구현

(index + i) % capacity에서 i 값이 0부터 capacity -1까지 순회함을 확인하자
index 값 temp는 처음 얻은 HashFunc 값에서 바로 직전 값까지 한바퀴를 순회한다

V Get(const K& key)
{
    size_t index = HashFunc(key);
    for (int i = 0; i < capacity_; i++)
    {
        size_t temp = (index + i) % capacity_; // index를 덮어쓰는 것이 아니라 임시 변수 만들기 
        if (table_[temp].key == key)
            return table_[temp].value;
    }
    return 0; // 정수 int()의 초기값은 0
}

숫자가 아닌 자료형을 Key 값으로 사용하기(String)

HashFunc

// 문자열을 정수 인덱스(해쉬값)로 변환
// Horner's method
size_t HashFunc(const string& s)
{
    int g = 31;

    size_t index = 0;
    for (int i = 0; i < s.size(); ++i)
        //index += int(s.at(i)); // 1) AB와 BA가 같은 Hash 값을 가진다
        index = g * index + int(s.at(i)); 
        // 2) g * (g * int('A') + int('B')) + int('C')
        // 따라서 AB와 BA가 달라진다.

    return index % capacity_;
}

Insert

key값을 K의 기본 생성자와 비교하여 비어있는 값을 확인한다. K가 문자열일 때 K()는 비어있는 문자열이다.

void Insert(const Item& item)
{
    size_t index = HashFunc(item.key); // 키를 인덱스로 사용

    if (table_[index].key != K())
        cout << "Collision!" << endl;

    // key가 int 자료형일 때 0이면 비어있는 것으로 가정
    // key가 문자열 자료형일 때 길이가 0이면 비어있는 것으로 가정
    //while (table_[index].key != K()) 
    //    index = (index + i) % capacity_; // infinite loop
    //table_[index % capacity_] = item;

    for (int i = 0; i < capacity_; ++i)
    {
        index = (index + i) % capacity_;
        if (table_[index].key == K())
        {
            table_[index] = item;
            return;
        }
    }

    std::cout << "Failed to insert\n"
}

Get

내구현

V Get(const K& key)
{
    size_t index = HashFunc(key);
    while (index < capacity_ && table_[index].key != key)
        ++index;

    return index < capacity_ ? table_[index].value : V(); // 빈 생성자를 호출하여 반환
}

추천구현

V Get(const K& key)
{
    size_t index = HashFunc(key);
    for (int i = 0; i < capacity_; i++)
    {
        size_t temp = (index + i) % capacity; 
        if (table_[temp].key == key)
            return table_[temp].value;
    }
    return V();
}

2. Chainning

연결리스트를 사용한다.
위에서 구현한 Item* table_ 대신에 LinkedList<Item>* table_을 사용하자

다양한 해쉬함수

폴딩 함수

큰 숫자를 해쉬값으로 변환할 때 자리수에 따라 접을 수도 있습니다

123456789를 123 + 456 + 789 로 3자리씩 더한다

Quadratic probing(이차 조사법)

선형 조사법은 충돌이 많은 경우 배열 일부에 몰려 저장된다. 이를 해결하기위해 Quadratic Probing 를 사용할 수 있다

size_t temp = (index + i*i) % capacity;

참고 https://www.codingeek.com/data-structure/complete-guide-open-addressing-classification-eliminate-collisions/

[Data Structures] 챕터10. 정렬

시옷지읏 — Fri, 22 Dec 2023 14:20:45 +0900

쉘 정렬

Insertion Sort는 바로 옆 값을 값을 비교하고 정렬한다. Shell Sort는 멀리 있는 값을 비교하고 정렬하여 효율을 얻는다.

성능

Worst : O(n^2)

Average : O(n^1.5)

구현하기

void ShellSort(int arr[], int n)
{
    for (int gap = n / 2; gap > 0; gap /= 2)
    {
        cout << "         ";
        Print(arr, n);

        InsertionSort(arr, n, gap);
    }

    cout << "         ";
    Print(arr, n);
    cout << endl;
}

Insertion Sort

내구현

void InsertionSort(int arr[], int n, int gap) // gap 추가
{
    cout << "gap = " << gap << endl;

    for (int i = gap; i < n; i += 1)
    {
        cout << "Before : ";
        Print(arr, n, i, gap);

        if (arr[i-gap] > arr[i])
            std::swap(arr[i-gap], arr[i]);

        int j;
        for(j=i; 0 <= j-gap ; j-=gap)
            if(arr[j-gap] > arr[j])
                std::swap(arr[j - gap], arr[j]);

        cout << " After : ";
        Print(arr, n, i, gap);
    }
}

추천구현

void InsertionSort(int arr[], int n, int gap) // gap 추가
{
    cout << "gap = " << gap << endl;

    for (int i = gap; i < n; i += 1)
    {
        cout << "Before : ";
        Print(arr, n, i, gap);

        if (arr[i - gap] > arr[i])
            std::swap(arr[i - gap], arr[i]);

        int key = arr[i];
        int j = i;
        for (; (0 <= j - gap) && (key < arr[j-gap]); j -= gap)
            arr[j] = arr[j - gap];
        arr[j] = key;

        cout << " After : ";
        Print(arr, n, i, gap);
    }
}

병합 정렬(Merge Sort)

특징

낱개로 나누어 합치면서 정렬한다
시간복잡도 : O(n * Log n)
공간복잡도 : O(n)
Merge 순서를 유지하는 Stable 정렬이다

정렬된 그룹을 합치므로 Two pointer로 구현할 수 있다(희소다항식에서 활용하였음)

void MergeSort(int arr[], int merged[], int left, int right)
{
    int mid;
    if (left < right)
    {
        mid = (left + right) / 2;

        MergeSort(arr, merged, left, mid);
        MergeSort(arr, merged, mid + 1, right);

        Merge(arr, merged, left, mid, right);
    }
}

int main()
{
    int arr[] = { 38, 27, 43, 3, 9, 82, 10 }; // https://en.wikipedia.org/wiki/Merge_sort
    int n = sizeof(arr) / sizeof(arr[0]);

    int* merged = new int[n]; // 추가 메모리 필요

    Print(arr, 0, n - 1);
    cout << endl;

    MergeSort(arr, merged, 0, n - 1);

    Print(merged, 0, n - 1);
    cout << endl;

    delete[] merged;
}

구현하기

Merge

void Merge(int init[], int merged[], int left, int mid, int right)
{
    int i, j, k, l;
    i = left;
    j = mid + 1;
    k = left;

    cout << "  Left : ";
    Print(init, left, mid);
    cout << " Right : ";
    Print(init, mid + 1, right);

    // 인덱스를 2개 이용해서 정렬하면서 merge
    k = left;
    while (i <= mid && j <= right)
    {
        if (init[i] > init[j])
            merged[k++] = init[j++];
        else // it also handle init[i] == init[j]
            merged[k++] = init[i++];
    }

    // 남은 내용들 복사
    for (; i <= mid; ++i)
        merged[k++] = init[i];

    for (; j <= right; ++j)
        merged[k++] = init[j];

    // merged -> init 복사
    for (l = left; l <= right; l++)
        init[l] = merged[l];

    cout << "Merged : ";
    Print(init, left, right);
    cout << endl;
}

퀵 정렬(Quick Sort)

시간복잡도
- best : O(n*log n)
- worst : O(n^2)
공간복잡도 O(log n)

구현하기

Partition

내구현

무한 Loop에 빠질 수 있다.

int Partition(int arr[], int low, int high, int n)
{
    int pivot = arr[size_t(floorf((high - low) / 2.0f)) + low];

    int i = low;
    int j = high;

    while (true)
    {
        while (arr[i] < pivot) // 1) arr[i] == pivot 그리고
            ++i;

        while (pivot < arr[j]) // 2) arr[j] == pivot일 경우 무한 loop
            --j;

        if (i >= j) break;

        std::swap(arr[i], arr[j]);


        cout << "pivot=" << pivot << ", i=" << i << ", j=" << j << endl;
        cout << "         ";
        Print(arr, low, high, n);
    }

    return (i+j)/2;
}

추천구현

// Hoare partition scheme
int Partition(int arr[], int low, int high, int n)
{
    int pivot = arr[size_t(floorf((high - low) / 2.0f)) + low];
    int i = low - 1;
    int j = high + 1;

    while (true)
    {
        do ++i;
        while (arr[i] < pivot);

        do --j;
        while (pivot < arr[j]);

        if (i >= j) break;

        std::swap(arr[i], arr[j]);


        cout << "pivot=" << pivot << ", i=" << i << ", j=" << j << endl;
        cout << "         ";
        Print(arr, low, high, n);
    }

    return j;
}

기수정렬(Radix Sort)

특징

숫자를 쉽게 정렬할 수 있다. 실수나 문자열을 정렬하기 어렵다.
시간복잡도 : O(n)
공간복잡도 : O(n + w)
- 10진수일 때 w=10, 16진수일 때 w=16
GPU연산에서 많이 사용한다(메모리를 아껴야할 때 Quick Sort처럼 메모리가 필요없는 정렬을 사용한다)

구현하기

#include <iostream>
#include "../shared/Queue.h"

using namespace std;

int main()
{
    int arr[] = { 170, 45, 75, 90, 802, 24, 2, 66 };
    int n = sizeof(arr) / sizeof(arr[0]);

    Print(arr, n);

    Queue<int> queues[10];

    int m = GetMax(arr, n); // 가장 큰 자리수를 찾기 위해서

    for (int exp = 1; m / exp > 0; exp *= 10)
    {
        for (int i = 0; i < n; ++i)
        {
            int rem = (arr[i] / exp) % 10;
            assert(0 <= rem); 
            assert(rem <= 10);
            queues[rem].Enqueue(arr[i]);
        }

        //for (int idx = 0; idx < 10; ++idx)
        //{
        //	cout << "i=" << idx << "\t";
        //	Queue<int> temp = Queue<int>{ queues[idx] };
        //	while (!temp.IsEmpty())
        //	{
        //		cout << temp.Front() << " ";
        //		temp.Dequeue();
        //	}
        //	cout << endl;
        //}

        int count = 0;
        for (int idx = 0; idx < 10; ++idx)
        {
            for(; !queues[idx].IsEmpty(); ++count)
            {
                arr[count] = queues[idx].Front();
                queues[idx].Dequeue();
            }
        }

        Print(arr, n);
    }

    return 0;
}

[Data Structures] 챕터9. 이진탐색트리

시옷지읏 — Thu, 21 Dec 2023 12:00:09 +0900

이진탐색트리

시간복잡도

균형잡힌 트리: O(Log N)

Worst : O(N)

이진 탐색 트리의 한계

완전 이진 트리가 아니므로 비효율적으로 작동할 수 있다
- 역순으로 정렬된 배열 값을 모두 넣을 경우
양 서브트리의 깊이가 비슷할 때 효율적이다

구현하기

IterGet

Item* IterGet(const K& key)
{
    Node* cur = root_;

    while (cur)
    {
        if (cur->left && key < cur->item.key)
            cur = cur->left;
        else if (cur->right && cur->item.key < key)
            cur = cur->right;
        else // handle two case (cur->item == key) & (empty child, No matching)
            return &cur->item;
    }

    return nullptr;  // no matching
}

Insert

상위 스택에서 node의 왼쪽 혹은 오른쪽 값을 할당한다.

Node* Insert(Node* node, const Item& item)
{
    if (!node)
        return new Node{ item, nullptr, nullptr };

    if (item.key < node->item.key)
        node->left = Insert(node->left, item);
    else if (node->item.key < item.key)
        node->right = Insert(node->right, item);
    else // node->item.key == item.key
        node->item = item;

    return node;
}

IterInsert

내구현

void IterInsert(const Item& item)
{
    if (!root_) root_ = new Node{ item, nullptr, nullptr };
    Node* cur = root_;

    while (cur)
    {
        if (cur->item.key < item.key)
        {
            if(!cur->right)
            {
                cur->right = new Node{ item, nullptr, nullptr };
                break;
            }

            cur = cur->right;
        }
        else if (item.key < cur->item.key)
        {
            if (!cur->left)
            {
                cur->left = new Node{ item, nullptr, nullptr };
                break;
            }

            cur = cur->left;
        }
        else
        {
            cur->item = item;
            break;
        }
    }
}

추천구현

포인터 2개를 사용하면 편하게 부모 값을 저장할 수 있다(포인터 하나 만 쓰려면 반복문 조건으로 손자 노드를 확인해야함)

void IterInsert(const Item& item)
{
    if (!root_) root_ = new Node{ item, nullptr, nullptr };

    Node* cur = root_;
    Node* pre = nullptr;

    while (cur)
    {
        pre = cur;
        if (cur->item.key < item.key)
            cur = cur->right;
        else if (item.key < cur->item.key)
            cur = cur->left;
        else
        {
            cur->item = item;
            return;
        }
    }

    cur = new Node{ item, nullptr, nullptr };
    if(item.key < pre->item.key)
        pre->left = cur;
    else if(pre->item.key < item.key)
        pre->right = cur;
    else // it already handled when pre is cur. 
        assert(false); // pre is cur->right or cur->left
}

Remove

내구현

Node* Remove(Node* node, const K& key)
{
    if (!node) return node;

    if (key < node->item.key)
        node->left = Remove(node->left, key);
    else if (key > node->item.key)
        node->right = Remove(node->right, key);
    else
    {
        // case 1. remove node which have two children
         if (node->left && node->right)
        {
            // If right node has a child, take it.
            Node* subCurrent = node->right; // subtree's root
            if (subCurrent->left)
            {
                while (subCurrent->left)
                {
                    if (!subCurrent->left->left)
                        break;

                    subCurrent = subCurrent->left;
                }

                Node* child = subCurrent->left;
                subCurrent->left = nullptr;
                child->left = node->left;
                child->right = node->right;
                delete node;

                return child;
            }
            else // No left, so return current because it is in-order.
            {
                subCurrent->left = node->left;
                delete node;
                return subCurrent;
            }

        }
        // case 2. remove node which had a child (connecting pre and post)
        // case 3. remove node which had no child
        else
        {
             // case 3 just assign nullptr to temp
            Node* temp = node->left ? node->left : node->right;
            delete node;
            return temp;
        }
    }

    return node;
}

추천구현

Node* Remove(Node* node, const K& key)
{
    if (!node) return node;

    if (key < node->item.key)
        node->left = Remove(node->left, key);
    else if (key > node->item.key)
        node->right = Remove(node->right, key);
    else
    {	// when left is nullptr or right is nullptr or both are nullptr
        if (!node->left || !node->right)
        {
            Node* temp = node->left ? node->left : node->right;
            delete node;
            return temp;
        }
        else
        {
            Node* temp = MinKeyLeft(node->right);
            node->item = temp->item; // copy value on target node

            // Remove a duplicates on subtree.
            node->right = Remove(node->right, temp->item.key);
            // "assign value on node->right" handle edge case for
            // removed one is just node->right. it return nullptr
        }
    }

    return node;
}

균형잡힌 탐색트리(AVL Tree / Self-Balancing Binary Search Tree)

Balance의 크기 : 왼쪽 자식이 Root인 SubTree의 레벨과 오른쪽 자식이 Root인 SubTree의 레벨 차이

해당 노드 자식간 Balance의 절대값이 2이상일 때 재배열한다.

성능

AVL 트리는 균형이 맞춰져 있어 삽입, 삭제, 탐색의 평균/최악 시간 복잡도는 O(logN)
높이는 매번 새로 계산하거나, 최적화를 위해 Node에 저장해서 값이 바뀔때만 업데이트 한다.

Reference

가시화 도구

구현방법

이 때 Left Rotation(왼쪽 위로 끌어올림)에서 B가 왼쪽 자식을 가질 수 있다

이 때 Left Rotation 이전에도 A는 오른쪽 자식을 가지므로 연결관계를 변경해주어 처리하자

Right Rotation(오른쪽 위로 끌어올림)도 위와 같이 처리할 수 있다.

Balance

왼쪽 자식의 높이가 높으면 양수, 오른쪽 사직의 높이가 높으면 음수이다
자식 Subtree의 높이를 측정한다

int Balance(Node* node)
{
    if (node)
        return Base::Height(node->left) - Base::Height(node->right);
    else
        return 0;
}

구현하기

Insert

Node* Insert(Node* node, const Item& item)
{
    if (!node)
        return new Node{ item, nullptr, nullptr };

    const auto& key = item.key;

    if (key < node->item.key)
        node->left = Insert(node->left, item);
    else if (key > node->item.key)
        node->right = Insert(node->right, item);
    else
    {
        node->item = item;
        return node;
    }

    // It works recursivly, So below executed after inserting node on child

    // It subtract btw child's height
    int balance = Balance(node);

    // Ref : https://www.geeksforgeeks.org/introduction-to-avl-tree/
    // balance가 0, 1, -1 이면 조절할 필요가 없다고 판단
    // LL -> Right Rotation
    if (balance > 1 && Balance(node->left) >= 0) // node->left->left must exist
        node = RotateRight(node);                // because blance > 1
    // Even if Balance(node->left) == 0 do this because left-left

    // RR -> Left Rotation
    else if (balance < -1 && Balance(node->right) <= 0) // node->right->right must exist
        node = RotateLeft(node);				   // because blance > 1

    // LR -> Left-Right Rotation
    else if (balance > 1 && Balance(node->left) < 0)
    {
        node->left = RotateLeft(node->left);
        node = RotateRight(node);
    }

    // RL -> Right-Left Rotation
    else if (balance < -1 && Balance(node->right) > 0)
    {
        node->right = RotateRight(node->right);
        node = RotateLeft(node);
    }

    return node;
}

Remove

위 Insert 로직을 그대로 가져왔다

Node* Remove(Node* node, const K& key)
{
    // BST와 동일
    if (!node) return node;

    if (key < node->item.key)
        node->left = Remove(node->left, key);
    else if (key > node->item.key)
        node->right = Remove(node->right, key);
    else
    {
        if (!node->left)
        {
            Node* temp = node->right;
            delete node;
            return temp;
        }
        else if (!node->right)
        {
            Node* temp = node->left;
            delete node;
            return temp;
        }

        Node* temp = MinKeyNode(node->right);
        node->item = temp->item;
        node->right = Remove(node->right, temp->item.key);
    }

    if (node == NULL)
        return node;

    // 균형 잡기
    int balance = Balance(node);
    if (balance > 1 && Balance(node->left) >= 0)
        node = RotateRight(node);
    else if (balance < -1 && Balance(node->right) <= 0)
        node = RotateLeft(node);
    else if (balance > 1 && Balance(node->left) < 0)
    {
        node->left = RotateLeft(node->left);
        node = RotateRight(node);
    }
    else if (balance < -1 && Balance(node->right) > 0)
    {
        node->right = RotateRight(node->right);
        node = RotateLeft(node);
    }
    return node;
}

영어사전 만들기

구현하기

MyString

#pragma once

#include <iostream>
#include <algorithm> // swap
#include <cassert>
#include <ostream>

class MyString
{
public:
	...
    bool Validate()
    {
        for (int i = 0; i < size_; i++)
        {
            if ('a' <= str_[i] && str_[i] <= 'z'){}
            else return false;
        }
        return true;
    }

    friend std::ostream& operator << (std::ostream & os, const MyString &Str)
    {
        for (int i = 0; i < Str.size_; i++)
            std::cout << Str.str_[i];

        return os;
    }

    friend bool operator > (const MyString& a, const MyString& b)
    {
        for (int i = 0; i < std::min(a.Length(), b.Length()); ++i)
            if (a.str_[i] != b.str_[i])
                return a.str_[i] > b.str_[i];

        return a.Length() > b.Length();
    }

    friend bool operator < (const MyString& a, const MyString& b)
    {
        for (int i = 0; i < std::min(a.Length(), b.Length()); ++i)
            if (a.str_[i] != b.str_[i])
                return a.str_[i] < b.str_[i];

        return a.Length() < b.Length();
    }

    friend bool operator <= (const MyString& a, const MyString& b)
    {
        for (int i = 0; i < std::min(a.Length(), b.Length()); ++i)
            if (a.str_[i] != b.str_[i])
                return a.str_[i] <= b.str_[i];

        return a.Length() <= b.Length();
    }

    friend bool operator >= (const MyString& a, const MyString& b)
    {
        for (int i = 0; i < std::min(a.Length(), b.Length()); ++i)
            if (a.str_[i] != b.str_[i])
                return a.str_[i] >= b.str_[i];

        return a.Length() >= b.Length();
    }

    friend bool operator == (const MyString& a, const MyString& b)
    {
        if (a.Length() != b.Length())
            return false;

        for (int i = 0; i < a.Length(); ++i)
            if (a.str_[i] != b.str_[i])
                return false;

        return true;
    }
private:
    char* str_ = nullptr; // 마지막에 '\0' 없음
    int size_ = 0; // 글자 수
};

main.cpp

#include <iostream>
#include <fstream>
#include <string>
#include "MyString.h"
#include "../shared/AVL.h"

using namespace std;

using Item = AVL<MyString, MyString>::Item;

void TestComparison()
{
    MyString A = MyString("apple");
    MyString B = MyString("board");
    MyString C = MyString("cancel");

    cout << boolalpha;
    cout << (A > B)  << endl;
    cout << (A < B)  << endl;
    cout << (A >= B) << endl;
    cout << (A <= B) << endl;
    cout << (A == B) << endl;
}

void ReadFileAndRichingDictionary(AVL<MyString, MyString> &bst)
{
    /* Read Files*/
    string temp;

    ifstream myfile("eng_dic.txt");
    if (myfile.is_open())
    {
        while (getline(myfile, temp))
        {
            MyString word{ temp.c_str() };
            getline(myfile, temp);

            MyString meaning{ temp.c_str() };

            if (word.Validate())
            {
                bst.IterInsert(*(new Item{ word, meaning }));
            }
        }
        myfile.close();
    }
    else cout << "Unable to open file";
}

int main() {
    AVL<MyString, MyString> bst;


    // Test
    //{
        //bst.Insert(Item{ MyString{"aaa"}, MyString{" 1"} });
        //bst.Insert(Item{ MyString{"decr"}, MyString{" D"} });

        //bst.Insert(Item{ MyString{"cold"}, MyString{" C"} });

        //bst.Insert(Item{ MyString{"appl"}, MyString{" A"} });
        //bst.Insert(Item{ MyString{"aca"}, MyString{" 3"} });
        //bst.Insert(Item{ MyString{"aba"}, MyString{" 2"} });
        //bst.Print2D();
    //}


    // Remove Bugs
    //{
    //    Item *item1 = new Item{ MyString{"abandonment"}, MyString{" 4"} };
    //    bst.Insert(*item1);
    //    Item* item2 = new Item{ MyString{"abandonment"}, MyString{" D"} };
    //    bst.Insert(*item2);
    //}


    ReadFileAndRichingDictionary(bst);
    cout << "Dictionary Created!" << endl;

    string temp;
    while (std::cin >> temp)
    {
        auto* Found = bst.IterGet(MyString{ temp.c_str()});
        if (Found)
        {
            cout << "key: " << Found->key << endl;
            cout << "\tval: " << Found->value << endl;
        }
        else
            cout << "No result" << endl;
    }

    return 0;
}

[Data Structures] 챕터8. 힙

시옷지읏 — Sat, 16 Dec 2023 22:44:48 +0900

최대 힙(Max Heap)과 Top에서 최대값을 출력한다. 최소 힙(Min Heap) Top에서 최소값을 출력한다.
보관된 값은 정렬되어있지 않다.
트리 개념을 활용하여 배열로 구현한다.
최대값 혹은 최소값을 매 번 꺼낼 때 유리한 자료구조이다.

최대 힙(Max Heap)

1. 구현원리

완전 이진 트리를 항상 유지한다
Root 값은 항상 최대값이다

2. 값 저장하기

따라서 값을 추가할 때 완전 이진 트리를 유지할 수 있는, 왼쪽에서 비어있는 순서대로 값을 대입한다
대입될 노드와 해당 노드의 부모를 비교한다
대입될 노드가 부모보다 크다면 자리를 바꾼다(Root까지 반복진행한다)

항상 자식이 부모보다 작다
Swap이 아닌 Shift를 쓰자(새로 만든 노드는 완전 이진 트리를 만들 수 있는 자리에 넣지 않고 비워두고 비교한다)

두 자식의 값을 비교할 수는 없지만 부모는 자식보다 항상 큰 값을 가지므로 효율적으로 최대 값을 찾을 수 있다.

3. 값 꺼내오기

Root 노드를 꺼낸 뒤, 완전이진트리 기준 최하위 노드를 Root 노드로 가져와 자식과 비교해나간다.
가져온 노드를 왼쪽 자식 오른쪽 자식과 비교하여 큰 값과 대체한다
대체된 위치에서 1.과 2.를 반복한다

구현하기

배열 사용, 0번은 비워 둔다
완전이진트리이므로 1번 index부터 해당 index의 위치를 파악할 수 있다.
부모 노드를 index로 찾을 수 있다(Index / 2 = parent)
자식 노드를 index로 찾을 수 있다(Index*2 = left child, Index*2+1 = right child)
값을 추가할 때 배열의 맨 마지막에 넣어준다.

Push

삽입 성능 : O( LogN )

void Push(const T& item)
{
    if (size_ == capacity_)
        Resize(capacity_ * 2);

    // 삽입: 일단 맨 마지막에 삽입한 후에 부모 노드로 올린다.
    size_ += 1;
    int current = size_; // 마지막에 추가가될 위치 (인덱스) // size_ == last index

    // heap_[0] had a trash value
    while (current != 1 && heap_[current/2] < item) // 부모 위치의 값이 추가하려는 값보다 작다면
    {	
        heap_[current] = heap_[current / 2]; // 부모 위치의 값을 자식 위치로 복사해서 내린다.
        current = current / 2;
    }

    heap_[current] = item; // 최종적으로 결정된 위치에 복사
}

Pop

삭제 성능 : O( LogN )

void Pop()
{
    assert(!IsEmpty());

    using namespace std;
    cout << "Pop()" << endl;

    heap_[1].~T(); // 소멸자 호출 

    // 삭제: 가장 마지막 값을 루트로 옮긴 후에 내려 보낸다.
    T last_item = heap_[size_]; // 마지막 아이템 복사
    size_--;					// 크기 줄이기

    int current = 1;			// 루트 노드에서 시작
    int child = 2;				// current * 2 (루트의 왼쪽 자식 인덱스)
    while (child <= size_) // 자식이 있는지 확인
    {
        if (child < size_) // right child가 존재하는가?
            // left, right 중에서 더 큰 자식의 인덱스를 찾는다. 
            child = heap_[child] < heap_[child+1]? child+1 : child; 

        // 현재(current) 값이 자식 중 큰 값 보다 크면 더이상 적절한 위치를 찾을 필요가 없다. 루프 중단
        if (heap_[child] <= last_item)
            break;

        // 자식 값을 부모 위치로 복사, 
        heap_[current] = heap_[child];

        // 그 자식 위치로 current 인덱스 변경, child 인덱스도 그 다음 자식 위치로 변경
        current = child;
        child = current * 2;
    }

    heap_[current] = last_item;
}

힙정렬

힙의 Push와 Pop을 이용하여 정렬할 수 있다.
이 때 동일한 값이 왼쪽 자식이나 오른쪽 자식에 들어갈 수 있으므로 들어갔을 때의 순서가 보장되않는다. 따라서 Unstable 정렬이다
시간복잡도 : Push/Pop 모두 O(Log N)이므로 N개를 정렬하면 O(N*Log N)이다.
공간복잡도 : 배열을 따로 사용할 때 O(N). 힙 배열 내부에서 정렬할 때 O(1)

공간복잡도 O(1) 구현하기

https://www.geeksforgeeks.org/heap-sort/

힙에서 꺼낸 가장 큰 값을 배열 마지막 index에 위치한다.
마지막 index를 제외한 값으로 1.을 반복한다.

우선순위 큐(Priority Queue)

우선순위 큐는 힙을 사용하여 구현할 수 있다

#include <iostream>

#include "../shared/MaxHeap.h"

using namespace std;

struct Patient
{
    int severity; // <- 중증도, 정렬할 때의 1차적인 키(key)로 사용됨
    int time;	  // <- 도착시간, 정렬할 때의 2차적인 키(key)로 사용됨, 중증도가 같을 때는 먼저 온 순서
    const char* name;

    // 우선순위 관점에서 봤을 때 a >= b 인지를 반환하는 함수
    friend bool operator >= (const Patient& a, const Patient& b)
    {
        if (a.severity == b.severity) // 우선순위가 같을 때는 시간을 기준으로 다시 판단 (선착순)
            return a.time <= b.time;   // 숫자로써 time이 작은 것이 먼저 왔다는 의미니까 최종 우선순위가 더 높다.
        else
            return a.severity > b.severity; // 우선순위가 큰 쪽 기준
    }

    friend bool operator < (const Patient& a, const Patient& b)
    {
        return !(a >= b); // 앞의 ! 주의 (operator >= 활용) 
    }

    friend bool operator <= (const Patient& a, const Patient& b)
    {
        if (a.severity == b.severity) // 우선순위가 같을 때는 시간을 기준으로 다시 판단 (선착순)
            return a.time >= b.time;   // 숫자로써 time이 작은 것이 먼저 왔다는 의미니까 최종 우선순위가 더 높다.
        else
            return a.severity <= b.severity; // 우선순위가 큰 쪽 기준
    }


    friend std::ostream& operator << (std::ostream& os, const Patient& p)
    {
        // TODO: 필요하면 구현
        return os;
    }
};

int main()
{
    // 응급실
    MaxHeap<Patient> h;

    // 우선순위가 더 높은 환자 먼저 치료
    // 더 중증인 경우(severity가 큰 경우) 우선순위가 높다.
    // 증상의 무거운 정도가 동일하다면(severity가 같다면) 먼저 온 환자 먼저 치료(time이 작은 환자 먼저)

    h.Push({ 1, 0, "Ironman" });   // 중증도 1의 Ironman 시간 0에 도착
    h.Push({ 1, 1, "Nick Fury" }); // 중증도 1의 Nick Fury 시간 1에 도착
    h.Push({ 3, 2, "Hulk" });      // 중증도 3의 Hulk 시간 2에 도착

    cout << h.Top().name << endl;  // 중증도가 높은 Hulk 먼저 치료
    h.Pop();

    cout << h.Top().name << endl;  // 중증도가 동일하지만 먼저 도착한 Ironman
    h.Pop();
    h.Push({ 2, 3, "Blue Beetle" });

    cout << h.Top().name << endl;  // 늦게 도착했지만 중증도가 높은 Blue Beetle
    h.Pop();

    cout << h.Top().name << endl;  // 마지막으로 Nick Fury
    h.Pop();

    /* 출력 예시
    Hulk
    Ironman
    Blue Beetle
    Nick Fury
    */

    return 0;
}

Fixed Priority Queue

#include <cassert>
#include <iostream>
#include <iomanip>

class FixedPriorityQueue;

struct Node
{
    int item;
    int idx = -1;
    Node* link = nullptr;
    friend std::ostream& operator << (std::ostream& os, const Node& b)
    {
        os << b.item;
        return os;
    }

    friend bool operator < (const Node& a, const Node& b)
    {
        return a.item < b.item;
    }

    friend bool operator >= (const Node& a, const Node& b)
    {
        return a.item >= b.item;
    }

    friend bool operator > (const Node& a, const Node& b)
    {
        return a.item > b.item;
    }

    friend bool operator <= (const Node& a, const Node& b)
    {
        return a.item <= b.item;
    }
};


class Heap
{
public:
    Heap(int cap = 10)
    {
        assert(cap > 0);

        capacity_ = cap;
        size_ = 0;
        heap_ = new Node*[capacity_ + 1];
    }

    void Resize(int new_capacity)
    {
        Node** new_heap = new Node*[new_capacity];
        memcpy(new_heap, heap_, sizeof(Node) * (size_ + 1));
        if (heap_) delete[] heap_;
        heap_ = new_heap;
        capacity_ = new_capacity;
    }

    Node* Top()
    {
        return heap_[1];
    }

    bool IsEmpty()
    {
        return size_ == 0;
    }

    void Print()
    {
        using namespace std;
        cout << "Index: ";
        for (int i = 1; i <= size_; i++)
            cout << setw(3) << i;
        cout << endl;

        cout << "Value: ";
        for (int i = 1; i <= size_; i++)
            cout << setw(3) << *heap_[i];
        cout << endl;

        cout << "idx:   ";
        for (int i = 1; i <= size_; i++)
            cout << setw(3) << heap_[i]->idx;
        cout << endl;

        cout << "addr: ";
        for (int i = 1; i <= size_; i++)
            cout << setw(18) << heap_[i];
        cout << endl;

        cout << "link: ";
        for (int i = 1; i <= size_; i++)
            cout << setw(18) << heap_[i]->link;
        cout << endl << endl;
    }

    void Push(const Node* item)
    {
        if (this->size_ == this->capacity_)
            Resize(this->capacity_ * 2);

        this->size_ += 1;
    }

    void Pop()
    {
        assert(!this->IsEmpty());

        using namespace std;
        cout << "Pop()" << endl;

        this->heap_[1]->~Node();
        delete this->heap_[1];
    }

protected:
    Node** heap_ = nullptr;
    int size_ = 0;
    int capacity_ = 0;

    friend FixedPriorityQueue;
};


class MaxHeap : public Heap
{
public:
    MaxHeap(int capacity=10) : Heap(capacity){}

    void Push(Node* item)
    {
        Heap::Push(item);

        int current = this->size_;

        // heap_[0] had a trash value
        while (current != 1 && *(this->heap_[current / 2]) < *item)
        {
            this->heap_[current] = this->heap_[current / 2];
            this->heap_[current]->idx = current;
            
            current = current / 2;
        }

        this->heap_[current] = item;
        this->heap_[current]->idx = current;
    }

    void Pop()
    {
        Heap::Pop();

        Node *last_item = this->heap_[this->size_];
        this->size_--;

        int current = 1;
        int child = 2;
        while (child <= this->size_)
        {
            // Dereferencing it to compare!!!! else compare address
            if (child < this->size_ && *(this->heap_[child]) < *(this->heap_[child + 1]))
                child =  child + 1;

            if (*(this->heap_[child]) <= *last_item)
                break;

            this->heap_[current] = this->heap_[child];
            this->heap_[current]->idx = current;

            //cout << "Current = " << current << ", child = " << child << endl;
            //Print();

            current = child;
            child = current * 2;
        }

        this->heap_[current] = last_item;
        this->heap_[current]->idx = current;
    }
};


class MinHeap : public Heap
{
public:
    MinHeap(int capacity=10) : Heap(capacity) {}

    void Push(Node* item)
    {
        Heap::Push(item);

        int current = this->size_;

        // heap_[0] had a trash value
        while (current != 1 && *(this->heap_[current / 2]) > *item) 
        {
            this->heap_[current] = this->heap_[current / 2];
            this->heap_[current]->idx = current;

            current = current / 2;
        }

        this->heap_[current] = item;
        this->heap_[current]->idx = current;
    }

    void Pop()
    {
        Heap::Pop();

        Node* last_item = this->heap_[this->size_];
        this->size_--;

        int current = 1;
        int child = 2;
        while (child <= this->size_)
        {
            // Dereferencing it to compare!!!! else compare address
            if (child < this->size_ && *(this->heap_[child]) > *(this->heap_[child + 1]))
                child = child + 1;
            
            if (*last_item  <= *(this->heap_[child]))
                break;

            this->heap_[current] = this->heap_[child];
            this->heap_[current]->idx = current;

            //cout << "Current = " << current << ", child = " << child << endl;
            //Print();

            current = child;
            child = current * 2;

        }

        this->heap_[current] = last_item;
        this->heap_[current]->idx = current;
    }
};


class FixedPriorityQueue
{
public:
    FixedPriorityQueue(int capacity)
    {
        maxHeap_ = MaxHeap(capacity);
        minHeap_ = MinHeap(capacity);
        size_ = capacity;
    }

    void Push(const int& item)
    {
        using namespace std;

        Node *maxNode = new Node{ item };
        Node *minNode = new Node{ item };
        maxNode->link = minNode;
        minNode->link = maxNode;

        if (maxHeap_.size_ == size_)
        {
            // minHeap_.Top()->link is leaf node at maxHeap
            int current = minHeap_.Top()->link->idx;
            minHeap_.Pop();
            minHeap_.Push(minNode);

            // compare maxNode with parent
            while (current != 1 && *(maxHeap_.heap_[current / 2]) < *maxNode)
            {
                maxHeap_.heap_[current] = maxHeap_.heap_[current / 2];
                maxHeap_.heap_[current]->idx = current;

                current = current / 2;
            }

            maxHeap_.heap_[current] = maxNode;
            maxHeap_.heap_[current]->idx = current;
        }
        else
        {
            minHeap_.Push(minNode);
            maxHeap_.Push(maxNode);
        }
    }

    void Print()
    {
        using namespace std;
        cout << "maxHeap" << endl;
        maxHeap_.Print();

        cout << "minHeap" << endl;
        minHeap_.Print();
    }

public:
    MaxHeap maxHeap_;
    MinHeap minHeap_;
    int size_;
};

[Data Structures] 챕터7. 트리

시옷지읏 — Sat, 16 Dec 2023 15:39:48 +0900

선형 vs 비선형 자료구조(Linear/ Non-Linear)

선형 자료구조

데이터 모두가 연결된 상태로 구현한다(직선으로 표현할 수 있다)
리스트(List), 스택(Stack), 큐(Queue)
위 자료구조를 배열 또는 연결노드로 구현할 수 있다.

비선형 자료구조

데이터 모두가 연결되지 않은 상태이다(직선으로 표현할 수 없다)
트리(Tree), 그래프(Graph)

이진 트리 소개

양방향 연결 리스트와 이진 트리 모두 Left와 Right 노드 포인터를 사용하지만 이진 트리는 자식-부모 관계를 다룬다.

Root Node : 트리의 시작점으로 부모가 없다.
Terminal{Leaf} Node(단말노드): 자식이 없는 노드
Edge : 노드와 노드의 연결을 가리킨다.
Degree(차수) : 자식의 개수
Tree의 차수 : Tree 내에 있는 가장 큰 차수를 가진 노드
Sub Tree : 모든 노드는 어떤 Sub Tree의 Root이다 (구현할 때 중요)

Level : 루트 레벨을 0 또는 1로 본다.
Height(높이) : 최고 레벨
Depth(깊이) :

Full Binary Tree(포화 이진 트리) : 단말 노드 외 모든 노드의 자식이 꽉 차있는 트리
Complete Binary Tree(완전 이진 트리) : 단말 노드가 속한 레벨 외에는 모두 꽉 차있고 해당 단말노드의 반대방향은 모두 포화 상태인 트리

(왼) 완전이진트리O (오) 완전이진트리X

완전이진트리

이진트리 구현

using Node = BinaryTree<int>::Node;

Node* n1 = new Node{ 1, nullptr, nullptr }; // 물결괄호 초기값 나열 (생성자 아님)
Node* n2 = new Node{ 2, n1, nullptr };
Node* n3 = new Node{ 3, nullptr, nullptr };
Node* n4 = new Node{ 4, nullptr, nullptr };
Node* n5 = new Node{ 5, nullptr, n4 };
Node* n6 = new Node{ 6, n2, n5 };

n1->right = n3; // <- 연결관계 변경

/*          6
*         /   \
*        2     5
*       /       \
*      1         4
*       \
*        3
*/

BinaryTree<int> tree(n6); // <- n6의 주소를 root node로

트리 순회(Tree Traversal methods)

PreOrder

현재 노드를 먼저 처리한다.
해당 노드에서 작업을 마친 후 왼쪽 자식>오른쪽 자식 순으로 순회

PostOrder

현재 노드를 나중에 처리한다.
왼쪽 자식>오른쪽 자식으로 순회한 이후 해당 노드에서 작업

InOrder

왼쪽 자식을 순회한 이후 자신을 처리한다
자신을 처리한 이후 오른쪽 자식을 순회한다.

Level Order

높은 레벨부터 처리한다
재귀호출 X

PreOrder, PostOrder, InOrder를 Iterative를 활용하여 구현해보자(Queue와 Stack을 활용)

Template Intellisense 활용하기

구현하기

Sum

내풀이

int Sum(Node* node)
{
    int total = node->item;
    if (node->left)
        total += Sum(node->left);

    if (node->right)
        total += Sum(node->right);

    return total;
}

추천풀이

int Sum(Node* node)
{
    if (!node) return 0;
    return node->item + Sum(node->left) + Sum(node->right);
}

Height

내풀이

int Height(Node* node)
{
    if (node->left || node->right)
    {
        int bigger = 0;
        if (node->left)
            bigger = Height(node->left) + 1;

        if (node->right)
        {
            int right = Height(node->right) + 1;
            bigger = bigger < right ? right : bigger;
        }

        return bigger;
    }

    return 1; // TODO:
}

int Height(Node* node)
{
    if(!node) return 0; // exit condition for recursive call
                        // Because node is null character, return 0
                        // Set -1 if base level is 0
    return std::max(Height(node->left), Height(node->right)) + 1;
}

Level Order

void LevelOrder()
{
    Queue<Node*> q;
    Node* current = root_;
    while (current)
    {
        Visit(current);

        if(current->left) q.Enqueue(current->left);
        if(current->right) q.Enqueue(current->right);
        if (q.IsEmpty()) break;

        current = q.Front();
        q.Dequeue();
    }
}

IterPreOrder

void IterPreorder()
{
    if (!root_) return;

    Stack<Node*> s;
    s.Push(root_);

    while (!s.IsEmpty())
    {
        Node* current = s.Top();
        s.Pop();

        Visit(current);
        if(current->right)
            s.Push(current->right);
        if (current->left)
            s.Push(current->left);
    }
}

IterInOrder

void IterInorder()
{
    if (!root_) return;

    Stack<Node*> s;

    Node* current = root_;
    while (current || !s.IsEmpty())
    {
        while (current) // 1) Creating temporary value is not needed
        {
            s.Push(current);
            current = current->left;
        }

        current = s.Top(); // 2) since a new value is always assigned anyway
        s.Pop();

        Visit(current);
        current = current->right; // assign nullptr if right is empty
    }
}

IterPostOrder

void IterPostorder()
{
    if (!root_) return;

    Stack<Node*> s1, s2;

    s1.Push(root_); // Reversed version of IterPreOrder
    while (!s1.IsEmpty())
    {
        Node* current = s1.Top();
        s1.Pop();
        s2.Push(current);

        // Stack Left first. It save right first at s2
        // So reversed version correctly poping out left first.
        if(current->left) s1.Push(current->left);
        if(current->right) s1.Push(current->right);
    }


    while (!s2.IsEmpty())
    {
        Visit(s2.Top());
        s2.Pop();
    }
}

수식 계산 트리

구현하기

Evaluate

내구현

int Evaluate(Node* node)
{		
    Stack<Node*> s1, s2;
    s1.Push(node);
    while (!s1.IsEmpty())
    {
        Node* current = s1.Top();
        s1.Pop();

        s2.Push(current);

        if(current->left)  s1.Push(current->left);
        if(current->right) s1.Push(current->right);
    }

    Stack<char> save;
    int total = 0;
    while (!s2.IsEmpty())
    {
        char c = s2.Top()->item;
        s2.Pop();

        if ('0' <= c && c <= '9')
            save.Push(c);
        else
        {
            int second = save.Top() - '0';
            save.Pop();

            int first = save.Top() - '0';
            save.Pop();

            if (c == '+') save.Push((first + second) +'0');
            if (c == '-') save.Push((first - second) +'0');
            if (c == '*') save.Push((first * second) +'0');
            if (c == '/') save.Push((first / second) +'0');
        }
    }

    total = save.Top() - '0';
    return total;
}

추천구현

int Evaluate(Node* node)
{
    if (!node) return 0;

    if(node->item == '+') return Evaluate(node->left) + Evaluate(node->right);
    if(node->item == '-') return Evaluate(node->left) - Evaluate(node->right);
    if(node->item == '*') return Evaluate(node->left) * Evaluate(node->right);
    if(node->item == '/') return Evaluate(node->left) / Evaluate(node->right);

    return node->item - '0';
}

Infix

void Infix(Node* node) {
    if (!node) return;

    if(!IsDigit(node->item)) std::cout << "(";
    Infix(node->left);
    std::cout << node->item;
    Infix(node->right);
    if (!IsDigit(node->item)) std::cout << ")";
}

Postfix

void Postfix(Node* node) {
    Stack<Node*> s1, s2;
    s1.Push(node);
    while (!s1.IsEmpty())
    {
        Node* current = s1.Top();
        s1.Pop();

        s2.Push(current);

        if (current->left)  s1.Push(current->left);
        if (current->right) s1.Push(current->right);
    }

    int total = 0;
    while (!s2.IsEmpty())
    {
        Visit(s2.Top());
        s2.Pop();
    }
}

ExpressionTree

ExpressionTree(const char* infix)
{
    // Infix -> Postfix (예제 재사용)
    Queue<char> q;
    for (int i = 0; infix[i] != '\0'; i++)
        q.Enqueue(infix[i]);
    cout << "  Infix: ";
    q.Print();
    Queue<char> postfix;
    InfixToPostfix(q, postfix);
    cout << "Postfix: ";
    postfix.Print();

    // Postfix -> Expression tree
    Stack<Node*> s, chars; // use another stack
    while (!postfix.IsEmpty())
    {
        char c = postfix.Front();
        postfix.Dequeue();

        Node* newNode = new Node{ c };
        if (c >= '0' && c <= '9')
            chars.Push(newNode);
        else
        {
            Node* second = chars.Top();
            chars.Pop();
            Node* first = chars.Top();
            chars.Pop();

            newNode->left = first;
            newNode->right = second;

            chars.Push(newNode);
        }
    }

    assert(chars.Size() == 1);
    root_ = chars.Top();
}

쓰레드

Leaf 노드는 자식이 없다. 이를 활용하여 스택을 사용하지 않고 Iterative In Order를 구현할 수 있다.

Leaf 노드가 다음 노드를 가리키는 링크를 가지고 있을 때 쓰레드(thread)라고 부른다. 이를 구분하기 위한 값을 노드에 추가하였다.

struct Node
{
    T data = T();
    Node* left = nullptr; // Left child
    Node* right = nullptr; // Right child
    int right_thread = 0; // <- right 링크가 쓰레드인지 구분
};

Node* Next(Node* node)
{
    Node* next = node->right;

    if (!next) return nullptr; // 종료
    if (next && node->right_thread) return next; // 오른쪽 링크가 쓰레드라면 바로 반환

    while (next->left) next = next->left; // Inorder 예시라서 가장 마지막 left로 이동

    return next; // (left가 없었다면 right 반환) left가 있었다면 가장 마지막 left 반환
}

void Inorder(Node* node)
{
    while (node->left) node = node->left; // Inorder라서 가장 마지막 left로 이동

    do
    {
        cout << node->data << " "; // Visit
        node = Next(node); // 다음 노드를 찾는다
    } while (node);

    cout << endl;
}

[Data Structures] 챕터6. 연결 리스트

시옷지읏 — Wed, 13 Dec 2023 13:07:24 +0900

Node* current = first_;
while(current->next)
{
	current = current->next;
}

순차 표현 vs 연결 표현

Sequential Representation

장점 : 데이터를 묶음별로 다룰 수 있어 효율적이다.
단점 : 중간에 데이터를 삽입하거나 제거하면, 그 뒤의 데이터를 이동시켜야 한다.

따라서 Sequential Representation은

많은 데이터를 읽어들이는데 유리하다
데이터를 연속적인 데이터 중간에 추가하거나 제거하는데 불리하다

Linked Representation

장점 : 중간에 데이터를 삽입하거나 제거하는 일이 빠르다.
단점 : 다음 Node에 접근하기 위해 이전에 존재하는 모든 Node를 거쳐야하므로 비효율적이다.

데이터를 삽입하거나 삭제할 때 해당 노르를 제거하거나 추가한 뒤 앞뒤 노드와 연결관계를 재설정하면 된다.

참고

CPU에서 메모리로 데이터를 읽어들일 때 메모리 대역폭에 맞춰서 주변 데이터를 블럭 단위로 읽어와서 일단 캐쉬에 넣어둔다. 그 다음에 요청하는 데이터가 캐쉬에 들어 있다면 재빠르게 가져오고 그렇지 않다면 다시 메인 메모리에서 데이터를 또 다시 블럭 단위로 가져옵니다. 그래서 배열 같은 순차적 자료구조에서 순서대로 데이터를 읽어오는 것은 캐쉬 효과 덕분에 아주 빠르다.

연결 노드(Linked List)

데이터 외에 추가로 링크 포인터도 저장(더 많은 메모리가 필요하다).
삽입/삭제가 편리하다는 장점을 살릴 수 없는 경우에는 메모리 낭비가 된다.
아이템 자체의 사이즈가 아주 큰 경우에도 포인터 하나가 추가되는 것 정도는 큰 낭비라고 볼 수 없다.

nullptr == 0?

int* ptr_zero = 0;       // X
int* ptr_null = nullptr; // O

숫자값 0과 비어있는 포인터를 구분하자. 이를 위해 비어있는 포인터를 0으로 사용하는 건 피하자

주소값 얻기

Reference와 Pointer&n.next는 포인터의 주소값을 나타낸다.

struct Node
{
	int item = 0;
	Node* next = nullptr;

	friend ostream& operator<<(ostream& os, const Node& n)
	{
		cout << &n << "주소값" << endl;
		cout << n.next << "포인터(주소 값)" << endl;

		return os;
	}
};

연결노드 삭제

Node* current = first;
while (current)
{
    Node*temp = current->next;
    delete current;

    current = temp;
}

단방향 연결 리스트(Singly Linked List)

Linked List의 속도

값 찾기 : O(n) 모든 값을 순회해야 함.

값 넣기 : O(1) 특정 노드 앞뒤 혹은 전체의 앞뒤에 값을 넣음.

삽입과 삭제의 시간 복잡도가 배열 리스트에서는 O(n)이지만 연결 리스트에서는 O(1)

여러 Linked List

Circular List : 맨 뒤와 앞이 연결된 Linked List.
- 마지막 노드가 맨 앞을 가리키면 된다.
Linked Stack : 연결된 스택
Linked Queue : 연결된 큐

구현하기

Node* current = first_;
while(current->next)
{
	current = current->next;
}

Node* current = first_;
while(current->next && current->next->next)
{
	current = current->next;
}

이 때 current->next와 current->next->next가 nullptr인 두 가지 경우의 예외를 처리해야 한다.

PushFront

void PushFront(T item)
{
    // 새로운 노드 만들기
    Node* newNode = new Node; // O(1)
    newNode->item = item;

    // 연결 관계 정리
    newNode->next = first_;
    first_ = newNode;
}

PushBack

void PushBack(T item)
{
    if (first_)
    {
        Node* current = first_;
        while (current->next)
            current = current->next;

        Node* newNode = new Node;
        newNode->item = item;
        newNode->next = nullptr;

        current->next = newNode;
    }
    else
        PushFront(item);
}

while반복문 조건에 current를 넣을 경우 반복문 종료 이후 current는 nullptr가 된다.
이 때 current에 동적할당 받은 새 주소를 할당받아도 마지막 바로 앞 노드의 next 포인터는 여전히 nullptr를 가리킨다.

Copy Constructor

내 구현

SinglyLinkedList(const SinglyLinkedList& list)
{
    Node* current= list.first_;
    Node* newCurrent = new Node;
    first_ = newCurrent;

    while (current)
    {
        newCurrent->item = current->item;

        if (current->next)
        {
            newCurrent->next = new Node;
            newCurrent = newCurrent->next;
        }

        current = current->next;
    }
}

추천 구현

SinglyLinkedList(const SinglyLinkedList& list)
{
    Node* current = list.first_;

    while (current)
    {
        this->PushBack(current->item); // handle "fisrt_"
        current = current->next;
    }
}

Reverse

참고 : https://www.geeksforgeeks.org/reverse-a-linked-list/

void Reverse()
{
    Node* current = first_;
    Node* previous = nullptr;

    while (current)
    {
        Node* next = current->next;
        current->next = previous;

        previous = current;
        current = next;
    }

    first_ = previous;
}

Find

Node* Find(T item)
{
    Node* current = first_;
    while (current)
    {
        if (current->item == item)
            return current;

        current = current->next;
    }

    return nullptr;
}

InsertBack

void InsertBack(Node* node, T item)
{
    Node* newNode = new Node;
    newNode->item = item;
    newNode->next = node->next;
    node->next = newNode;
}

Remove

첫 값을 삭제하는 경우 예외처리

void Remove(Node* n)
{
    assert(first_);

    if (first_ == n)
    {
        first_ = first_->next;
        delete n;

        return;
    }

    Node* current = first_;
    while (current->next) // check next of current instead of current
    {                     // because it could be nullptr
        if (current->next == n)
        {
            current->next = n->next;
            delete n;

            break;
        }

        current = current->next;
    }
}

PopBack

내구현

void PopBack()
{
    if (IsEmpty())
    {
        using namespace std;
        cout << "Nothing to Pop in PopBack()" << endl;
        return;
    }

    assert(first_);
    Node* previous = nullptr;
    Node* current = first_;

    while (current->next)
    {
        previous = current;
        current = current->next;
    }

    if (previous)
    {
        delete previous->next;
        previous->next = nullptr;
    }
    else {
        delete first_;
        first_ = nullptr;
    }
}

추천구현

void PopBack()
{
    if (IsEmpty())
    {
        using namespace std;
        cout << "Nothing to Pop in PopBack()" << endl;
        return;
    }

    assert(first_);
    Node* current = first_;

    if (current->next)
    {
        while (current->next->next)
            current = current->next;

        delete current->next;
        current->next = nullptr;
    }
    else
    {
        delete first_;
        first_ = nullptr;
    }
}

Clear

void Clear()
{
    Node* current = first_;
    while (current)
    {
        Node* temp = current->next;
        delete current;

        current = temp;
    }

    first_ = nullptr;
}

void Clear()
{
    while (first_)
        PopFront();
}

연결 다항식 실습(희소 다항식 구현하기)

부모 Class에 있는 struct Name불러쓰기

template<typename T>
class SinglyLinkedList
{
public:
    struct Node
    {
        T item = T();
        Node* next = nullptr;
    };
	...
};

class LinkedPolynomial : public SinglyLinkedList<Term>
{
public:
	typedef SinglyLinkedList<Term>::Node Node;
}

구현하기

NewTerm

void NewTerm(float coef, int exp)
{
    if (first_ == nullptr)
    {
        first_ = new Node;
        first_->next = nullptr;
        first_->item = Term{ coef, exp };
        return;
    }

    Node* current = first_;
    Node* previous = nullptr;
    while (current)
    {
        if (exp == current->item.exp)
        {
            current->item.coef += coef;
            return;
        }
        else if (exp < current->item.exp)
        {
            Node* newNode = new Node;
            newNode->item = Term{ coef, exp };
            if (previous)
            {
                Node* temp = previous->next;
                previous->next = newNode;
                newNode->next = temp;
            }
            else
            {
                newNode->next = first_;
                first_ = newNode;
            }
            return;
        }

        previous = current;
        current = current->next;
    }

    Node* newNode = new Node;
    newNode->item = Term{ coef, exp };
    previous->next = newNode;
    newNode->next = current;
}

Eval

float Eval(float x)
{
    float temp = 0.0f;

    Node* current = first_;
    while (current)
    {
        temp += current->item.coef* powf(x, (float)current->item.exp);
        current = current->next;
    }

    return temp;
}

Add

LinkedPolynomial Add(const LinkedPolynomial& poly)
{
    LinkedPolynomial temp;

    Node* i = this->first_;
    Node* j = poly.first_;

    while (i && j)
    {
        if (i->item.exp < j->item.exp)
        {
            temp.NewTerm(i->item.coef, i->item.exp);
            i = i->next;
        }
        else if (i->item.exp > j->item.exp)
        {
            temp.NewTerm(j->item.coef, j->item.exp);
            j = j->next;
        }
        else 
        {
            float sum = i->item.coef + j->item.coef;
            if(sum)
                temp.NewTerm(sum, i->item.exp);

            i = i->next;
            j = j->next;
        }
    }

    for(;i;i=i->next)
        temp.NewTerm(i->item.coef, i->item.exp);

    for(;j;j=j->next)
        temp.NewTerm(j->item.coef, j->item.exp);

    return temp;
}

Print

void Print()
{
    bool is_first = true;

    Node* current = first_;
    while (current)
    {
        if (!is_first) cout << " + ";
        else is_first = false;

        cout << current->item.coef << "x^" << current->item.exp;
        current = current->next;
    }

    cout << endl;
}

양방향 연결리스트(Doubly Linked List)

코팅 팁

while 반복문으로 Link의 마지막 노드를 가리키기.

Node* current = first_;

if (current->right)
{
    while (current->right)
    {
        cout << current->item << " ";
        current = current->right;
    }
    cout << current->item;
}
else { // single node
    cout << current->item << " ";
}

while 조건문을 code block 내부로 이동한다.

while (true)
{
    cout << current->item << " ";
    if (!current->right)
        break;

    current = current->right;
}

구현하기

void Reverse()
{
    Node* current = first_;

    while (current)
    {
        Node* temp = current->right; // what if current->right is nullptr?
        current->right = current->left; // you assign a value on nullptr?
        current->left = temp;
        first_ = current;	// Trick for Simplifing Code 

        current = temp;
    }
}

[Data Structures] 챕터5. 큐(Queue)

시옷지읏 — Thu, 30 Nov 2023 18:04:33 +0900

원형 큐

FIFO(First in First Out)

원형 큐에서 두 개의 index를 활용하여 비어있을 경우, 1개 있을 경우, 2개 있을경우, ..., 꽉 차있을 경우를 표현해야 한다.

모든 경우를 각각 유일하게 표현할 수 있도록 index를 사용하는 방법은 무엇인가?

front는 시작 index보다 1 작은 값을 가진다.
rear는 가장 마지막에 추가된 index이다.
front == rear일 때 원형 큐는 비어있다.

위 규칙을 적용하고 capacity -1 개의 저장공간만 사용한다(front가 가리키는 곳은 항상 비어있다)

원형 큐의 구현 원리

front와 rear 모두 0 index에서 시작한다.
값을 추가하면 rear를 증가시켜 해당 index에 값을 할당한다

값을 뺄 때 front 값을 증가시키고 해당 index에 있는 값을 지운다.
rear 값이 capacity를 넘어가면 0에서 시작한다. rear = (rear + 1) % capacity

이 때 rear와 front가 같아지면 empty와 구분할 수 없으므로 capacity = capacity -1이 된다.

index 1은 비워야 한다

구현

int Size() const
{    
    // front_ == rear_ 일 때 Size = 0
    if (front_ <= rear_)
        return rear_ - front_;

    // front ~ (capacity-1)의 개수 +  0 ~ rear의 개수
    // (capacity - front -1)      +    (rear_ + 1)
    return capacity_ - front_ + rear_;

    //            비어있는 공간 개수
    // capacity  -  (front - rear)
}

ReSize

반복문 사용

내구현(if-else로 나누어 처리)

void Resize() // 2배씩 증가
{
    T* NewQueue= new T[capacity_ * 2];
    
    if (front_ > rear_)
    {
        for (int i = front_+1; i < capacity_; ++i)
            NewQueue[i - front_] = queue_[i]; // start idx is 1 not 0

        for (int i = 0;i <= rear_; ++i)
            NewQueue[capacity_ - front_ + i] = queue_[i]; // capacity_ - front_ = new start idx position
        // 예제 활용하기 front_=4, capacity=6
        // idx 4는 비어있고 idx 5는 값을 가지며 6-4 = 2이다
        // 이를 0으로 shift하면 idx 2(capacity - front)부터 채우면 된다.

        front_ = 0;
        rear_ = capacity_-1;
    }
    else
    {
        for (int i = 0; i < capacity_; ++i)
            NewQueue[i] = queue_[i];
    }
    
    delete[] queue_;
    queue_ = NewQueue;
    capacity_ *= 2;
}

추천구현(% 연산자를 활용)

void Resize()
{
    T* NewQueue= new T[capacity_ * 2];
    
    int count = 1; // start idx is 1
    for (int i = (front_ + 1) % capacity_; i != (rear_ + 1) % capacity_; i= (i+1) % capacity_)
    {
        NewQueue[count] = queue_[i]; 
        count++;
    }

    front_ = 0;
    rear_ = capacity_-1;
    delete[] queue_;
    queue_ = NewQueue;
    capacity_ *= 2;
}

memcpy 사용

내구현

void Resize() // 2배씩 증가
{
    T* NewQueue= new T[capacity_ * 2];
    
    if (front_ > rear_)
    {
        // 비어있는 front_ index부터 마지막 index까지 
        memcpy(NewQueue, &queue_[front_], (capacity_ - front_) * sizeof(T)); // T의 크기로 할당

        // 위에서 (capacity_ - front_)개수 만큼 채웠으므로 
        // (capacity_ - front_ -1) index까지 값이 할당됨. (capacity_ - front_)에서 시작.
        memcpy(&NewQueue[capacity_ - front_], queue_, (rear_+1)* sizeof(T)); // T의 크기로 할당

        front_ = 0;
        rear_ = capacity_-1; // 마지막 index를 가리킴
    }
    else
        memcpy(NewQueue, queue_, capacity_ * sizeof(T));

    front_ = 0;
    rear_ = capacity_-1;
    delete[] queue_;
    queue_ = NewQueue;
    capacity_ *= 2;
}

처음에 한 칸을 띄우지 않는 구현 방식(front가 마지막 index)

강의 21:48

Deque

void Dequeue() // 큐의 첫 요소 삭제, Pop()
{
    assert(!IsEmpty());

    front_ = (front_ + 1) % capacity_;
    //queue_[front_].~T(); // 자료형이 동적할당 메모리를 가질 경우
}

조세푸스 문제

덱(Deque)

Deque(Double Ended Queue) 덱
양쪽을 모두 사용할 수 있다(queue의 기능을 확장)
- PushFront / PushBack, PopFront / PopBack
dequeue와 deque는 다르다

위에서 구현한 Queue를 상속하면 PushBack == Enqueue, PopFront == Dequeue이므로 이미 구현되었다.

PushFront와 PopBack만 구현하면 된다.

구현

template<typename T>
class Deque : public Queue<T> // Deque가 사용하는 자료형 T와 동일한
{                             // 자료형을 사용하는 Queue를 상속
    typedef Queue<T> Base; // Queue<T> == Base (짧게 쓰기)
private:
    int& rear_ = Base::rear_;
    int& front_ = Base::front_;
    int& capacity_ =  Base::capacity_;
    T*& queue_ = Base::queue_;
};

참고 1) 위와 같이 부모 멤버 변수의 새 이름을 만들어 호출할 수 있다.

참고 2) 부모 클래스가 템플릿(template) 클래스일 경우 부모 클래스의 멤버를 아래와 같이 호출할 수 있다.

this->부모 멤버 (자신의 멤버와 부모의 멤버가 헷갈릴 수 있다)
Base::멤버
Queue<T>::멤버

PushFront

이 때 front_는 값을 가지지 않는 index이므로 해당 index에 값을 할당하고 이동시킨다.

void PushFront(const T& item)
{
    if (Base::IsFull())
        Base::Resize();

    Base::queue_[Base::front_] = item;
    Base::front_ = (Base::front_ + Base::capacity_ - 1) % Base::capacity_;
}

PopBack

void PopBack()
{
    assert(!Base::IsEmpty());

    Base::rear_ = (Base::rear_ + Base::capacity_ - 1) % Base::capacity_;
}

수식 계산

infix : 숫자 사이에 연산자를 적는다(사람이 이해하기 편함)

A/B-C+D*E-A*C

 8 / 2 - 3 + 4 * 5 - 1 * 2 = 19

postfix : 계산 순서에 따라 숫자와 연산자를 나열한다(컴퓨터가 계산하기 편함)

AB/C-DE*+AC*-

8 2 / 3 - 4 5 * + 1 2 * - // 연산자를 만날때까지 진행
= 4 3 - 4 5 * + 1 2 * -
= 1 4 5 * + 1 2 * -
= 1 20 + 1 2 * -
= 21 1 2 * -
= 21 2 -
= 19

구현목표

infix를 posfix로 변환 (InfixToPostfix)
posfix를 계산 (EvalPostfix)

Queue는 문자열 데이터를 저장하는 용도로 쓴다. 알고리즘(로직)은 Stack을 활용한다.

Stack을 사용하는 이유 : 우선순위가 높은 연산자를 먼저 계산하기 위함

stack에 담겨있는 연산자와 새로운 연산자를 비교하여 우선순위가 높은 연산자를 먼저 계산한다

구현

// Function to return precedence of operators
// * is higher than - and +
int Prec(char c)
{
    if (c == '/' || c == '*')
        return 2;
    else if (c == '+' || c == '-')
        return 1;
    else
        return -1; // '('는 우선순위가 아주 낮은 것으로 처리, ')' 닫는 괄호를 만날때까지 남겨두기 위함
}

void InfixToPostfix(Queue<char>& q, Queue<char>& output)
{
    Stack<char> s; // 우선순위가 낮은 연산을 보류하기 위한 스택

    output.SetDebugFlag(false);

    while (!q.IsEmpty())
    {
        char c = q.Front();
        q.Dequeue();

        cout << c << endl;

        if (c >= '0' && c <= '9') // 숫자(피연산자)라면 output에 추가
            output.Enqueue(c);
        else if (c == '(') // 여는 괄호라면 스택에 추가
            s.Push(c);
        else if (c == ')') // 닫는 괄호를 만나면
        {
            // 여는 괄호 전까지를 스택에서 꺼내서 출력에 넣기
            // 여는 괄호 제거
            while (s.Top() != '(')
            {
                output.Enqueue(s.Top());
                s.Pop();
            }
            s.Pop();
        }
        else // 연산자를 만나면
        {
            // 스택에서 c보다 우선순위가 높거나 같은 것들을 꺼내서 추가
            while (!s.IsEmpty() && Prec(c) <= Prec(s.Top()))
            {
                output.Enqueue(s.Top());
                s.Pop();
            }

            // c는 스택에 추가
            s.Push(c);
        }

        cout << "Stack: ";
        s.Print();
        cout << "Output:";
        output.Print();
        cout << endl;
    }

    // 스택에 남아있는 것들을 모두 추가
    while (!s.IsEmpty())
    {
        output.Enqueue(s.Top());
        s.Pop();
    }
}

int EvalPostfix(Queue<char>& q)
{
    Stack<int> s;

    while (!q.IsEmpty())
    {
        char c = q.Front();
        q.Dequeue();

        cout << c << endl;

        if (c != '+' && c != '-' && c != '*' && c != '/')
        {
            // 입력이 연산자가 아니면 일단 저장
            // 문자를 숫자로 변환 c - '0' 예: int('9' - '0') -> 정수 9
            s.Push(c - '0');
        }
        else
        {
            cout << "Operator: " << c << endl;

            // 입력이 연산자이면 스택에서 꺼내서 연산에 사용
            int second = s.Top();
            s.Pop();
            int first = s.Top();
            s.Pop();

            if (c == '+')
                s.Push(first + second);
            else if (c == '-')
                s.Push(first - second);
            else if (c == '*')
                s.Push(first * second);
            else if (c == '/')
                s.Push(first / second);
            else
            {
                cout << "Wrong operator" << endl;
                exit(-1); // 강제 종료
            }
        }

        cout << "Stack: ";
        s.Print();
    }

    return s.Top();
}

더 해볼 것들

숫자가 두자리 이상인 경우

character 자료형은 1 2 3 4를 12, 34 혹은 123,4로 구분할 수 없다. 따라서 두자리 숫자는 하나의 자료형으로 저장해야 하므로 Queue 자료형을 string 혹은 여러 숫자를 저장할 수 있는 자료형으로 변경해야 한다.

이 때 기존에 구현한 Queue는 메모리 해제 delete 와 소멸자를 호출하고 있다.

std::string은 자체적으로 메모리를 관리하므로 소멸자를 따로 호출할 필요가 없다.

str is not a pointer to dynamically allocated memory, so you cannot delete it. In fact, you don't have to: it is a member of a class and maneges owned memory itself.

string 자료형에다 곧바로 memcpy을 사용할 수 없다.

[Data Structures] 챕터4. 스택(Stack)

시옷지읏 — Wed, 29 Nov 2023 15:47:21 +0900

스택

할 일을 쌓아둔다.
LIFO(Last in First Out), 후입선출

용도

편집 소프트웨어의 Undo/Redo 기능 구현
연산자 우선순위를 고려한 수식의 계산 예) 1 + 2 * 3 에서 + 연산을 미뤄두고 *를 먼저 수행
함수 실행할 때 스택에 프레임 쌓기 - 앞에서 재귀호출 가시화 도구 가시화에서 봤듯이 나중에 호출된 함수를 끝낸 후 그 전에 호출된 함수로 돌아갈 수 있습니다.

구현

int Size() const
{
    return top_ + 1; // top_이 index를 가리키므로 +1을 해주자
}

// Insert item into the TOP of the stack
void Push(const T& item)
{
    if (capacity_ == top_+1) // capacity는 top + 1 index를 포함해야함
        Resize(capacity_ * 2);
	
    ++top_;
    stack_[top_] = item;
}

Pop

T자료형이 내부에서 동적할당 메모리를 사용한다면 소멸자를 호출해주자.

void Pop()
{
    assert(!IsEmpty());
    
    stack_[top_].~T(); // T 자료형 내부에서 동적할당 메모리를 사용할 경우
    top_--;

    // 메모리를 아껴야 될 경우 Resize로 크기를 줄이자
}

미로

struct Pos
{
    int row;
    int col;

    friend ostream& operator<<(ostream& os, const Pos& pos)
    {
        cout << "(" << pos.row << ", " << pos.col << ")" << flush;
        return os;
    }
};

참고 1) 9.2 입출력 연산자 오버로딩하기 https://hoplite.tistory.com/100

1. 연산자 오버로딩은 2개의 Parameter가 필요하다
2. 멤버 함수로 정의할 경우 1개의 Parameter가 필요하다
3. ostream의 멤버함수를 정의할 수 없으므로 외부 함수로 2개의 Parameter를 호출하는 형태로 함수를 정의한다.
4. 이 때 외부에서 구현하면 private 멤버변수에 접근할 수 없다.
5. 따라서 class 내부에서 정의 + friend keyword를 활용하여 해당 함수에서 멤버 변수의 접근권한을 준다.

참고 2) constexpr Keyword in C++17 https://hoplite.tistory.com/86

constexpr은 compile time에 초기화되는 변수이다.아래와 같이 정적 배열을 정의하는데 사용할 수 있다.

constexpr int kNumRows = 2;
constexpr int kNumCols = 2;

char maze[kNumRows][kNumCols] = {{0,1},{2,3};

참고 3) 구조체의 생성자와 임시 구조체

Pos start = { 1, 1 }; // i = 1, j = 1  시작 지점
//Pos start;
//start.row = 1;
//start.col = 1;

s.Push(start); // s.Push({1, 1});

구현

재귀호출

int RecurMaze(Pos p)
{
    const char mark = maze[p.row][p.col];
    cout << p << endl;

    if (mark == 'G')
    {
        cout << "Found!" << endl;
        return 1;
    }
    
    if (mark == '1' || mark == 'X')
        return 0;
    
    maze[p.row][p.col] = 'X';

    if (RecurMaze({p.row, p.col-1})) return 1;
    if (RecurMaze({p.row, p.col+1})) return 1;
    if (RecurMaze({p.row+1, p.col})) return 1;
    if (RecurMaze({p.row-1, p.col})) return 1;
}

문자 값 '1'으로 둘러쌓인 배열이므로 사용할 수 없는 index에 접근하는지 확인할 필요는 없다.

/*L*/if (0 < p.col - 1)
{
    if (RecurMaze({p.row, p.col-1}) == 1)
        return 1;
}

stack

재귀 호출은 자기함수를 호출하는 순서와 순회하는 순서가 동일하다.

stack을 사용하면 push하는 순서와 순회하는 순서가 반대가 된다.

void StackMaze()
{
    Stack<Pos> s;
    s.Push({1, 1});// i = 1, j = 1  시작 지점

    // s.Print(); // 디버깅에 사용 가능
    while (!s.IsEmpty())
    {
        Pos p = s.Top();
        s.Pop();

        cout << p << " "; // 디버깅 출력

        const char mark = maze[p.row][p.col];

        if (mark == 'G')
        {
            cout << "Found!" << endl;
            break;
        }

        if (mark == 'X' || mark == '1')
            continue;
        
        maze[p.row][p.col] = 'X';

        // 재귀와 다르게 마지막 Push부터 순회함
        s.Push({ p.row, p.col-1 });
        s.Push({ p.row, p.col+1 });
        s.Push({ p.row+1, p.col });
        s.Push({ p.row-1, p.col });
    }
}

의미

재귀호출와 Stack을 사용한 구현은 유사하다.

하노이의 탑

N개의 Disk를 옮기려면

N-1개의 Disk를 임시 위치로 옮긴다.
가장 아래에 있는 N 번째 Disk를 목표 위치로 옮긴다.
임시 위치에 있는 N-1개의 Disk를 목표위치로 옮긴다.

이 때 N-1개의 Disk를 옮기는 일은 다시 위와 같이 처리할 수 있으므로 재귀호출로 문제를 풀 수 있다.

https://github.com/HongLabInc/HongLabDataStructures/blob/main/Ex0403_TowerOfHanoi/Ex0403_TowerOfHanoi.cpp

void RecurMoveDisks(int n, int from, int temp, int to)
{
    if (n == 0)
        return;

    // stack the rest on temp location
    RecurMoveDisks(n-1, from, to, temp);

    // Move bottom disk to target location
    MoveDisk(from, to);

    // move the rest on the temp to target location
    RecurMoveDisks(n - 1, temp, from, to);
}

[Data Structures] 챕터3. 배열

시옷지읏 — Wed, 29 Nov 2023 00:31:13 +0900

문자열 ADT

Data Type : 저장공간의 크기, 같은 Data Type의 연산을 정의한다.

Abstract Data Type

- 구현 하지 않은 Data Type.

- 어떤 일을 해야하는 지 정의되어 있다.

예)

class MyString
{
public:
    MyString();                       // 비어 있는 MyString() 생성
    MyString(const char* init);       // 맨 뒤에 널 캐릭터'\0'가 들어 있는 문자열로부터 초기화
    MyString(const MyString& str);    // MyString의 다른 instance로부터 초기화
    ~MyString();

    bool IsEmpty();
    bool IsEqual(const MyString& str);
    int Length();
    void Resize(int new_size);

    MyString Substr(int start, int num);    // 인덱스 start위치의 글자부터 num개의 글자로 새로운 문자열 만들기
    MyString Concat(MyString app_str);      // 뒤에 덧붙인 새로운 문자열 반환 (append)
    MyString Insert(MyString t, int start); // 중간에 삽입

    int Find(MyString pat);

    void Print();

private:
    char* str_ = nullptr; // 마지막에 '\0' 없음
    int size_ = 0; // 글자 수
};

문자 배열 값을 복사할 때 for 반복문 대신 memcpy를 활용할 수 있다.

// 데이터 복사
for (int i = 0; i < size_; ++i)
    str_[i] = init[i];

// 데이터 복사
memcpy(str_, init, size_);

복사생성자

MyString::MyString(const MyString& str)
{
    // 기본 복사생성자는 포인터주소만 복사, 소멸시 오류
    size_ = str.size_;
    str_ = new char[size_];
    memcpy(str_, str.str_, size_);
}

동적할당 메모리 해제

메모리 할당이 되어있지 않을 때 메모리를 해제하면 에러가 발생한다.

if (str_ != nullptr)
{
    delete[] str_;
    str_ = nullptr;
    size_ = 0;
}

Resize

void MyString::Resize(int new_size)
{
    if (new_size != size_)
    {
        ...
    }
}

주의

동적할당 메모리를 재할당할 때 기존의 메모리를 반드시 반환해주자.

Concat

MyString MyString::Concat(MyString app_str)
{
    MyString temp;

    temp.Resize(size_ + app_str.size_);

    for (int i = 0; i < size_; ++i)
        temp.str_[i] = str_[i];

    for (int i = 0; i < app_str.size_; ++i)
        temp.str_[size_ + i] = app_str.str_[i];

    return temp;
}

for (int i = 0; i < app_str.size_; ++i)
    temp.str_[size_ + i] = app_str.str_[i];

memcpy를 활용하여 배열 포인터의 중간 index부터 복사하기

memcpy(temp.str_ + size_, app_str.str_, app_str.size_);
// or
memcpy(&temp.str_[size_], app_str.str_, app_str.size_);

Find

내 구현

int MyString::Find(MyString pat)
{
    for (int i = 0; i < size_; ++i)
    {
        if (str_[i] == pat.str_[0])
        {
            bool isEqual = true;
            for (int j = 0; j < pat.size_; ++j)
            {
                if (str_[i + j] != pat.str_[j])
                {
                    isEqual = false;
                    break;
                }
            }

            if (isEqual)
                return i;
        }
    }

    return -1;
}

우수 풀이

int MyString::Find(MyString pat)
{
    // "ABC" 에서 "DE"를 찾는다면      
    //   ^ 위치에서 더 찾을 필요가 없다
    // 글자 개수가 X라면 마지막 글자부터 X-1번째는 확인하지 않아도 됨
    for (int start = 0; start <= Length() - pat.Length(); ++start)
    {
        for (int j = 0; j < pat.size_; ++j)
        {
            if (str_[start + j] != pat.str_[j])
                break;

            if (j == pat.Length() - 1)
                return start;
        }
    }

    return -1;
}

더 빠른 풀이

Knuth-Morris-Pratt

Find의 최악의 시간복잡도

원본 문자열의 길이가 n이고 찾으려는 문자열의 길이가 n일 때 시간복잡도를 계산한다.

2중 for루프만 보면 O( (m-n+1) * n )이다. 이 때 m이 n보다 크면 O(mn)

다항식

Eval

다항식 2x^2 = 2 * pow(x,2)

float Polynomial::Eval(float x)
{
    float temp = 0.0f;

    // 힌트 std::powf(2.0f, float(3)); // 2.0f^3.0f = 8.0f (2.0f의 3.0f 제곱)
    for (int i = 0; i < capacity_; ++i)
    {
        if (coeffs_[i] != 0)
            temp += coeffs_[i] * powf(x, (float)i);
    }

    return temp;
}

이 때 i는 integer 자료형이므로 float로 형변환해주자

두 다항식의 곱은 다음과 같은 방법으로도 구할 수 있다.

1. 두 다항식의 요소를 각각 하나씩 조합하여 모든 경우를 나열한다.

2. 각 조합의 내부 원소를 모두 곱한 뒤 총합하면 두 다항식의 곱이된다.

Polynomial Polynomial::Mult(const Polynomial& poly)
{
    assert(poly.capacity_ == this->capacity_); // 문제를 단순화하기 위한 가정

    Polynomial temp(this->MaxDegree());

    for (int i = 0; i < poly.capacity_; ++i)
    {
        if (poly.coeffs_[i] == 0)
            continue;

        for (int j = 0; j < this->capacity_; ++j)
        {
            if (this->coeffs_[j] == 0)
                continue;

            if(i+j  < MaxDegree())
                temp.coeffs_[i+j] += poly.coeffs_[i] * this->coeffs_[j];
        }
    }

    return temp;
}

희소다항식(Sparse Polynomial)

계수가 0인 항이 많은 다항식을 희소다항식(Sparse Polynomial)이라 한다

위에서 구현한 다항식은 최대 차수항을 기준으로 메모리 공간을 사용한다.

희소다항식은 꼭 필요한 차수항만 데이터를 저장한다.

struct Term
{
    float coef;
    int exp;
};

class SparsePolynomial
{
private:
    Term* terms_ = nullptr;
};

높은 차수를 가지고 있지만 항의 개수가 적은 경우 그냥 다항식보다 빠르다

구현방법

A 다항식과 B 다항식을 더하여 C 다항식을 만든다. 이 때 두 다항식 모두 차수항이 정렬되어있다.

index를 사용하여 차수항이 낮은 쪽을 C 다항식에 밀어넣는다.

차수항이 동일할 때 합한 값을 C 다항식에 밀어넣는다.

내구현

SparsePolynomial SparsePolynomial::Add(const SparsePolynomial& poly)
{
    SparsePolynomial temp;

    int polyIdx = 0;
    int thisIdx = 0;

    while (true)
    {
        int thisExp = this->terms_[thisIdx].exp;
        int polyExp = poly.terms_[polyIdx].exp;
        
        if (polyIdx < poly.num_terms_ && thisIdx < this->num_terms_)
        {
            if (thisExp == polyExp)
            {
                float sumCoef = poly.terms_[polyIdx].coef + this->terms_[thisIdx].coef;
                temp.NewTerm(sumCoef, polyExp);
                thisIdx++;
                polyIdx++;
            }
            else if (thisExp > polyExp)
            {
                temp.NewTerm(poly.terms_[polyIdx].coef, polyExp);
                polyIdx++;
            }
            else if (thisExp < polyExp)
            {
                temp.NewTerm(this->terms_[thisIdx].coef, thisExp);
                thisIdx++;
            }
        }
        else if (polyIdx < poly.num_terms_)
        {
            temp.NewTerm(poly.terms_[polyIdx].coef, polyExp);
            polyIdx++;
        }
        else if (thisIdx < this->num_terms_)
        {
            temp.NewTerm(this->terms_[thisIdx].coef, thisExp);
            thisIdx++;
        }
        else
        {
            break;
        }
        
    }

    return temp;
}

우수구현

SparsePolynomial SparsePolynomial::Add(const SparsePolynomial& poly)
{
    SparsePolynomial temp;

    int i = 0, j = 0;
    while ((i < this->num_terms_) && (j < poly.num_terms_))
    {
        if ((terms_[i].exp == poly.terms_[j].exp))
        {
            float sum = poly.terms_[j].coef + terms_[i].coef;
            if (sum != 0.f)
                temp.NewTerm(sum, terms_[i].exp);

            ++i;
            ++j;
        }
        else if ((terms_[i].exp > poly.terms_[j].exp))
        {
            temp.NewTerm(poly.terms_[j].coef, poly.terms_[j].exp);
            ++j;
        }
        else
        {
            temp.NewTerm(terms_[i].coef, terms_[i].exp);
            ++i;
        }
    }

    // i가 끝날 경우 실행되지 않음
    for (; i < num_terms_; i++)
        temp.NewTerm(terms_[i].coef, terms_[i].exp);

    // j가 끝날 경우 실행되지 않음
    for (; j < poly.num_terms_; j++)
        temp.NewTerm(poly.terms_[j].coef, poly.terms_[j].exp);

    return temp;
}

시간복잡도

알고리즘의 시간복잡도는 O(m+n)

이 때 메모리를 동적할당 할 때 필요한 시간복잡도는 O( log2(N) )

예) 2^5를 가정할 때 0 - 1 - 2 - 4 - 8 - 16 - 32

메모리 크기를 100을 할당받을 때와 10000을 할당받을 때의 속도는 동일하다. 따라서 N개의

void SparsePolynomial::NewTerm(float coef, int exp)
{
	...
    if (num_terms_ >= capacity_)
    {
        capacity_ = capacity_ > 0 ? capacity_ * 2 : 1; // 2배씩 증가
        Term* new_term = new Term[capacity_];
		...
    }
    ...
}

행렬

1차원 배열을 활용하여 2차원 배열처럼 사용할 수 있다.

참고 const

함수 안에서 멤버 변수의 값을 바꾸지 않겠다는 의미

float Matrix::GetValue(int row, int col) const;

Transpose

내구현

Matrix Matrix::Transpose()
{
    Matrix temp(num_cols_, num_rows_); // num_cols_, num_rows_ 순서 주의

    for (int i = 0; i < num_cols_ * num_rows_; ++i)
    {
        int row = i / num_cols_;
        int col = i % num_cols_;
        temp.SetValue(col, row, this->GetValue(row, col));
    }

    return temp;
}

참고 구현

Matrix Matrix::Transpose()
{
    Matrix temp(num_cols_, num_rows_); // num_cols_, num_rows_ 순서 주의

    for (int r = 0; r < num_rows_; ++r)
        for (int c = 0; c < num_cols_; ++c)
            temp.SetValue(c, r, GetValue(r, c));

    return temp;
}

Add

내구현

Matrix Matrix::Add(const Matrix& b)
{
    assert(b.num_cols_ == num_cols_);
    assert(b.num_rows_ == num_rows_);

    Matrix temp(num_rows_, num_cols_);

    for (int i = 0; i < num_rows_ * num_cols_; ++i)
        temp.values_[i] = b.values_[i] + this->values_[i];

    return temp;
}

참고구현

Matrix Matrix::Add(const Matrix& b)
{
    assert(b.num_cols_ == num_cols_);
    assert(b.num_rows_ == num_rows_);

    Matrix temp(num_rows_, num_cols_);

    for (int r = 0; r < num_rows_; ++r)
        for (int c = 0; c < num_cols_; ++c)
            temp.SetValue(r, c, GetValue(r, c) + b.GetValue(r, c));

    return temp;
}

동적 배열의 배열

1. 동적할당으로 포인터 배열을 만든다.

2. 이 때 각 포인터는 동적할당 배열을 가리킨다.

1차원 배열로 2차원 배열처럼 사용 VS 동적할당 포인터 배열을 활용

1차원 배열

아주 큰 저장공간을 OS에게 요구할 경우 연속되지 않은 메모리를 할당받을 수 있다.

동적할당 포인터 배열

각 Row 별로 나누어 저장할 수 있다.

동적할당 포인터 배열의 크기만큼 추가적인 저장공간을 차지한다.

복사생성자 구현

Array2D::Array2D(const Array2D& b)
{
    this->num_rows_ = b.num_rows_;
    this->num_cols_ = b.num_cols_;

    arrays_ = new float* [b.num_rows_];

    for (int r = 0; r < b.num_rows_; ++r)
    {
        arrays_[r] = new float[b.num_cols_];
        for (int c = 0; c < b.num_cols_; ++c)
            arrays_[r][c] = b.arrays_[r][c];
    }
}

Array2D::Array2D(const Array2D& b)
{
    this->num_rows_ = b.num_rows_;
    this->num_cols_ = b.num_cols_;

    arrays_ = new float* [b.num_rows_];

    for (int r = 0; r < b.num_rows_; ++r)
    {
        arrays_[r] = new float[b.num_cols_];
        memcpy(arrays_[r], b.arrays_[r], sizeof(float) * num_cols_);
    }
}

C++ 정적 2차원 배열

#include <iostream>

using namespace std;

int main() 
{
    int arr[3][2] = {1, 2, 3, 4, 5, 6}; // 2차원 (정적) 배열

    for(int j = 0; j < 3; j ++)
        for(int i = 0; i < 2; i ++)
            cout << arr[j][i] << " "; // <- 정적 2차원 배열도 2차원 인덱싱 가능
    
    return 0;
}

희소 행렬(Sparse Matrix)

전체에서 값이 0인 항의 비중이 큰 행렬을 희소행렬(Sparse Matrix)라 한다.

희소행렬은 값이 0인 항을 저장하지 않는다.

0이 아닌 값을 가지는 항이 정렬되게 구현하자.

내구현

void SparseMatrix::SetValue(int row, int col, float value)
{
    if (value == 0.0f) return; // value가 0이 아닌 term만 저장

    int i;
    for (i = 0; i < num_terms_; ++i)
    {
        if (row < terms_[i].row)
        {	
            break; // row를 기준으로 새로 넣을 위치를 찾음
        }
        else if (row == terms_[i].row)
        {
            for (; i < num_terms_; ++i)
            {	
                if (row < terms_[i].row)
                    break; // i를 높였을 때 row가 변했다면 해당 위치에 넣기
                if (col <= terms_[i].col )
                    break; // row가 일정할 때 col을 기준으로 위치 찾기
            }
            break;
        }
    }

    // Shift
    if (col != terms_[i].col)
        for (int j = num_terms_ - 1; i < j; --j)
            terms_[j] = terms_[j - 1];
    
    MatrixTerm NewTerm;
    NewTerm.col = col;
    NewTerm.row = row;
    NewTerm.value = value;

    terms_[i] = NewTerm;
}

이 때 아무 값이 들어가있지 않을 때도 값을 비교해야하므로 생성자에서 col, row 초기값을 INT_MAX로 잡아준다.

SparseMatrix::SparseMatrix(int num_rows, int num_cols, int capacity)
{
    this->num_rows_ = num_rows;
    this->num_cols_ = num_cols;

    this->capacity_ = capacity;
    this->num_terms_ = capacity;

    terms_ = new MatrixTerm[this->capacity_];
    for (int i = 0; i < this->capacity_; ++i)
    {
        MatrixTerm Term;
        Term.col = INT_MAX; // 중요
        Term.row = INT_MAX; // 중요
        Term.value = 0;

        terms_[i] = Term;
    }
}

float SparseMatrix::GetValue(int row, int col) const
{
    for (int i = 0; i < num_terms_; ++i)
    {
        if (row < terms_[i].row) // 원하는 row의 범위를 지나갔음
            break;

        if (row == terms_[i].row && col == terms_[i].col)
            return terms_[i].value;
    }
    return 0.0f;
}

SparseMatrix SparseMatrix::Transpose()
{
	SparseMatrix temp(num_cols_, num_rows_, capacity_); // num_cols_, num_rows_ 순서 주의

	for (int i = 0; i < num_terms_; ++i)
		temp.SetValue(terms_[i].col, terms_[i].row, terms_[i].value);

	return temp;
}

float SparseMatrix::GetValue(int row, int col) const
{
    for (int i = 0; i < num_terms_; ++i)
    {
        if (row < terms_[i].row) // 원하는 row의 범위를 지나갔음
            break;

        if (row == terms_[i].row && col == terms_[i].col)
            return terms_[i].value;
    }
    return 0.0f;
}

참고

1. { }를 활용하여 간단하게 구조체를 정의할 수 있다. 이 때 멤버변수의 순서가 반드시 일치해야 한다.

struct MatrixTerm
{
    int row;
    int col;
    float value;
};

// 1
terms_[i].row = row;
terms_[i].col = col;
terms_[i].value = value;

// 2
terms_[i] = {row, col, value};

2. 동적할당 initialization

https://stackoverflow.com/questions/12694214/initialize-a-float-array-on-construction

더해보기

더하는 두 행렬은 동일한 row과 col을 가지며 capacity = row * col으로 설정하였다.

SparseMatrix SparseMatrix::Add(const SparseMatrix& b)
{
    SparseMatrix temp(b.num_rows_, b.num_cols_, b.capacity_);

    int cur = 0;
    int pram = 0;
    while (cur < num_terms_ && pram < b.num_terms_)
    {
        int curKey = num_cols_ * terms_[cur].row + terms_[cur].col;
        int pramKey = b.num_cols_ * b.terms_[pram].row + b.terms_[pram].col;

        if (curKey < pramKey)
        {
            temp.SetValue(terms_[cur].row, terms_[cur].col, terms_[cur].value);
            cur++;
        }
        else if (pramKey < curKey)
        {
            temp.SetValue(b.terms_[pram].row, b.terms_[pram].col, b.terms_[pram].value);
            pram++;
        }
        else
        {
            temp.SetValue(terms_[cur].row, terms_[cur].col, terms_[cur].value + b.terms_[pram].value);
            cur++;
            pram++;
        }
    }

    for (; cur < num_terms_; ++cur)
        temp.SetValue(terms_[cur].row, terms_[cur].col, terms_[cur].value);

    for (; pram < b.num_terms_; ++pram)
        temp.SetValue(b.terms_[pram].row, b.terms_[pram].col, b.terms_[pram].value);

    return temp;
}