c++) list

std::list

이중 연결 리스트(doubly linked list)를 구현한 컨테이너입니다. 각 요소는 두 개의 포인터(하나는 이전 요소를 가리키고 다른 하나는 다음 요소를 가리킴)를 포함하는 노드에 저장

 

헤더파일

#include<list>

선언

list< [Data Type] > [변수 명];
//요소의 데이터 타입을 명시해주지 않는다면 컴파일 에러가 발생합니다.

생성자

list< [Data Type] > lt; //비어있는 list를 lt로 명명

list< [Data Type] > lt(10); //원소 10개를 생성하여 lt로 명명

list< [Data Type] > lt(3,2) //값 2로 초기화한 원소 3개를 생성하여 lt로 명명

list< [Data Type] > lt1;
list< [Data Type] > lt2(lt1); //리스트 lt1의 값을 lt2에 복사하여 생성

연산자

list<Int> lt1 = {1,2,3};
list<Int> lt2 = {1,2,3};

//==, !=, >, <, >=, <= 연산자로 리스트 등가성비교 대소비교가 가능
lt1 == lt2
lt1 != lt2
lt1 >= lt2 //대소비교 같은 경우, 왼쪽 요소부터 차례대로 값을 비교합니다.
lt1 <= lt2
lt1 > lt2
lt1 < lt2

list<Int> lt1 = {1,3,3};
list<Int> lt2 = {1,2,3};

/*
이 경우 첫번째 요소들은 같지만 
두번째 요소 3과 2를 비교했을때 3이 크므로 
lt1이 크다고 할 수 있습니다.
*/
lt1 > lt2

list의 멤버 함수

자주 사용하는 멤버 함수를 살펴보겠습니다.

push_front()

void push_front(const T& value);

용도

list 선언 과정에서 선택된 타입(T)인 값(value)를 list 첫번째에 추가

push_back()

void push_back(const T& value);

용도

값(value)를 list 마지막에 추가

pop_front()

void pop_front();

용도

list 첫번째 요소 제거

pop_back()

void pop_back();

용도

list 마지막 요소 제거

insert()

iterator insert(iterator position, const T& value);

용도

iterator타입의 값을 가지고 리스트 내 몇번째에 값(value)을 추가할지 선택 후 값 (value) 을 주입

 

이때!

iterator타입의 값을 얻기 위해서

#include<iostream>
#include<list>

using namespace std;

int main(){
    list<int> lt1 = {1,2,3};

    //iterator 타입 선언 첫번째 자리를 가리키는 iterator 값 할당
    list<int>::iterator it = lt1.begin();

    //만약 3번째를 가리키고 싶다면
    advance(it,2);
    
    lt1.insert(it, 10);//
    
    for(auto value : lt1){
    	cout << value << " ";
        //삽입 이전: 1,2,3
        //3번째에 10 추가: 1,2,10,3
    }
}

erase()

iterator erase(iterator position);//position 위치에 요소 삭제

//first위치에 요소부터 last 요소 이전의 값을 삭제(last 위치에 해당하는 요소 삭제X)
iterator erase(iterator first, iterator last);

용도

지정된 범위 내 요소 삭제

 

clear()

void clear();

용도

모든 요소 삭제

size()

size_type size() const;

용도

요소의 갯수 반환

empty()

bool empty() const;

용도

리스트가 요소가 존재하지 않는지 확인

sort()

void sort();

용도

기본 sort()는 사전 순으로 요소들을 정렬하는 함수입니다.

만약 다른 기준으로 정렬하고 싶다면 예를 들어, 내림차순

#include <iostream>
#include <list>

bool compareDescending(int a, int b) {
    return a > b; // 내림차순 비교
}

int main() {
    // 리스트 생성 및 초기화
    std::list<int> myList = {1,2 ,3};

    // 사용자 정의 비교 함수를 사용하여 리스트 정렬
    myList.sort(compareDescending);

    // 정렬된 리스트 출력
    std::cout << "Sorted list in descending order: ";
    for (const auto& item : myList) {
        std::cout << item << " ";
    }
    std::cout << std::endl;

    return 0;
}

reverse()

void reverse();

용도

