MySQL 서비스 관리 명령어

상태 확인

sudo systemctl status mysql

서비스 시작

sudo systemctl start mysql

서비스 재시작

# 설정 변경 후 MySQL 재시작 필요
sudo systemctl restart mysql

서비스 중지

sudo systemctl stop mysql

부팅 시 자동 시작

# 부팅 시 자동 시작 활성화
sudo systemctl enable mysql

# 부팅 시 자동 시작 비활성화
sudo systemctl disable mysql

설정 파일

sudo cat /etc/mysql/my.cnf

# 현재 상태 정보 확인
mysql -u root -p -e "SHOW STATUS;"

# MySQL 클라이언트로 현재 설정 값 확인
mysql -u root -p -e "SHOW VARIABLES;"

# 특정 설정 값만 필터링해서 보기 (예: buffer_pool_size)
mysql -u root -p -e "SHOW VARIABLES LIKE '%buffer_pool_size%';"

추가 유용한 명령어

# MySQL 프로세스 확인
ps aux | grep mysql

# MySQL 버전 확인
mysql -V
mysql -u root -p -e "SELECT version();"

# 사용자 목록 확인
mysql -u root -p -e "SELECT user, host FROM mysql.user;"

# 데이터베이스 목록 확인
mysql -u root -p -e "SHOW DATABASES;"

# 테이블 상태 확인
mysql -u root -p -e "SHOW TABLE STATUS;"

# 실행 중인 쿼리 확인
mysql -u root -p -e "SHOW PROCESSLIST;"

백업 및 복구

# 전체 데이터베이스 백업
sudo mysqldump -u root -p --all-databases > full_backup.sql

# 특정 데이터베이스 백업
sudo mysqldump -u root -p database_name > db_backup.sql

# 백업 파일로 복구
mysql -u root -p < full_backup.sql

The post MySQL 서비스 관리 명령어 (Ubuntu) appeared first on 어제와 내일의 나 그 사이의 이야기.

트라이(Trie)?

Trie data structure는 문자열을 효율적으로 저장하고 검색하는 데 사용되는 Tree와 유사한 데이터 구조입니다.

“Trie”라는 이름은 “트리”와 비슷하게 발음되는 “retrieval,”이라는 단어에서 유래되었습니다.

검색할 때 볼 수 있는 자동완성 기능, 사전 검색 등 문자열을 탐색하는데 특화되어있는 자료구조입니다.

“A”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”를 키로 둔 트라이.

이 예제에는 모든 자식 노드가 알파벳 순으로 왼쪽에서 오른쪽으로 정렬되어 있지는 않다. (루트 노드와 ‘t’ 노드)

Trie에서 각 node는 문자열의 단일 문자를 나타내고 node에서 나오는 가장자리는 문자열의 다음 문자를 나타냅니다.

Trie의 각 문자열은 root node에서 leaf node까지의 경로로 표시됩니다.

root node에는 연결된 문자가 없으며 각 leaf node는 데이터 세트의 전체 문자열을 나타냅니다.

Trie는 특히 공통 접두사를 공유하는 문자열을 검색할 때 문자열을 효율적으로 저장하고 검색하는 데 자주 사용됩니다.

예를 들어 Trie를 사용하여 단어 사전을 저장할 수 있습니다.

여기서 Trie의 각 node는 단어의 접두사를 나타냅니다.

Trie를 root node에서 leaf node로 이동하면 leaf node와 관련된 전체 단어를 빠르게 검색할 수 있습니다.

트라이(Trie)의 이점

1. 효율적인 접두사 검색

Trie는 특히 접두사 검색 쿼리에 효율적입니다.

root node에서 접두사를 나타내는 node로 Trie를 순회하면 해당 접두사로 시작하는 데이터 세트의 모든 문자열을 검색할 수 있습니다.

이는 자동 완성, 맞춤법 검사기 및 검색 엔진과 같은 응용 프로그램에서 유용합니다.

