Инвертирование очереди

Тема в разделе "Общие вопросы по С и С++", создана пользователем Mariaaa, 10 май 2006.

Статус темы:
Закрыта.
  1. Mariaaa

    Mariaaa Гость

    С++
    Помогите, пожалуйста, написать функцию, инвертирующую очередь в классе QueueInt.
    Вот программа:

    #include<iostream.h>
    #include<conio.h>
    enum BOOL {false, true};
    //------------------------------------------------------------------
    class List
    {
    int data;
    List *next, *prev;
    int Get() {return data;}
    public:
    List(const int d)
    {
    data=d;
    next=prev=NULL;
    }
    friend class ListInt;
    friend class QueueInt;
    friend ostream & operator<<(ostream&, ListInt*);
    friend istream & operator>>(istream&, ListInt*);
    };
    //------------------------------------------------------------------
    class ListInt
    {
    protected:
    List *back, *front, *token;
    friend ostream & operator<<(ostream&, ListInt*);
    friend istream & operator>>(istream&, ListInt*);
    public:
    ListInt()
    {
    back=front=token=NULL;
    }
    void PutToken(int val)
    {
    List *p = new List(val);
    if(empty())
    front=back=p;
    else
    {
    back->next=p; p->prev=back;
    back=p;}
    }
    virtual int GetToken()
    {
    if(token==NULL) token=front;
    if(token)
    {
    int rv=token->data;
    token=token->next;
    return rv;
    }
    else return 0;}
    BOOL empty()
    {return front==NULL? true:false;}
    };
    //------------------------------------------------------------------
    class QueueInt: public ListInt
    {
    int GetToken();
    };
    //------------------------------------------------------------------
    ostream & operator<<(ostream& os, ListInt*q)
    {
    os<<"<";
    do
    {
    if(!q->empty())
    os<<q->GetToken()<<",";
    }
    while(q->token);
    return os<<">"<<endl;
    }
    //---------------------------------------------------------------
    istream & operator>>(istream& is, ListInt*q)
    {
    int a; int k;
    cout<<"Сколько элементов будите вводить? ";
    is>>k;
    for(int i=0; i<k; i++)
    {
    cout<<i+1<<": ";
    is>>a;
    q->PutToken(a);
    }
    return is;
    }
    //---------------------------------------------------------------------------
    int QueueInt::GetToken()
    {
    if(token==NULL) token=back;
    if(back)
    {
    back=back->prev;
    if(back)
    {
    back->next=NULL;
    }
    else front=NULL;
    int retval=token->data;
    delete token;
    token=back;
    return retval;
    }
    else return 0;
    }
    //-----------------------------------------------------------------
    int main()
    {
    clrscr();
    ListInt* lst=new ListInt;
    cin>>lst;
    cout<<"Список:\n";
    cout<<lst;
    ListInt*och;
    cout<<"Очередь:\n";
    cout<<och;
    getch();
    return 0;
    }
     
  2. Trupik

    Trupik Гость

    Для: Mariaaa
    Пожалуйста, воспользуйся тегом code и отформатируй код. А то читать уж больно неудобно.
     
  3. ru_looking_for

    ru_looking_for Гость

    Это называестя не очередь, а стэк, потому что ты кидаешь данные в конец и из конца извлекаешь. Очередь - это когда кладут в начало, а извлекают из конца. Ну ладно, пусть стэк станет на некоторое время очередью :( . Я немного исправил твой код, хотя есть еще много недостатков, но возможно тебе и не нужно чего-то большего. Из существенного: я довавил оператор << для класа QueueInt, потому что его там не было, и вызывался оператор базового класса. Он использовал метод GetToken(), который перегружен в QueueInt. Но в QueueInt он у тебя ИЗВЛЕКАЕТ данные, то есть удаляет их из структуры, а оператор вывода не должен модифицировать то, что он выводит в поток. Новый оператор просто обхотит всю структуру и выводит в поток кождое звено. Ну и естественно инвертирование - это функция QueueInt::Reverse(). Пользуйся на здоровье!

    Код (Text):
    #include <iostream>
    #include <conio.h>

    using namespace std;

    /////////////////////////////////////////////////////////////////////////////

    //enum BOOL {false, true};

    // List /////////////////////////////////////////////////////////////////////

    class List
    {
    private:
    int data;
    List *next, *prev;

    public:
    List(const int d)
    {
    data = d;
    next = prev = NULL;
    }

    int Get() { return data; }

    friend class ListInt;
    friend class QueueInt;
    friend ostream & operator<<(ostream&, ListInt*);
    friend ostream & operator<<(ostream& os, QueueInt *q);
    };

    // ListInt //////////////////////////////////////////////////////////////////

    class ListInt
    {
    protected:
    List *back, *front, *token;

    public:
    ListInt()
    {
    back = front = token = NULL;
    }
    void PutToken(int val)
    {
    List *p = new List(val);
    if(empty())
    front = back = p;
    else
    {
    back->next = p;
    p->prev = back;
    back = p;
    }
    }

    virtual int GetToken()
    {
    if(token == NULL)
    token = front;

    if(token)
    {
    int rv = token->data;
    token = token->next;
    return rv;
    }
    else
    return 0;
    }

    bool empty() { return front == NULL ? true : false; }

    friend ostream & operator<<(ostream&, ListInt*);
    friend istream & operator>>(istream&, ListInt*);
    };

    /////////////////////////////////////////////////////////////////////////////

    ostream & operator<<(ostream& os, ListInt *q)
    {
    os << "<";

    do
    {
    if(!q->empty())
    os << q->GetToken() << ", ";
    } while (q->token);

    return os << ">" << endl;
    }

    /////////////////////////////////////////////////////////////////////////////

    istream & operator>>(istream& is, ListInt*q)
    {
    int a;
    int k;

    cout << "How much elements are you going to put in? ";
    is >> k;

    for(int i=0; i<k; i++)
    {
    cout << i+1 << ": ";
    is >> a;
    q->PutToken(a);
    }

    return is;
    }

    // QueueInt /////////////////////////////////////////////////////////////////

    class QueueInt: public ListInt
    {
    public:
    int  GetToken();
    void Reverse();

    friend ostream & operator<<(ostream& os, QueueInt*);
    };

    /////////////////////////////////////////////////////////////////////////////

    ostream & operator<<(ostream& os, QueueInt *q)
    {
    List *current = q->back;

    os << "<";

    while (current)
    {
    os << current->Get() << ", ";
    current = current->prev;
    }

    return os << ">" << endl;
    }

    /////////////////////////////////////////////////////////////////////////////

    int QueueInt::GetToken()
    {
    if (token == NULL)
    token = back;

    if(back)
    {
    back = back->prev;
    if(back)
    back->next = NULL;
    else
    front = NULL;

    int retval = token->data;
    delete token;
    token = back;
    return retval;
    }
    else
    return 0;
    }

    /////////////////////////////////////////////////////////////////////////////

    void QueueInt::Reverse()
    {
    List *temp;
    List *current;

    temp = front;
    front = back;
    back = temp;

    current = front;
    while (current)
    {
    temp = current->next;
    current->next = current->prev;
    current->prev = temp;

    current = current->next;
    }
    }

    /////////////////////////////////////////////////////////////////////////////

    int main()
    {
    //clrscr();
    ListInt lst;
    QueueInt och;

    cin >> &lst;
    cout << "List:\n";
    cout << &lst;

    cout << "Queue:\n";
    cin >> &och;
    cout << &och;

    cout << "Reverse queue:" << endl;
    och.Reverse();
    cout << &och;

    getch();
    return 0;
    }
     
Загрузка...
Похожие Темы - Инвертирование очереди
  1. hellsq
    Ответов:
    4
    Просмотров:
    1.189
  2. Мыш
    Ответов:
    10
    Просмотров:
    2.684
  3. lmike
    Ответов:
    0
    Просмотров:
    1.486
Статус темы:
Закрыта.

Поделиться этой страницей