1. 비변경 시퀀스 알고리즘

이 알고리즘들은 대상 컨테이너의 요소들을 수정하지 않고 동작합니다.

1.1 검색 관련 함수

• find(start, end, target): 특정 값과 일치하는 첫 번째 요소를 찾습니다.
• find_if(start, end, condition): 조건을 만족하는 첫 번째 요소를 탐색합니다.
• find_end(start, end, pattern_start, pattern_end): 하위 시퀀스가 마지막으로 나타나는 위치를 반환합니다.

vector<int> data = {1, 3, 5, 7, 9};

// 값 5 찾기
auto pos = find(data.begin(), data.end(), 5);
if (pos != data.end()) {
    cout << "발견됨: " << *pos << endl;
}

// 6보다 큰 첫 요소 찾기
auto greater_than_six = find_if(data.begin(), data.end(), [](int val) {
    return val > 6;
});
cout << "첫 6초과 값: " << *greater_than_six << endl;

// 부분 시퀀스 찾기
vector<int> pattern = {3, 5};
auto subseq_pos = find_end(data.begin(), data.end(), pattern.begin(), pattern.end());
if (subseq_pos != data.end()) {
    cout << "시작 인덱스: " << subseq_pos - data.begin() << endl;
}

1.2 카운팅 함수

• count(start, end, target): 특정 값의 개수를 셉니다.
• count_if(start, end, condition): 조건을 만족하는 요소 수를 계산합니다.

vector<int> numbers = {1, 2, 3, 2, 4, 2};
int twos = count(numbers.begin(), numbers.end(), 2);
int evens = count_if(numbers.begin(), numbers.end(), [](int n) { 
    return n % 2 == 0; 
});

1.3 순회 적용 함수

for_each(start, end, function)는 지정 범위의 모든 요소에 함수를 적용합니다.

vector<int> values = {1, 2, 3, 4, 5};
for_each(values.begin(), values.end(), [](int& item) { 
    item *= 2; 
});

1.4 비교 함수

• equal(range1_start, range1_end, range2_start): 두 범위가 같은지 확인합니다.
• mismatch(range1_start, range1_end, range2_start): 처음으로 다른 요소들의 위치를 반환합니다.

vector<int> first = {1, 2, 3};
vector<int> second = {1, 2, 4};
vector<int> third = {1, 2, 3, 4};

bool same = equal(first.begin(), first.end(), second.begin());
auto diff_pair = mismatch(first.begin(), first.end(), third.begin());

1.5 조건 검사 함수

• all_of(): 모든 요소가 조건을 만족하는지
• any_of(): 하나라도 조건을 만족하는 요소가 있는지
• none_of(): 모든 요소가 조건을 만족하지 않는지

vector<int> test_data = {2, 4, 6, 8};
bool all_even_numbers = all_of(test_data.begin(), test_data.end(), [](int n) { 
    return n % 2 == 0; 
});
bool has_odd = any_of(test_data.begin(), test_data.end(), [](int n) { 
    return n % 2 != 0; 
});
bool no_negatives = none_of(test_data.begin(), test_data.end(), [](int n) { 
    return n < 0; 
});

2. 변경 시퀀스 알고리즘

컨테이너의 내용을 직접 수정하는 알고리즘들입니다.

2.1 복사 함수

• copy(source_start, source_end, destination): 요소들을 복사합니다.
• copy_if(source_start, source_end, destination, condition): 조건에 맞는 요소만 복사합니다.

vector<int> origin = {1, 2, 3, 4, 5};
vector<int> target(5);

copy(origin.begin(), origin.end(), target.begin());

vector<int> filtered;
copy_if(origin.begin(), origin.end(), back_inserter(filtered), [](int n) {
    return n % 2 == 0;
});

2.2 변환 함수

transform()은 각 요소에 함수를 적용하여 결과를 저장합니다.

vector<int> input = {1, 2, 3};
vector<int> output(3);

transform(input.begin(), input.end(), output.begin(), [](int x) {
    return x * x;
});