2. 공간 효율성

Trie는 해시 테이블과 같은 다른 데이터 구조에 비해 매우 공간 효율적일 수 있습니다.

문자열에 공통 접두사의 중복 저장을 방지하여 특히 문자열 수가 많은 데이터 세트의 경우 공간을 크게 절약할 수 있습니다.

3. 빠른 삽입 및 삭제

Trie는 문자열의 빠른 삽입 및 삭제를 지원하며 최악의 경우 O(m)의 시간 복잡도(m 문자열의 길이)입니다.

따라서 데이터 세트가 동적이며 자주 업데이트해야 하는 애플리케이션에서 유용합니다.

4. 예측 텍스트 입력

Trie는 자동 완성 시스템을 구현하는 데 사용할 수 있습니다.

여기서 시스템은 사용자 입력을 기반으로 다음 단어나 구문을 제안합니다.

자주 사용되는 단어와 구문의 Trie를 저장함으로써

시스템은 사용자의 현재 입력을 기반으로 가장 가능성이 높은 다음 단어를 제안할 수 있습니다.

5. 낮은 메모리 오버헤드

Trie는 특히 ASCII 또는 유니코드와 같은 작은 문자 세트의 경우 메모리 오버헤드가 낮습니다.

따라서 임베디드 시스템 및 기타 메모리 제약 환경에서 사용하기에 적합합니다.

전반적으로 Trie 데이터 구조는 문자열의 데이터 세트를 효율적으로 저장하고 처리하기 위한 강력한 도구입니다.

특히 기본 사용 사례가 접두사를 검색하거나 시퀀스의 다음 단어를 예측하는 경우에 그렇습니다.

트라이(Trie)의 잠재적인 단점

1. 메모리 요구 사항

Trie는 특히 문자열이 길거나 문자 집합이 큰 경우

큰 문자열 데이터 세트를 저장하기 위해 상당한 양의 메모리를 요구할 수 있습니다.

이는 메모리 사용량이 중요한 환경이나 응용 프로그램에서의 사용을 제한할 수 있습니다.

2. 접두사가 아닌 쿼리에 대한 느린 검색 시간

Trie는 접두사 검색 쿼리에 효율적이지만 접두사가 아닌 쿼리에 대한 다른 데이터 구조보다 느릴 수 있습니다.

알고리즘이 쿼리와 일치하는 모든 문자열을 찾기 위해 각 노드의 전체 하위 트리를 탐색해야 하므로

해시 테이블과 같은 다른 데이터 구조에 비해 검색 시간이 느려질 수 있기 때문입니다.

3. 복잡성

Trie 데이터 구조의 구현 및 유지 관리는

엄청나게 큰 데이터 세트의 경우 또는 문자 집합이 매우 복잡한 경우에

다른 데이터 구조보다 더 복잡할 수 있습니다.

이로 인해 개발 시간이 길어지고 개발 비용이 높아질 수 있습니다.

4. 희소 데이터 집합에 대한 비효율적인 메모리 사용

데이터 집합에 희소 문자열이 많이 포함되어 있거나 공통 접두사가 거의 없는 경우

Trie는 가장 메모리 효율적인 데이터 구조가 아닐 수 있습니다.

이는 Trie가 많은 빈 노드를 저장해야 하므로 메모리가 낭비될 수 있기 때문입니다.

전반적으로 Trie 데이터 구조는 효율적인 문자열 처리를 위한 강력한 도구이지만

응용 프로그램의 특정 요구 사항에 따라 항상 최선의 선택이 아닐 수도 있습니다.

트라이(Trie)의 시간 복잡도

일반적으로 Trie의 생성 시간 복잡도는 O(M x L), 탐색 시간 복잡도는 O(L)이다.

제일 긴 문자열의 길이를 L이라 하고, 총 문자열들의 수를 M이라 할 때 시간 복잡도는 위와 같다.

생성 시간 복잡도는 모든 문자열 M 개를 넣어야 하고,

M 개에 대해서 트라이에 넣는 건 가장 긴 문자열 길이인 L 만큼 걸리므로 O(MxL)의 시간 복잡도를 가진다. (삽입은 O(L)이다.)

탐색 시간 복잡도는 트리를 제일 깊게 탐색하는 경우는 가장 긴 문자열 길이인 L까지 깊게 들어가는 것이므로 O(L)의 시간 복잡도를 가진다.

트라이(Trie) 구현 (C++)

#include <iostream>
#include <unordered_map>

using namespace std;

// TrieNode클래스를 사용하여 Trie의 각 노드를 표현
class TrieNode {

public:
    unordered_map<char, TrieNode*> children;
    bool isEndOfWord;

    TrieNode() { 
        isEndOfWord = false;
    }
    
};

// Trie 클래스
class Trie {

    // Trie의 루트 노드에 대한 포인터인 Trie개인 멤버 변수
    private: 
        TrieNode* root; // 루트 노드

// 생성자새 인스턴스를 만들고 Trie를 초기화합
    public:
        Trie() {
            root = new TrieNode();
        }


    // 문자열을 받아 Trie에 추가합니다. 
    // 루트 노드에서 시작하여 Trie 아래로 이동하여 단어의 각 문자에 필요한 새 노드를 만듭니다.
    void insert(string word) {
        TrieNode* curr = root; // 시작
        for (char c : word) {
            if (curr->children.find(c) == curr->children.end()) {
                // Trie에 없다면 새 노드 생성
                curr->children[c] = new TrieNode();
            }
            curr = curr->children[c]; // Trie에 이미 존재하는 경우 기존 노드로 이동
        }
        // 단어의 끝을 나타내는 isEndOfWord bool값
        curr->isEndOfWord = true;
    }

    // 단어를 검색합니다.
    bool search(string word) {
        TrieNode* curr = root;
        for (char c : word) {
            if (curr->children.find(c) == curr->children.end()) {
                return false;
            }
            curr = curr->children[c];
        }
        return curr->isEndOfWord;
    }

    // prefix(접두사)로 시작하는 단어가 Trie에 있는지 확인
    bool startsWith(string prefix) {
        TrieNode* curr = root;
        for (char c : prefix) {
            if (curr->children.find(c) == curr->children.end()) {
                return false;
            }
            curr = curr->children[c];
        }
        return true;
    }
};

int main() {

    Trie trie;
    trie.insert("hello");
    trie.insert("world");
    trie.insert("hello world");

    cout << trie.search("hello") << "\n";      // output: 1 (true)
    cout << trie.search("hello world") << "\n"; // output: 1 (true)
    cout << trie.search("hi") << "\n";         // output: 0 (false)

    cout << trie.startsWith("hell") << "\n";    // output: 1 (true)
    cout << trie.startsWith("heaven") << "\n";  // output: 0 (false)

    return 0;
}

#include <string>
#include <vector>
#include <unordered_map>

using namespace std;

// TrieNode클래스를 사용하여 Trie의 각 노드를 표현
class TrieNode {
public:
    unordered_map<char, TrieNode*> children;
    int num; // 연관된 단어의 개수를 저장
    TrieNode() {
        num = 0;
    }
};

// Trie 클래스
class Trie {

private: // Trie의 루트 노드에 대한 포인터인 Trie개인 멤버 변수
    TrieNode* root; // 루트 노드


public:
    Trie() { // 생성자새 인스턴스를 만들고 Trie를 초기화
        root = new TrieNode();
    }