요소의 순서를 거꾸로 하는 함수

merge()

void merge(list& x);
template <class Compare> void merge(list& x, Compare comp);

용도

두 개의 list를 병합하는 함수

 

병합을 진행한 후 merge()함수를 호출한 list가 아닌 나머지 list는 clear가 된다.

 

template <class Compare> void merge(list& x, Compare comp);

위 merge() 같은 경우 병합 시 comp라는 병합 기준에 따라 정렬을 진행해줌

주의!: 병합 시 각 리스트들을 정렬 시켜주어야 한다. 그렇지 않은 경우 기준과 상관없이 병합을 진행

 

 

#include <iostream>
#include <list>

// 사용자 정의 비교 함수 (오름차순 비교)
bool compareAscending(int a, int b) {
    return a < b;
}

int main() {
    // 첫 번째 리스트 생성 및 초기화
    std::list<int> list1 = {1, 3, 5, 7}; //정렬된 상태

    // 두 번째 리스트 생성 및 초기화
    std::list<int> list2 = {2, 4, 6, 8}; //정렬된 상태
    
    // 두 리스트를 내림차순으로 병합
    list1.merge(list2, compareAscending);

    // 병합된 리스트 출력
    std::cout << "Merged list: ";
    for (const auto& item : list1) {
        std::cout << item << " ";
    }
    std::cout << std::endl;

    // list2는 이제 비어 있어야 함
    std::cout << "List2 size after merge: " << list2.size() << std::endl;

    return 0;
}

splice()

void splice(iterator position, list& x);
void splice(iterator position, list& x, iterator i);
void splice(iterator position, list& x, iterator first, iterator last);

용도

하나의 리스트 특정 위치에 다른 리스트의 전체 혹은 요소 하나 또는 여러 요소들을 잘라내어 추가할 수 있다.

x(list)의 선택된 영역은 splice() 함수가 실행된 이후 삭제가 된다.

#include <iostream>
#include <list>

int main() {
    std::list<int> list1 = {1, 2, 3, 4, 5};

    std::list<int> list2 = {6, 7, 8, 9, 10};

    std::list<int>::iterator itEnd = list2.begin();
    std::advance(itEnd, 2);
    list1.splice(list1.end(), list2, list2.begin(), itEnd);

    std::cout << "list1: ";
    for (auto i : list1) {
        std::cout << i << " "; //list1: 1 2 3 4 5 6 7 
    }
    std::cout << std::endl;

    std::cout << "list2: ";
    for (auto i : list2) {
        std::cout << i << " ";//list2: 8 9 10
    }

    return 0;
}

remove()

void remove(const T& value);

용도

전달한 값(value)과 일치하는 요소를 제거하는 함수

unique()

void unique();
template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);

용도

front()

reference front();
const_reference front() const;

용도

첫번째 요소를 반환 받는 함수, 첫번째 공간에 값을 할당할 수 있다.

#include <iostream>
#include <list>

int main() {
    // 리스트 생성 및 초기화
    std::list<int> myList = {10, 20, 30, 40};

    // 첫 번째 요소를 반환받아 출력
    std::cout << "First element: " << myList.front() << std::endl;

    // 첫 번째 요소를 수정
    myList.front() = 100;
    std::cout << "First element after modification: " << myList.front() << std::endl;

    return 0;
}

back()

reference back();
const_reference back() const;

용도

마지막 요소를 반환 받는 함수, 마지막 공간에 값을 할당할 수 있다.

#include <iostream>
#include <list>

int main() {
    // 리스트 생성 및 초기화
    std::list<int> myList = {10, 20, 30, 40};

    // 첫 번째 요소를 반환받아 출력
    std::cout << "First element: " << myList.back() << std::endl;

    // 첫 번째 요소를 수정
    myList.back() = 100;
    std::cout << "First element after modification: " << myList.back() << std::endl;

    return 0;
}

begin()

iterator begin();
const_iterator begin() const;

용도

컨테이너의 첫 번째 요소를 가리키는 반복자를 반환하는 함수

end()

iterator end();
const_iterator end() const;

용도

컨테이너의 마지막 요소의 다음 위치를 가리키는 반복자를 반환하는 함수