Question

我需要自己创建一个deque来了解它如何与练习一起工作，我也不需要使用该库，我想编写自己的函数

我创建了一个Deque类，它有方法push_back（），push_front（），pop_back（），pop_front（）;

起初我为push_front（）编写了这样的代码：

void Deque :: push_front( int data, int number ) {

 deque[head - 1] = data;
 head++;
}

这是构造函数：

  Deque :: Deque( int number ) : head (1), tail (1), 
                                 go_straight (0), go_back (1), 
                                 deque (new int [number]) {
                                    for( int i = 0; i < number; ++i) {
                                       deque[i] = 0;
                                    }
                                 };

但是这个push_front以这样的方式工作：如果我输入4（元素数）然后输入40（值）

   40 0 0 0

如果输入50（值），它将变为：

  40 50 0 0

但我需要像这样做

  50 40 0 0

换句话说，我需要在+1上移动元素，我该怎么做？

提前谢谢!!!

Answer 1

假设您的序列存储在某个数组ar[N]中，而某些ar[len]其中len < N是当前的＆＃34;返回＆＃34;你的队列，只是＆＃34; shift＆＃34;要素：

#include <iostream>

template<typename T, size_t N>
bool push_front(const T& val, T(&ar)[N], size_t& len)
{
    if (len >= N)
        return false;

    size_t i = len;
    while (i--)
        ar[i+1] = ar[i];
    ar[0] = val;
    ++len;
    return true;
}

template<typename T, size_t N>
void print_array(const T(&ar)[N])
{
    for (auto& x : ar)
        std::cout << x << ' ';
    std::cout << '\n';
}

int main()
{
    int ar[10] = {0};
    size_t len = 0;
    print_array(ar);

    for (int i=10; push_front(i, ar, len); i+=10);
    print_array(ar);

    return 0;
}

<强>输出

0 0 0 0 0 0 0 0 0 0 
100 90 80 70 60 50 40 30 20 10

注意：每次插入都有O（N）复杂度（这意味着插入N个项目的O（N ^ 2））。使用循环缓冲区和非常仔细的模运算，你可以使它成为O（1），但它并不是微不足道的，所以我提前警告你。

关于在您的代码中的工作方式，包括充实复制/交换习惯用法以符合Rule of Three。这两次推动已经实施。我将两个pop，top()和back()实现留给你。

#include <algorithm>

class Deque
{

private:
    unsigned int size;
    unsigned int length;
    int *elems;

    void swap(Deque& other)
    {
        std::swap(size, other.size);
        std::swap(length, other.length);
        std::swap(elems, other.elems);
    }

public:
    Deque(unsigned int size)
        : size(size)
        , length(0)
        , elems(new int[size]())
    {
    }

    Deque(const Deque& arg)
        : size(arg.size)
        , length(arg.length)
        , elems(new int[arg.size])
    {
        std::copy(arg.elems, arg.elems + arg.length, elems);
    }

    ~Deque()
    {
        delete [] elems;
    }

    Deque& operator =(Deque obj)
    {
        swap(obj);
        return *this;
    }

    // push to the front of the deque
    bool push_front(int value)
    {
        if (length == size)
            return false;

        unsigned int i=length;
        while (i--)
            elems[i+1] = elems[i];
        elems[0] = value;
        ++length;
        return true;
    }

    // push to the back of the deque
    bool push_back(int value)
    {
        if (length == size)
            return false;

        elems[length++] = value;
        return true;
    }
};

Deque push_front（）和push_back（），不包括<deque> </deque>

1 个答案: