[C++] dequeのランダムアクセスとは？アクセス速度や実装について解説

#include <iostream>
#include <deque>
int main() {
    // dequeの宣言と初期化
    std::deque<int> numbers = {10, 20, 30, 40, 50};
    // ランダムアクセスで3番目の要素を取得
    int thirdElement = numbers[2];
    std::cout << "3番目の要素: " << thirdElement << std::endl;
    return 0;
}

3番目の要素: 30

#include <iostream>
#include <deque>
#include <vector>
std::vector<int> maxSlidingWindow(const std::vector<int>& nums, int k) {
    std::deque<int> deq;
    std::vector<int> result;
    for (int i = 0; i < nums.size(); ++i) {
        // ウィンドウから外れる要素を削除
        if (!deq.empty() && deq.front() == i - k) {
            deq.pop_front();
        }
        // 現在の要素より小さい要素を削除
        while (!deq.empty() && nums[deq.back()] < nums[i]) {
            deq.pop_back();
        }
        // 現在の要素を追加
        deq.push_back(i);
        // ウィンドウがk要素に達したら最大値を記録
        if (i >= k - 1) {
            result.push_back(nums[deq.front()]);
        }
    }
    return result;
}
int main() {
    std::vector<int> nums = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3;
    std::vector<int> result = maxSlidingWindow(nums, k);
    std::cout << "スライディングウィンドウの最大値: ";
    for (int num : result) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

スライディングウィンドウの最大値: 3 3 5 5 6 7

#include <iostream>
#include <deque>
int main() {
    std::deque<int> buffer;
    // データの追加
    buffer.push_back(10);
    buffer.push_back(20);
    buffer.push_front(5);
    // バッファの内容を表示
    std::cout << "バッファの内容: ";
    for (int num : buffer) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    // データの削除
    buffer.pop_back();
    buffer.pop_front();
    // バッファの内容を再表示
    std::cout << "更新後のバッファの内容: ";
    for (int num : buffer) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

バッファの内容: 5 10 20
更新後のバッファの内容: 10

#include <iostream>
#include <deque>
int main() {
    std::deque<int> dataStream;
    // データストリームにデータを追加
    for (int i = 1; i <= 5; ++i) {
        dataStream.push_back(i);
    }
    // データストリームの内容を表示
    std::cout << "データストリームの内容: ";
    for (int num : dataStream) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    // 古いデータを削除し、新しいデータを追加
    dataStream.pop_front();
    dataStream.push_back(6);
    // 更新後のデータストリームの内容を再表示
    std::cout << "更新後のデータストリームの内容: ";
    for (int num : dataStream) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

データストリームの内容: 1 2 3 4 5
更新後のデータストリームの内容: 2 3 4 5 6

#include <iostream>
#include <deque>
#include <string>
int main() {
    std::deque<std::string> eventQueue;
    // イベントの追加
    eventQueue.push_back("Player1 moved");
    eventQueue.push_back("Player2 attacked");
    eventQueue.push_back("Player1 healed");
    // イベントの処理
    while (!eventQueue.empty()) {
        std::cout << "Processing event: " << eventQueue.front() << std::endl;
        eventQueue.pop_front();
    }
    return 0;
}

Processing event: Player1 moved
Processing event: Player2 attacked
Processing event: Player1 healed

#include <iostream>
#include <deque>
int main() {
    std::deque<int> realTimeData;
    // データの追加
    for (int i = 0; i < 5; ++i) {
        realTimeData.push_back(i * 10);
    }
    // データの処理
    while (!realTimeData.empty()) {
        std::cout << "Processing data: " << realTimeData.front() << std::endl;
        realTimeData.pop_front();
    }
    return 0;
}

Processing data: 0
Processing data: 10
Processing data: 20
Processing data: 30
Processing data: 40

#include <iostream>
#include <deque>
#include <thread>
#include <mutex>
#include <condition_variable>
std::deque<int> dataQueue;
std::mutex mtx;
std::condition_variable cv;
void producer() {
    for (int i = 0; i < 5; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        dataQueue.push_back(i);
        std::cout << "Produced: " << i << std::endl;
        cv.notify_one();
    }
}
void consumer() {
    for (int i = 0; i < 5; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return !dataQueue.empty(); });
        int data = dataQueue.front();
        dataQueue.pop_front();
        std::cout << "Consumed: " << data << std::endl;
    }
}
int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

Produced: 0
Consumed: 0
Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3
Produced: 4
Consumed: 4