vector<int> left = {1, 2, 3};
vector<int> right = {4, 5, 6};
vector<int> combined(3);
transform(left.begin(), left.end(), right.begin(), combined.begin(), [](int a, int b) {
    return a + b;
});

2.3 교체 함수

• replace(start, end, old_value, new_value): 특정 값을 다른 값으로 변경합니다.
• replace_if(start, end, condition, new_value): 조건을 만족하는 요소를 교체합니다.
• replace_copy(start, end, destination, old_value, new_value): 복사하면서 교체합니다.

vector<int> dataset = {1, 2, 3, 2, 5};

replace(dataset.begin(), dataset.end(), 2, 20);

replace_if(dataset.begin(), dataset.end(), [](int x) {
    return x > 10;
}, 0);

vector<int> copied;
replace_copy(dataset.begin(), dataset.end(), back_inserter(copied), 3, 300);

2.4 제거 함수

• remove(start, end, value): 특정 값을 제거합니다.
• remove_if(start, end, condition): 조건에 맞는 요소를 제거합니다.

vector<int> elements = {1, 2, 3, 2, 4};

auto new_end = remove(elements.begin(), elements.end(), 2);
elements.erase(new_end, elements.end());

elements = {1, 2, 3, 4, 5};
elements.erase(remove_if(elements.begin(), elements.end(), [](int x) {
    return x % 2 == 0;
}), elements.end());

2.5 중복 제거 함수

unique()는 연속된 중복 요소를 제거합니다.

vector<int> sequence = {1, 1, 2, 2, 3, 3, 3, 4, 5};
auto last_unique = unique(sequence.begin(), sequence.end());
sequence.erase(last_unique, sequence.end());

2.6 역순 함수

reverse(start, end)는 요소들의 순서를 반전시킵니다.

vector<int> items = {1, 2, 3, 4, 5};
reverse(items.begin(), items.end());

2.7 회전 함수

rotate(start, pivot, end)는 지정된 중심점을 기준으로 요소들을 회전시킵니다.

vector<int> rotation_test = {1, 2, 3, 4, 5};
rotate(rotation_test.begin(), rotation_test.begin() + 2, rotation_test.end());

2.8 무작위 재배열 함수

shuffle()은 요소들을 임의로 섞습니다.

#include <random>
#include <algorithm>

vector<int> shuffle_target = {1, 2, 3, 4, 5};
random_device rd;
mt19937 generator(rd());
shuffle(shuffle_target.begin(), shuffle_target.end(), generator);

3. 정렬 및 관련 알고리즘

3.1 정렬 함수

• sort(start, end): 퀵소트 기반 정렬
• stable_sort(start, end): 안정 정렬
• partial_sort(start, middle, end): 부분 정렬

vector<int> unsorted = {5, 3, 1, 4, 2};
sort(unsorted.begin(), unsorted.end());
sort(unsorted.begin(), unsorted.end(), greater<int>());

vector<pair<int,int>> pairs = {{1, 2}, {2, 1}, {1, 1}, {2, 2}};
stable_sort(pairs.begin(), pairs.end(), [](const auto& a, const auto& b) {
    return a.first < b.first;
});

vector<int> partial_data = {5, 3, 1, 4, 2, 6};
partial_sort(partial_data.begin(), partial_data.begin() + 3, partial_data.end());

3.2 선택 정렬 함수

nth_element(start, nth_position, end)는 n번째 요소를 정렬 후 위치에 배치합니다.

vector<int> selection_data = {5, 3, 1, 4, 2, 6};
nth_element(selection_data.begin(), selection_data.begin() + 2, selection_data.end());

3.3 이진 탐색 함수

정렬된 컨테이너에서 사용됩니다.

• binary_search(start, end, value): 값 존재 여부 확인
• lower_bound(start, end, value): 첫 >= 위치
• upper_bound(start, end, value): 첫 > 위치

vector<int> sorted_data = {1, 3, 3, 5, 7};

bool found = binary_search(sorted_data.begin(), sorted_data.end(), 3);

auto lower = lower_bound(sorted_data.begin(), sorted_data.end(), 3);
auto upper = upper_bound(sorted_data.begin(), sorted_data.end(), 3);

