C++ 如何遍历deque并搜索元素？

我有两个deque，定义如下

struct elem
{
    int key; elem* next;
}
*left = NULL, *right=NULL, *left2 = NULL, *right2 = NULL;

还有一个推送和弹出功能

void push_front(int n, elem*&l, elem*&r)
{
    elem *p=left;
    left = new elem;
    left -> key=n;
    left -> next=p;
    if(right==NULL)
    {
        right = left;
    }
}

int pop_front(int &n, elem*&l, elem*&r)
{ 
    elem *p; 
if (left)  
{    
    n=left->key; 
    p=left;    
    left=left->next;
    if (left==NULL)
        right=NULL;    
    delete p;     
    return 1;
}   
else
    return 0;
}

我必须输入搜索函数将使用的整数。出于某种原因，他们要求我首先弹出元素，检查它是否等于输入的数字，然后重复，直到找到元素，或者是否从第一个deque弹出所有元素。在提出要求之前，我是这样做的，但显然不正确：

void search(int x)
{
    elem *y=left;
    while(y->key!=x)
    {
    if(y==right)
    {
        cout<<x<<" wasn't found, adding to front."<<endl;
        push_front(x);
        return;
    }
    y=y->next;
    }
    cout<<x<<" was found"<<endl;
    return;

}

void搜索（int x）
{
elem*y=左；
而（y->键！=x）
{
如果（y==右）
{
cout对于初学者，两个函数
push_front
和
pop_front
都有打字错误。在函数中，您必须使用参数
l
和
r
的标识符，而不是标识符
left
和
right

void push_front(int n, elem*&l, elem*&r)
                       ^^^^^^^^^^^^^^^^
{
    elem *p=left;
            ^^^^^
    //...

并且不应定义全局变量left、right、left2和right2。函数不应依赖于全局变量

像搜索这样的函数应该只做一件事：报告元素是否存在于列表中

因此，函数的定义如下

bool search( const elem * &l, int x )
{
    const elem *current = l;

    while ( current != nullptr && current->key != x ) current = current->next;

    return current != nullptr;
}

根据函数的返回值，您可以将该值添加到列表中，也可以执行其他操作

如果由于您可能仅使用函数
pop_front
和
push_front
遍历列表而使用辅助列表（这是低效的），则该函数可能如下所示

bool search( elem * &l, elem * &r, int x )
{
    elem *l2 = nullptr, *r2 = nullptr;

    bool success = false;

    if ( l != nullptr )
    {
        do 
        {
            int key;

            pop_front( key, l, r );
            push_front( key, l2, r2 );

            success = key == x;
        } while ( !success && l != nullptr );
    }

    while ( l2 != nullptr )
    {
        pop_front( key, l2, r2 );
        push_front( key, l, r );
    }

    return success;
}

这是一个演示程序

#include <iostream>

struct elem
{
    int key; 
    elem *next;
};

void push_front( int n, elem * &l, elem * &r )
{
    l = new elem { n, l };

    if ( r == nullptr ) r = l;
}

bool pop_front( int &n, elem * &l, elem * &r )
{ 
    bool success = l != nullptr;

    if ( success )
    {
        n = l->key;

        elem *tmp = l;

        l = l->next;

        if ( l == nullptr ) r = nullptr;

        delete tmp;
    }

    return success;
}   


bool search( elem * &l, elem * &r, int x )
{
    elem *l2 = nullptr, *r2 = nullptr;

    bool success = false;

    if ( l != nullptr )
    {
        do 
        {
            int key;

            pop_front( key, l, r );
            push_front( key, l2, r2 );

            success = key == x;
        } while ( !success && l != nullptr );
    }

    while ( l2 != nullptr )
    {
        pop_front( key, l2, r2 );
        push_front( key, l, r );
    }

    return success;
}

int main() 
{
    elem *left = nullptr, *right = nullptr;

    const int N = 10;

    for ( int i = N; i != 0; --i )
    {
        push_front( i, left, right );
    }

    if ( !search( left, right, 0 ) )
    {
        push_front( 0, left, right );
    }

    while ( left != nullptr )
    {
        int key;

        pop_front( key, left, right );

        std::cout << key << ' ';
    }

    std::cout << '\n';

    return 0;
}

也就是说，如果在形成的列表中找不到0，它将被推到列表的前面。程序输出显示结果

如何穿越德克

这在很大程度上取决于用于实现双端队列的数据结构。
std:：deque
例如被实现为数组的链接列表。除了在遍历数组的每个节点之外，遍历列表就像遍历链接列表一样

不管怎样，数据结构的遍历通常通过定义迭代器类在C++中实现。给定迭代器，遍历可以像这样实现：
current = beginning_of_the_range;
last    = end_of_the_range;
for (; current != last; ++current) {
    // current points to current element here
}

您似乎已经使用单链接列表实现了双端队列。单链接列表的迭代器可以实现如下：

current = beginning_of_the_range;
last    = end_of_the_range;
for (; current != last; ++current) {
    // current points to current element here
}


将指向当前节点的指针存储在迭代器中。让我们将其称为
node
迭代器的间接寻址可以实现为
returnnode->key；
要移动到下一个元素，请执行
node=node->next；
要检查迭代器是否相等，
返回节点==other.node；
表示结束的迭代器可以表示为nullptr，也可以使用sentinel节点

…并搜索一个元素

一旦你实现了遍历，你就可以使用线性搜索了。
-为什么不呢？这是我不使用它的一个要求…我很久以前使用std:：find做过这件事，但实际上我不允许使用它。我有两个定义如下的deque——你向我们展示的更像是一个单链接列表，而不是deque。
struct elem
{
    int key; elem* next;
}