    // 문자열을 받아 Trie에 추가합니다. 
    // 루트 노드에서 시작하여 Trie 아래로 이동하여 단어의 각 문자에 필요한 새 노드를 만듭니다.
    void insert(string word) {
        TrieNode* curr = root; // 시작
        for (char c : word) {
            if (curr->children.find(c) == curr->children.end()) {
                // Trie에 없다면 새 노드 생성
                curr->children[c] = new TrieNode();
            }

            // Trie에 이미 존재하는 경우 기존 노드로 이동
            curr = curr->children[c];
            curr->num++; // 연관된 단어의 개수 추가
        }
    }

    // 단어를 검색합니다.
    // 연관된 단어의 개수가 1이라면 글자수 반환
    int search(string word) {
        TrieNode* curr = root;
        int cnt = 0;
        for (char c : word) {
            curr = curr->children[c];
            cnt++;
            if (curr->num == 1) {
                // 연관된 단어의 개수가 1이라면 
                // 자동완성
                return cnt;
            }
        }
        return 9999; // 문제에서 나올 수 없는 경우 
    }

    // prefix(접두사)로 시작하는 단어가 Trie에 있는지 확인
    int startsWith(string prefix) {
        TrieNode* curr = root;
        for (char c : prefix) {
            if (curr->children.find(c) == curr->children.end()) {
                return false;
            }
            curr = curr->children[c];
        }
        return curr->children.size();
    }

};

int solution(vector<string> words) {
    int answer = 0;
    Trie trie;
    for (auto& it : words) {
        trie.insert(it);
    }

    for (auto& it : words) {
        if (trie.startsWith(it) >= 1) {
            // 접두사로 시작하는 단어가 있다면 
            // 단어 전체를 입력해야한다.
            answer += it.length();
            continue;
        }

        // 자동완성 확인
        answer += trie.search(it);
    }

    return answer;
}

https://www.acmicpc.net/problemset?sort=ac_desc&algo=79 <- 트라이 연습 문제 모음

The post 알고리즘 – 트라이(Trie) 자료구조 appeared first on 어제와 내일의 나 그 사이의 이야기.

시간 복잡도 / 공간 복잡도

상황에 맞는 좋은 알고리즘을 선택하기 위해서는 알고리즘의 효율성을 확인해야 한다.

이 때 효율성 측정에는 시간 복잡도(time complexity)와 공간 복잡도(space complexity)라는 두 부분이 있다.

시간 복잡도는 문제를 해결하는데 걸리는 시간과 입력의 함수 관계

공간 복잡도는 문제를 해결하는데 필요로 하는 자원 공간의 양

Big-O 표기법 (Big-O Notation)

시간 복잡도의 표기법은

최선 경우 분석(Best Case Analysis) => Big-Ω(빅-오메가) / 하한 점근

-> 알고리즘 최상의 실행 시간을 표기한다.

최악 경우 분석(Worst Case Analysis) => Big-O(빅-오) / 상한 점근

-> 알고리즘 최악의 실행 시간을 표기한다.

평균 경우 분석(Average Case Analysis) => Big-θ(빅-세타) / 그 둘의 평균

-> 알고리즘 평균 실행 시간을 표기한다.

일반적으로 위의 3가지 경우로 분류한다.

그중에서 Big-O 표기법은 최소한 보장되는 성능을 표기하기 때문에 가장 많이 사용하는 표기법이다.

(불확실성을 제거하기 위해 최악의 경우를 사용)

O(1) < O(logN) < O(N) < O(N logN) < O(N²) < O(2ᴺ) < O(N!)

O(1) – 상수 시간 (Constant Time)

입력한 데이터의 크기에 상관없이 언제나 일정한 시간이 걸리는 알고리즘

O(1) 알고리즘은 데이터(data)가 증가해도, 처리속도(time)에는 변함이 없는 알고리즘이다.

#include <iostream>

using namespace std;

int main()
{
	cout << "Do Something!!";

	return 0;
}

#include <iostream>

using namespace std;

int main()
{
	cout << "Do Something!!";
	cout << "Do Something!!";

	return 0;
}