3.4 병합 함수

merge(sorted_range1, sorted_range2, destination)는 두 정렬된 범위를 합칩니다.

vector<int> list_a = {1, 3, 5};
vector<int> list_b = {2, 4, 6};
vector<int> merged_result(list_a.size() + list_b.size());

merge(list_a.begin(), list_a.end(), list_b.begin(), list_b.end(), merged_result.begin());

4. 힙 알고리즘

힙 구조를 다루는 함수들입니다.

vector<int> heap_data = {4, 1, 3, 2, 5};
make_heap(heap_data.begin(), heap_data.end());

heap_data.push_back(6);
push_heap(heap_data.begin(), heap_data.end());

pop_heap(heap_data.begin(), heap_data.end());
int maximum = heap_data.back();
heap_data.pop_back();

sort_heap(heap_data.begin(), heap_data.end());

5. 최대/최소값 알고리즘

5.1 단일 값 비교

int x = 5, y = 3;
int minimum = min(x, y);
int maximum = max(x, y);

auto min_from_list = min({4, 2, 8, 5, 1});
auto max_from_list = max({4, 2, 8, 5, 1});

5.2 범위 내 최대/최소

vector<int> range_data = {3, 1, 4, 2, 5};
auto min_iterator = min_element(range_data.begin(), range_data.end());
auto max_iterator = max_element(range_data.begin(), range_data.end());

5.3 동시 최대/최소 찾기

vector<int> dual_search = {3, 1, 4, 2, 5};
auto min_max_pair = minmax_element(dual_search.begin(), dual_search.end());

6. 수치 알고리즘 (<numeric> 헤더)

6.1 누적 합계

#include <numeric>

vector<int> sum_input = {1, 2, 3, 4, 5};
int total = accumulate(sum_input.begin(), sum_input.end(), 0);
int multiplication = accumulate(sum_input.begin(), sum_input.end(), 1, multiplies<int>());

6.2 내적 계산

vector<int> vector_a = {1, 2, 3};
vector<int> vector_b = {4, 5, 6};
int dot_product = inner_product(vector_a.begin(), vector_a.end(), vector_b.begin(), 0);

6.3 연속 값 채우기

vector<int> fill_target(5);
iota(fill_target.begin(), fill_target.end(), 10);

6.4 부분 합계

vector<int> partial_source = {1, 2, 3, 4, 5};
vector<int> partial_destination(partial_source.size());
partial_sum(partial_source.begin(), partial_source.end(), partial_destination.begin());

6.5 인접 차분

vector<int> diff_source = {1, 2, 3, 4, 5};
vector<int> diff_destination(diff_source.size());
adjacent_difference(diff_source.begin(), diff_source.end(), diff_destination.begin());

7. 기타 알고리즘

7.1 생성 함수

vector<int> generation_target(5);
int counter = 0;
generate(generation_target.begin(), generation_target.end(), [&counter]() { 
    return counter++; 
});

vector<int> limited_generation(5);
int start_value = 10;
generate_n(limited_generation.begin(), 3, [&start_value]() { 
    return start_value++; 
});

7.2 포함 관계 확인

vector<int> superset = {1, 2, 3, 4, 5};
vector<int> subset = {2, 4};
bool is_subset = includes(superset.begin(), superset.end(), subset.begin(), subset.end());

7.3 집합 연산

vector<int> set_a = {1, 2, 3, 4, 5};
vector<int> set_b = {3, 4, 5, 6, 7};
vector<int> operation_result;

set_union(set_a.begin(), set_a.end(), set_b.begin(), set_b.end(), back_inserter(operation_result));

operation_result.clear();
set_intersection(set_a.begin(), set_a.end(), set_b.begin(), set_b.end(), back_inserter(operation_result));

operation_result.clear();
set_difference(set_a.begin(), set_a.end(), set_b.begin(), set_b.end(), back_inserter(operation_result));

operation_result.clear();
set_symmetric_difference(set_a.begin(), set_a.end(), set_b.begin(), set_b.end(), back_inserter(operation_result));