Форум программистов [Powered by Invision Power Board]

Код


//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "form_main.h"

// одна из последующих трех строк должна быть незакомментирована
#define FIRST            // непараметризованные классы
//#define SECOND            // параметризованные классы
//#define THIRD            // с помощью STL

#ifdef FIRST
#include "list.h"
#endif

#ifdef SECOND
#include "list_template.h"
#endif

#ifdef THIRD
#include "list_stl.h"
#endif

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TMainForm *MainForm;

#ifdef FIRST
list lst;
#endif

#ifdef SECOND
list<int> lst;
#endif

#ifdef THIRD
listSTL<int> lst;
#endif

//---------------------------------------------------------------------------
__fastcall TMainForm::TMainForm(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::FirstBtnClick(TObject *Sender)
{
    lst.first();
    display();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::LastBtnClick(TObject *Sender)
{
    lst.last();
    display();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::PrevBtnClick(TObject *Sender)
{
    lst.prev();
    display();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::NextBtnClick(TObject *Sender)
{
    lst.next();
    display();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::InsertBtnClick(TObject *Sender)
{
    lst.ins();
    display();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::DeleteBtnClick(TObject *Sender)
{
    lst.del();
    display();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::SortBtnClick(TObject *Sender)
{
    lst.sort();
    display();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::ExitBtnClick(TObject *Sender)
{
    Close();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::display(void)
{
    NodesList->Clear();

#ifndef THIRD
    if (lst.getcurr()) {
#endif

#ifdef FIRST
        node* temp = lst.getcurr();
#endif

#ifdef SECOND
        node<int>* temp = lst.getcurr();
#endif

#ifndef THIRD
        int i = 0;
        lst.first();
        while (lst.getcurr()->getnext()) {
            NodesList->Items->Add(AnsiString(*lst.getcurr()->getvalue()));

            if (lst.getcurr() == temp) NodesList->Selected[i] = true;
            i++;

            lst.next();
        }
        NodesList->Items->Add(AnsiString(*lst.getcurr()->getvalue()));
        if (lst.getcurr() == temp) NodesList->Selected[i] = true;

        lst.first();
        while (lst.getcurr() != temp) lst.next();
    }
#endif

#ifdef THIRD
    list<int>::iterator display_iter = lst.lst.begin();
    for (int i = 0; i < lst.lst.size(); i++) {
        NodesList->Items->Add(AnsiString(*display_iter));
        if (lst.iter == display_iter) NodesList->Selected[i] = true;
        display_iter++;
    }
#endif
}
//---------------------------------------------------------------------------

Код


#include <stdlib.h>

// класс элемента двунаправленного списка
template <class T> class node {
private:
    node<T>* _prev;    // ссылка на предыдущий элемент
    node<T>* _next;    // ссылка на следующий элемент
    T* _value;    // ссылка на значение (в данном случае - целое число)

public:
    node(void) { _prev = NULL; _next = NULL; _value = new T; *_value = rand(); }
    ~node(void) { delete _value; }

    void setprev(node<T>* newprev) { _prev = newprev; }
    void setnext(node<T>* newnext) { _next = newnext; }
    void setvalue(T* newvalue) { _value = newvalue; }

    node<T>* getprev(void) { return _prev; }
    node<T>* getnext(void) { return _next; }
    T* getvalue(void) { return _value; }
};

// класс двунаправленного списка
template <class T> class list {
private:
    node<T>* _head;    // ссылка на начальный элемент списка
    node<T>* _tail;    // ссылка на последний элемент списка
    node<T>* _curr;    // ссылка на текущий элемент списка

public:
    list(void) { _head = NULL; _tail = NULL; _curr = NULL; }
    ~list(void) { while (_curr) del(); }

    // функция сдвигает указатель на один элемент ближе к началу
    void prev(void) { if (_curr != _head) _curr = _curr->getprev();    }

    // функция сдвигает указатель на один элемент ближе к концу
    void next(void) { if (_curr != _tail) _curr = _curr->getnext(); }

    // функция устанавливает указатель на начало списка
    void first(void) { _curr = _head; }

    // ... на конец списка
    void last(void) { _curr = _tail; }

    node<T>* getcurr(void) { return _curr; }

    // создает элемент и вставляет его после текущего элемента,
    // если список не был пуст
    void ins(void);

    // удаляет текущий элемент, новым текущим элементом становится
    // предшествующий удаленному, если был удален не первый элемент,
    // в противном случае - последующий элемент
    void del(void);

    // сортирует список по возрастанию значений
    void sort(void);
};


template <class T> void list<T>::ins(void) {
    node<T>* newnode = new node<T>;    // создаем новый элемент списка
    node<T>* prevnode = _curr;        // указатель на элемент, после которого вставляем
    node<T>* nextnode = NULL;        // указатель на элемент, перед которым вставляем

    if (prevnode) nextnode = prevnode->getnext();

    // если вставляем между двумя элементами
    if (prevnode && nextnode) {
        prevnode->setnext(newnode);
        nextnode->setprev(newnode);
        newnode->setprev(prevnode);
        newnode->setnext(nextnode);
    }

    // если вставляем в конец списка
    if (prevnode && !nextnode) {
        prevnode->setnext(newnode);
        newnode->setprev(prevnode);
        _tail = newnode;
    }

    // если вставляем в начало списка
    if (!prevnode && nextnode) {
        nextnode->setprev(newnode);
        newnode->setnext(nextnode);
        _head = newnode;
    }

    // если вставляем в пустой список первый элемент
    if (!prevnode && !nextnode) {
        _head = newnode;
        _tail = newnode;
    }

    // вставленный элемент становится текущим элементом списка
    _curr = newnode;
}

template <class T> void list<T>::del(void) {
    // удаляемый элемент - это текущий элемент
    node<T>* delnode = _curr;

    // если список не пустой
    if (delnode) {
        node<T>* prevnode = delnode->getprev();    // указатель на предыдущий элемент
        node<T>* nextnode = delnode->getnext();    // указатель на следующий элемент

        // если удаляем между двумя элементами
        if (prevnode && nextnode) {
            prevnode->setnext(nextnode);
            nextnode->setprev(prevnode);
            _curr = prevnode;
        }

        // если удаляем из конца списка
        if (prevnode && !nextnode) {
            prevnode->setnext(NULL);
            _curr = prevnode;
            _tail = prevnode;
        }

        // если удаляем из начала списка
        if (!prevnode && nextnode) {
            nextnode->setprev(NULL);
            _curr = nextnode;
            _head = nextnode;
        }

        // если удаляем единственный элемент списка
        if (!prevnode && !nextnode) {
            _curr = NULL;
            _head = NULL;
            _tail = NULL;
        }

        delete delnode;
    }
}

template <class T> void list<T>::sort(void) {
    // если есть хотя бы два элемента в списке
    if (_head != _tail) {
        T* temp;
        first();
        do {
            if (*_curr->getvalue() > *_curr->getnext()->getvalue()) {
                // следующие три строки - обмен указателями на данные между
                // двумя соседними элементами, стоящими не по возрастанию
                temp = _curr->getvalue();
                _curr->setvalue(_curr->getnext()->getvalue());
                _curr->getnext()->setvalue(temp);
                first();
            } else next();
        } while (_curr != _tail);
    }
    // после сортировки списка текущим элементом становится последний элемент
}

Код


#include <stdlib.h>
#include <list.h>

// класс двунаправленного списка на основе STL
template <class T> class listSTL {
public:
    list<T> lst;                // список STL
    list<T>::iterator iter;        // итератор этого списка

    listSTL(void) { iter = lst.begin(); }

    // функция сдвигает указатель на один элемент ближе к началу
    void prev(void) { if (iter != lst.begin()) iter--; }

    // функция сдвигает указатель на один элемент ближе к концу
    void next(void) { if (iter != --lst.end()) iter++; }

    // функция устанавливает указатель на начало списка
    void first(void) { iter = lst.begin(); }

    // ... на конец списка
    void last(void) { iter = --lst.end(); }

    // создает элемент и вставляет его после текущего элемента,
    // если список не был пуст, текущим становится новый элемент
    void ins(void);

    // удаляет текущий элемент, новым текущим элементом становится
    // предшествующий удаленному, если был удален не первый элемент,
    // в противном случае - последующий элемент
    void del(void);

    // сортирует список по возрастанию значений
    void sort(void);
};


template <class T> void listSTL<T>::ins(void) {
    lst.insert(++iter, rand());
    iter--;
}

template <class T> void listSTL<T>::del(void) {
    if (lst.size()) lst.erase(iter--);
    if (iter == lst.end()) iter = lst.begin();
}

template <class T> void listSTL<T>::sort(void) {
    lst.sort();
}

Код


#include <stdlib.h>

// класс элемента двунаправленного списка
template <class T> class node {
private:
    node<T>* _prev;    // ссылка на предыдущий элемент
    node<T>* _next;    // ссылка на следующий элемент
    T* _value;    // ссылка на значение (в данном случае - целое число)

public:
    node(void) { _prev = NULL; _next = NULL; _value = new T; *_value = rand(); }
    ~node(void) { delete _value; }

    void setprev(node<T>* newprev) { _prev = newprev; }
    void setnext(node<T>* newnext) { _next = newnext; }
    void setvalue(T* newvalue) { _value = newvalue; }

    node<T>* getprev(void) { return _prev; }
    node<T>* getnext(void) { return _next; }
    T* getvalue(void) { return _value; }
};

// класс двунаправленного списка
template <class T> class list {
private:
    node<T>* _head;    // ссылка на начальный элемент списка
    node<T>* _tail;    // ссылка на последний элемент списка
    node<T>* _curr;    // ссылка на текущий элемент списка

public:
    list(void) { _head = NULL; _tail = NULL; _curr = NULL; }
    ~list(void) { while (_curr) del(); }

    // функция сдвигает указатель на один элемент ближе к началу
    void prev(void) { if (_curr != _head) _curr = _curr->getprev();    }

    // функция сдвигает указатель на один элемент ближе к концу
    void next(void) { if (_curr != _tail) _curr = _curr->getnext(); }

    // функция устанавливает указатель на начало списка
    void first(void) { _curr = _head; }

    // ... на конец списка
    void last(void) { _curr = _tail; }

    node<T>* getcurr(void) { return _curr; }

    // создает элемент и вставляет его после текущего элемента,
    // если список не был пуст
    void ins(void);

    // удаляет текущий элемент, новым текущим элементом становится
    // предшествующий удаленному, если был удален не первый элемент,
    // в противном случае - последующий элемент
    void del(void);

    // сортирует список по возрастанию значений
    void sort(void);
};


template <class T> void list<T>::ins(void) {
    node<T>* newnode = new node<T>;    // создаем новый элемент списка
    node<T>* prevnode = _curr;        // указатель на элемент, после которого вставляем
    node<T>* nextnode = NULL;        // указатель на элемент, перед которым вставляем

    if (prevnode) nextnode = prevnode->getnext();

    // если вставляем между двумя элементами
    if (prevnode && nextnode) {
        prevnode->setnext(newnode);
        nextnode->setprev(newnode);
        newnode->setprev(prevnode);
        newnode->setnext(nextnode);
    }

    // если вставляем в конец списка
    if (prevnode && !nextnode) {
        prevnode->setnext(newnode);
        newnode->setprev(prevnode);
        _tail = newnode;
    }

    // если вставляем в начало списка
    if (!prevnode && nextnode) {
        nextnode->setprev(newnode);
        newnode->setnext(nextnode);
        _head = newnode;
    }

    // если вставляем в пустой список первый элемент
    if (!prevnode && !nextnode) {
        _head = newnode;
        _tail = newnode;
    }

    // вставленный элемент становится текущим элементом списка
    _curr = newnode;
}

template <class T> void list<T>::del(void) {
    // удаляемый элемент - это текущий элемент
    node<T>* delnode = _curr;

    // если список не пустой
    if (delnode) {
        node<T>* prevnode = delnode->getprev();    // указатель на предыдущий элемент
        node<T>* nextnode = delnode->getnext();    // указатель на следующий элемент

        // если удаляем между двумя элементами
        if (prevnode && nextnode) {
            prevnode->setnext(nextnode);
            nextnode->setprev(prevnode);
            _curr = prevnode;
        }

        // если удаляем из конца списка
        if (prevnode && !nextnode) {
            prevnode->setnext(NULL);
            _curr = prevnode;
            _tail = prevnode;
        }

        // если удаляем из начала списка
        if (!prevnode && nextnode) {
            nextnode->setprev(NULL);
            _curr = nextnode;
            _head = nextnode;
        }

        // если удаляем единственный элемент списка
        if (!prevnode && !nextnode) {
            _curr = NULL;
            _head = NULL;
            _tail = NULL;
        }

        delete delnode;
    }
}

template <class T> void list<T>::sort(void) {
    // если есть хотя бы два элемента в списке
    if (_head != _tail) {
        T* temp;
        first();
        do {
            if (*_curr->getvalue() > *_curr->getnext()->getvalue()) {
                // следующие три строки - обмен указателями на данные между
                // двумя соседними элементами, стоящими не по возрастанию
                temp = _curr->getvalue();
                _curr->setvalue(_curr->getnext()->getvalue());
                _curr->getnext()->setvalue(temp);
                first();
            } else next();
        } while (_curr != _tail);
    }
    // после сортировки списка текущим элементом становится последний элемент
}

Код


#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>

//---------------------------------------------------------------------------
class TMainForm : public TForm
{
__published:    // IDE-managed Components
    TButton *FirstBtn;
    TButton *PrevBtn;
    TButton *NextBtn;
    TButton *LastBtn;
    TButton *InsertBtn;
    TButton *DeleteBtn;
    TButton *SortBtn;
    TListBox *NodesList;
    TButton *ExitBtn;
    void __fastcall FirstBtnClick(TObject *Sender);
    void __fastcall LastBtnClick(TObject *Sender);
    void __fastcall PrevBtnClick(TObject *Sender);
    void __fastcall NextBtnClick(TObject *Sender);
    void __fastcall InsertBtnClick(TObject *Sender);
    void __fastcall DeleteBtnClick(TObject *Sender);
    void __fastcall SortBtnClick(TObject *Sender);
    void __fastcall ExitBtnClick(TObject *Sender);
private:    // User declarations
public:        // User declarations
    __fastcall TMainForm(TComponent* Owner);

    void __fastcall display(void);

};
//---------------------------------------------------------------------------
extern PACKAGE TMainForm *MainForm;
//---------------------------------------------------------------------------
#endif