두번 출력을 하는 코드는 O(2)가 아닌 O(1)이다.

왜냐하면 Big O는 함수의 디테일에는 관심이 없기 때문이다.

그저 input 사이즈에 따라서 달라진다.

O(N) – 선형 시간 (Linear Time)

O(N)는 완벽한 대각선

최악의 경우에 n번의 연산을 수행해야 하는 알고리즘으로 데이터가 추가될 때마다 알고리즘이 한 단계 더 진행된다.

이것이 선형 시간이라고 하는 이유

ex) 1중 for문

#include <iostream>

using namespace std;

int main()
{
	int N = 0;
	cin >> N;
	for (int i = 0; i < N; i++) {
		cout << "Do Something!!" << "\n";
	}

	return 0;
}

* 참고 * O(1) / O(N)

O(1)과 O(N)의 알고리즘으로 같은 문제를 50까지 수행한다면

→ 입력 배열의 요소가 50개 미만일 때 O(N)가 더 효율적

→ 정확히 50개의 요소에서 두 알고리즘은 동일한 단계 수를 사용

→ 데이터가 증가할수록 O(N)더 많은 단계가 필요

Big-O 표기법은 데이터가 무한대로 커짐에 따라 알고리즘이 어떻게 수행되는지 살펴보기 때문에

O(N)가 보다 덜 효율적인 것으로 간주되는 이유다.

O(N²) – 2차 시간 (Quadratic Time)

성능이 입력 요소 크기의 제곱에 비례하는 알고리즘의 복잡성을 나타낸다. 일반적으로 매우 느리다.

주로 중첩 반복이 있을 때 발생하게 된다.

루프안에서 루프가 실행된다면, 20개의 데이터는 400개의 스텝이 된다. O(n^2)

ex) 2중 for문, 삽입(Insertion)/거품(Bubble)/선택(Selection) 정렬 등…

#include <iostream>

using namespace std;

int main()
{
	int N = 0;
	cin >> N;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			cout << "Do Something!!" << "\n";
		}
	}

	return 0;
}

O(logN) – 로그 시간 (Logarithmic Time)

연산이 한 번 실행될 때 마다 데이터의 크기가 절반 감소하는 알고리즘 (log의 지수는 항상 2)

데이터의 관점으로 말하면 O(logN)은 데이터가 두 배가 될 때마다 작업 수가 하나씩 증가한다.

ex) binary search 알고리즘, tree 형태 자료구조 탐색

// 이진 탐색

int BinarySearch(int arr[], int size, int target)
{
	
	int low = 0;
	int high = size - 1;
	int mid = 0;

	while (low <= high)
	{
		mid = (low + high) / 2;

		if (target < arr[mid])
			high = mid - 1;
		else if (target > arr[mid])
			low = mid + 1;
		else
			return mid;  // 반환 값은 인덱스
	}

	return -1;
}

O(N logN) – 로그 선형 시간 (Log-linear Time)

O(N)의 알고리즘과 O(log N)의 알고리즘이 중첩된 형태

log(N)작업 N시간을 수행

ex) 퀵(Quick) / 병합(Merge) / 힙(Heap) 정렬, 분할 정복 알고리즘

O(2ᴺ) – 지수 시간 (Exponential Time)

매우 느린 시간 복잡도로 주로 재귀적으로 수행하는 알고리즘이 이에 해당

ex) fibonacci 수열

// 피보나치 수열 
int Fibonaci(int n){
    if (n == 1) return 0;
    else if (n == 2) return 1;
    else return Fibo(n - 1) + Fibo(n - 2);
}

O(N!) – 계승 시간(Factorial Time)

 입력 크기의 계승에 비례하는 실행 시간

가장 느린 알고리즘으로 입력 값이 조금만 커져도 계산이 어렵다. (답없다.)

빅오 표기법(big-O notation) 규칙

계수 법칙: 상수를 제거하라

계수 법칙은 단순히 입력 크기와 연관되지 않은 상수를 전부 무시하는 것이다

빅오에서 입력 크기가 클 때 계수를 무시할 수 있다

상수 k > 0 인 경우 f(n)이 O(g(n))이면,
kf(n)은 O(g(n)이다.
이 말은 즉, 5f(n)과 f(n)이 모두 동일한 O(f(n))이라는 빅오 표기법을 지님을 의미한다

합의 법칙: 빅오를 더하라

합의 법칙은 시간 복잡도를 더할 수 있다는 것을 의미한다

f(n)이 O(h(n))이고 g(n)이 O(p(n))이라면
f(n)+g(n)은 O(h(n))+O(p(n))이다
이 때 주의해야할 점은 합의 법칙을 적용한 다음 계수 법칙을 적용해야한다는 점이다

곱의 법칙: 빅오를 곱하라

곱의 법칙은 빅오가 어떤 식으로 곱해지는지에 관한 것이다

f(n)이 O(h(n))이고 g(n)이 O(p(n))이면
f(n)g(n)은 O(h(n)p(n))이다

다항 법칙: 빅오의 k승

다항 법칙은 다항 시간 복잡도가 동일한 다항 차수를 지닌 빅오 표기법을 지님을 의미한다

f(n)이 k차 다항식이면 f(n)은 O(nᵏ)이다

쉽게 말해, 빅오 표기법은 제일 영향력 있는 것만 신경쓰겠다는 의미

(최고 차항을 남기고, 상수는 버린다)

O(30n³+20n²+500n+3000)로 표시된 값이 있을 때, 빅오 표기법은 제일 영향력 있는 것만 남겨 O(n³)으로만 표기한다

참고 사이트

https://velog.io/@2seunghye/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EB%B9%85%EC%98%A4%ED%91%9C%EA%B8%B0%EB%B2%95Big-O-notation

https://towardsdatascience.com/introduction-to-big-o-notation-820d2e25d3fd

https://wing-beat.tistory.com/17

https://towardsdatascience.com/the-big-o-notation-d35d52f38134

https://noahlogs.tistory.com/27

https://velog.io/@nana-moon/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EB%B9%85%EC%98%A4-%ED%91%9C%EA%B8%B0%EB%B2%95big-O-notation%EC%9D%B4%EB%9E%80

The post 알고리즘 – 빅오 표기법(Big-O Notation) 정리 appeared first on 어제와 내일의 나 그 사이의 이야기.

알고리즘을 분석하는 이유

정확성 확인(무결성 확인)

모든 유효한 입력에 대해서 유한 시간 내에 올바른 해를 찾아내는가를 판단하기 위함

효율성 확인

한정된 자원(기억 장소 사용량, 수행 시간)에서 효율적으로 작동하는지 확인하기 위함

궁극적으로 알고리즘을 분석하여 얻는 이점

문제를 해결하기 위해 중요한 것과 중요하지 않은 것을 판단할 수 있다.

문제를 단순화하여 생각할 수 있다.

다른 사람의 아이디어에 대한 효율성을 판단할 수 있다.

같은 문제를 해결하는 알고리즘은 여러 가지가 존재한다.

최상의 알고리즘은 존재하지 않으며 항상 주어진 상황을 객관적으로 분석하여 알고리즘을 선택해야 한다.

또한 기존의 알고리즘을 개선하기 위해서 적용 가능한 여러 알고리즘을 객관적으로 비교 분석을 할 줄 알아야 한다.

알고리즘을 분석하는 방법

일반적으로 알고리즘의 수행 시간에 따른 시간복잡도(Time Complexity)와

작성한 프로그램이 얼마나 많은 공간(메모리)을 차지하느냐를 분석하는 방법인 공간복잡도(Space Complexity)로 분석한다.

시간복잡도의 경우 알고리즘을 잘못 구성하였을 경우 결과값이 나오지 않거나 현저하게 느린속도가 나오기에

공간복잡도보다는 시간복잡도를 우선시하여 프로그램을 분석한다. (기술의 발달로 인한 메모리 증가도 큰 영향)

알고리즘의 수행 시간

알고리즘의 효율성을 분석하는 방법은 다양하지만, 많은 경우에 알고리즘의 수행 시간을 이용하여 효율성을 분석

시간복잡도 (Time Complexity) : 얼마나 빠른가?

입력 크기에 비례하여 작업시간이 어떠한 비율로 증가하는지 확인한다.

시간복잡도를 사용하는 이유

실측으로 시간을 측정하는 경우 프로그래밍 언어, 컴퓨터의 성능, 프로그래머의 실력 등의 다양한 변수에 따라 달라질 수 있다.

(분석에 객관적인 기준이 필요)

수행 시간 분석 방법

최선 경우 분석(Best Case Analysis) => Big-Ω(빅-오메가) / 하한 점근

최선의 경우는 프로그램 실행 시간의 하한을 계산한다.

선형 탐색의 경우 베스트 케이스는 찾으려는 x가 제일 처음에 위치하는 경우이다.

최상의 경우 실행되는 연산의 수는 상수이며 입력 크기 n에 영향을 받지 않는다.

따라서 최상의 경우 시간 복잡도는 θ(1)이다.

최악 경우 분석(Worst Case Analysis) => Big-O(빅-오) / 상한 점근

최악의 경우는 알고리즘이 실행되는 시간의 상한을 결정한다.

프로그램을 실행 할 때 연산이 수행되는 횟수가 최대가 되는 경우이다.

선형 탐색의 경우 찾으려는 원소가 배열에 존재하지 않거나 배열의 끝에 존재하는 경우이다.

배열에 찾으려는 원소가 존재하지 않으면 배열의 전체 원소와 모두 비교를 한다.

이 때 최악이라는 것은 단위 연산이 수행되는 횟수가 최대라는 것이다.

입력 크기와 입력 값(내용) 모두에 종속된다.

선형 탐색의 최악의 경우 시간 복잡도는 θ(n)이다.​

평균 경우 분석(Average Case Analysis) => Big-θ(빅-세타) / 그 둘의 평균

평균적인 경우를 계산하는 방법은 다음과 같다.

가능한 모든 입력에 대해 실행 시간을 계산한다.

그리고 이 시간을 모두 더하고, 더한 결과를 입력의 수로 나눈다.

선형 탐색을 계산하는 방법은 다음과 같다.

선형 탐색인 경우 모든 경우들이 균등하게 분포한다고 가정하자.

크기 n의 배열에서 원소 x를 찾으려고 할 때, x의 위치는 1 또는 2, 3, … , n이 될 수 있다.

배열을 따라 각 원소를 x와 비교한다.

만약 배열의 k번째 원소에 도달 했으면 이미 k번 비교를 한 것이다.

x가 인덱스 1의 위치에 있다면 1번 비교한다.

x가 인덱스 2의 위치에 있다면 2번 비교한다.

…

x가 인덱스 n의 위치에 있다면 n번 비교한다.

평균을 구하기 위해 비교한 수들을 합하면 1+ 2 + 3 + … + n = (n+1)n / 2

이를 배열의 크기인 n으로 나누면 (n+1) / 2 이다.

따라서 선형 탐색의 평균 시간 복잡도는 θ(n) 이다.

가장 자주 사용되는 분석

최악 경우 분석(Worst Case Analysis) => Big-O(빅-오) / 상한 점근

시간 복잡도에는 여러 개념이 있지만 그중에서

‘아무리 많이 걸려도 이 시간 안에는 끝날 것‘의 개념이 제일 중요하다. 

예를 들어 동전을 튕겨서 뒷면이 나올 확률을 이야기해본다면 운이 좋으면 한 번에 뒷면이 나올 수도 있고

운이 좋지 않으면 3번 4번만에 뒷면이 나올수도 있다.

운이 나쁜 경우 n번만큼 동전을 튕겨야 하는 최악의 경우가 발생하는데

이 최악의 경우를 계산하는 방식을 빅-오(Big-O) 표기법이라고 부르며 이 방식을 가장 많이 사용한다.

The post 알고리즘 – 알고리즘 분석에 대한 정리 appeared first on 어제와 내일의 나 그 사이의 이야기.

요약

코딩 테스트를 준비하면서 정리한 변수 자료형들의 범위 및 바이트 목록입니다.

값의 범위를 어느 정도 인지하고 있어야 오버플로우를 막을 수 있습니다.

# int와 long은 다른 타입입니다.

https://smallpants.tistory.com/10 <- 참고

long이 int보다 더 큰 범위를 보관할 수 있다고 보는 것은 옳지 않다.

int는 운영체제의 환경(32bit, 64bit 등)에 맞는 크기로 사용되어 왔는데

아래와 같이 16비트 운영체제에서는 16비트로 사용되었고

32비트 운영체제에서는 32비트로 사용되었는데

64비트 운영체제에서 int가 64비트가 되면 long보다 크기가 커지게 되므로

int가 아닌 long을 8바이트로 늘려서 사용하게 되었다고 한다.

그러므로 32비트 기반으로 컴파일하게 되면 int와 long의 자료형의 길이는 같다.

(windows의 경우 64비트로 컴파일해도 같다. 이유는 맨 아래에)

16비트 운영체제

  – short : 16비트

  – int : 16비트

  – long : 32비트

32비트 운영체제 

  – short : 16비트

  – int : 32비트

  – long : 32비트

64비트 운영체제 

  – short : 16비트

  – int : 32비트

  – long : 64비트

MS 문서

https://learn.microsoft.com/ko-kr/cpp/cpp/data-type-ranges?view=msvc-170

Microsoft C++ 32비트 및 64비트 컴파일러는 이 문서의 뒷부분에 있는 표의 형식을 인식합니다.

int (unsigned int)

__int8 (unsigned __int8)

__int16 (unsigned __int16)

__int32 (unsigned __int32)

__int64 (unsigned __int64)

short (unsigned short)

long (unsigned long)

long long (unsigned long long)

이름이 두 개의 밑줄(__)로 시작하는 경우 데이터 형식은 비표준입니다.

다음 표에 지정된 범위는 포함-포함입니다.

__wchar_t 변수는 사용 방법에 따라 와이드 문자 형식 또는 멀티바이트 문자 형식을 지정합니다.

문자 또는 문자열 상수 앞에 L 접두사를 사용하여 와이드 문자 형식 상수를 지정합니다.

signed 및 unsigned 는 bool을 제외한 모든 정수 형식에서 사용할 수 있는 한정자입니다. 

char, signed char 및 unsigned char는 오버로드 및 템플릿과 같은 메커니즘에 사용되는 3가지 고유 형식입니다.

int 및 unsigned int 형식의 크기는 4바이트입니다.

그러나 언어 표준에서 구현 전용으로 허용되므로 이식 가능한 코드는 int 의 크기에 의존해서는 안 됩니다.

Visual Studio의 C/C++에서도 크기가 지정된 정수 형식을 지원합니다.

자세한 내용은 정수 제한 및 정수 제한을 참조 __int8, __int16, __int32, __int64 하세요.

각 형식의 크기 제한에 대한 자세한 내용은 기본 제공 형식을 참조하세요.

열거 형식의 범위는 언어 컨텍스트 및 지정된 컴파일러 플래그에 따라 달라집니다.

The post C++ 데이터 형식 범위 (<strong>Microsoft Visual C++</strong>) appeared first on 어제와 내일의 나 그 사이의 이야기.