Немного о списках

#include <iostream>
#include <list>
using namespace std;
 
template <typename T>
struct MyList : std::list<T>
{
    using list<T>::list;
};
 
int main()
{
    MyList<int> lst{ 1, 2, 3 };
 
    for (auto const& i : lst)
        cout << i << endl;
 
    system("pause");
}

#pragma once
 
#include <iostream>
 
 
// Узел списка
template <typename T>
struct Node
{
    T         m_value;
    Node    * m_prev;
    Node    * m_next;
 
    Node(T value=T());
};
 
 
// Список
template <typename T>
class List
{
private:
    Node<T> * m_head;
    Node<T> * m_tail;
 
public:
    List();
    ~List();
    
    void PushFront(T value);
    void PushBack(T value);
 
    bool PopFront();
    bool PopBack();
 
    void Clear();
 
    void Print() const;
};
 
 
// ============================================================================
// Node
 
template<typename T>
Node<T>::Node(T value)
{
    m_value = value;
    m_prev = m_next = NULL;
}
 
// Node
// ============================================================================
 
 
 
// ============================================================================
// List
 
template <typename T>
List<T>::List()
{
    m_head = m_tail = NULL;
}
 
 
template<typename T>
List<T>::~List()
{
    Clear();
}
 
 
template<typename T>
void List<T>::PushFront(T value)
{
    if (!m_head)
    {
        m_head = new Node<T>(value);
        m_tail = m_head;
    }
    else
    {
        m_head->m_prev = new Node<T>(value);
        
        m_head->m_prev->m_next = m_head;
 
        m_head = m_head->m_prev;
    }
}
 
 
template<typename T>
void List<T>::PushBack(T value)
{
    if (!m_tail)
    {
        m_tail = new Node<T>(value);
        m_head = m_tail;
    }
    else
    {
        m_tail->m_next = new Node<T>(value);
 
        m_tail->m_next->m_prev = m_tail;
 
        m_tail = m_tail->m_next;
    }
}
 
 
template<typename T>
bool List<T>::PopFront()
{
    if (!m_head)
    {
        return false;
    }
    else
    {
        if (m_head->m_next)
        {
            m_head = m_head->m_next;
            delete m_head->m_prev;
            m_head->m_prev = NULL;
        }
        else
        {
            delete m_head;
            m_head = NULL;
        }
 
        return true;
    }
}
 
 
template<typename T>
bool List<T>::PopBack()
{
    if (!m_tail)
    {
        return false;
    }
    else
    {
        if (m_tail->m_prev)
        {
            m_tail = m_tail->m_prev;
            delete m_tail->m_next;
            m_tail->m_next = NULL;
        }
        else
        {
            delete m_tail;
            m_tail = NULL;
        }
 
        return true;
    }
}
 
 
template<typename T>
void List<T>::Clear()
{
    while ( PopFront() )
        ;
}
 
 
template<typename T>
void List<T>::Print() const
{
    const Node<T>   * node = m_head;
 
    while (node)
    {
        std::cout << node->m_value << ' ';
        node = node->m_next;
    }
 
    std::cout << std::endl;
}
 
// List
// ============================================================================

#include <iostream>
#include "Include\List.h"
 
 
// ================================================================================================
int main()
{
    List<char>      charList;
    charList.PushBack('a');
    charList.PushBack('b');
    charList.PushBack('c');     // charList: 'a', 'b', 'c'
    charList.Print();
    charList.Clear();
 
    List<int>       intList;
    intList.PushFront(1);
    intList.PushFront(2);
    intList.PushFront(3);       // intList: 3, 2, 1
    intList.Print();
    intList.Clear();
 
    List<double>    doubleList;
    doubleList.PushBack(1.1);
    doubleList.PushFront(2.2);
    doubleList.PushBack(3.3);   // doubleList: 2.2, 1.1, 3.3
    doubleList.Print();
    doubleList.Clear();
 
    system("pause");
    return 0;
}
// ================================================================================================

#include <conio.h>
#include <iostream.h>
 
struct element //Структура с инфополями и адресным полем
{
 int x; //Инфополе. значения из x будут передаваться в список
 element *Next; //Адресное поле
};
 
class List //Класс Список
{
 element *Head; //Указатель на последний активный элемент или просто голова списка
 public:
  List() {Head=NULL;} //Конструктор и инициализация указателя пустым значением
 ~List(); //Деструктор. Далее он вынесен за класс
 void Add(int x); //Функция для добавления значений в список
 void Show(); //Функция для отображения списка на экране
};
 
List::~List() //Деструктор вынесен за класс
{
    while (Head!=NULL)  //Пока по адресу не пусто 
     {    
        element *temp=Head->Next; //Временная переменная для хранения адреса следующего элемента
        delete Head; //Освобождаем адрес обозначающий начало
        Head=temp; //Меняем адрес на следующий
     }
}
 
void List::Add(int x) //Функция добавления элементов в список
{
 element *temp=new element; //При каждом вызове выделяется память
temp->x=x; //Записываем x в элемент структуры  element (в x структуры element)
temp->Next=Head; //Указываем, что след. элемент это объект по адресу Head
Head=temp; //Указываем, что последний активный элемент это только что введенный
}
 
void List::Show() //Функция отображения списка на экране
{
 element *temp=Head; //Определяем указатель, который изначально он равен адресу начала списка
 
 while (temp!=NULL) //До тех пор пока не встретит пустое значение
 {
  cout<<temp->x<<" "; //Выведет элемент x из списка
  temp=temp->Next; //Указываем, что далее нам нужен следующий элемент
 }
}
 
void main()
{
 clrscr();
  int N; //Число элементов в список
  int x; //Элементы вводимые в список
  List lst; //Переменная, тип которой список
 
   cout<<"N = ";cin>>N; //Указали сколько элементов вводить в список
 
for (int i=0;i<N;i++)
 {
  cout<<i+1<<". x = "; cin>>x; //Ввод x с клавиатуры
  lst.Add(x); //Добавление элемента в список
 }
 
lst.Show(); //Вывод списка на экран
 getch();
}

#include <iostream>
using std::cin;
using std::cout;
 
class List
{
    List *Next;
    List *Head;
    int x;
 
public:
    void addList(int);
    List();
    //~List();
    void Show();
};
 
List::List()
{
    Next = NULL;
    Head = NULL;
}
 
void List::addList(int n)
{
    List *tmp = new List;
    tmp -> x = n;
    tmp -> Next = Head;
    Head = tmp;
}
 
void List::Show()
{
    List *tmp = Head;
    while(tmp != NULL)
    {
        cout << tmp -> x << ' ';
        tmp = tmp -> Next;
    }
}
 
int main()
{
    List l;
    l.addList(1);
    l.addList(2);
    l.addList(3);
    l.Show();
    return 0;
}

#include <iostream>
using std::cin;
using std::cout;
 
template<typename T>
struct NODE
{
    NODE *Next;
    T x;
};
 
template<typename T>
class List
{
    NODE<T> *Head;
    int size;
 
public:
    void addList(T);
    List();
    ~List();
    void Show();
    void Delete(int);
};
 
template<typename T>
void List<T>::Delete(int n)
{
    NODE<T> *p = Head;
    int k = 1;
    if(n == 1)
    {
        NODE<T> *tmp;
        tmp = Head;
        Head = p -> Next;
        delete tmp;
        return;
    }
 
    if(n == size)
    {
        while(k < n - 1)
        {
            p = p -> Next;
            k++;
        }
        p -> Next = NULL;
        return;
    }
 
    while(k < n - 1 && k < size)
    {
        //cout << p -> x << ' ';
        p = p -> Next;
        k++;
    }
    //cout << k << std::endl;
    //cout << p -> x << ' ';
    p -> Next = p -> Next -> Next;
    size--;
}
 
template<typename T>
List<T>::List()
{
    Head = NULL;
    size = 0;
}
 
template<typename T>
void List<T>::addList(T n)
{
    NODE<T> *tmp = new NODE<T>;
    tmp -> x = n;
    tmp -> Next = Head;
    Head = tmp;
    size++;
}
 
template<typename T>
void List<T>::Show()
{
    NODE<T> *tmp = Head;
 
    while(tmp != NULL)
    {
        cout << tmp -> x << ' ';
        tmp = tmp -> Next;
    }
}
 
template<typename T>
List<T>::~List()
{
    NODE<T> *tmp;
    while(Head != NULL)
    {
        tmp = Head -> Next;
        delete Head;
        Head = tmp;
    }
}
 
int main()
{
    List<int> l;
    for(int i = 10; i >= 1; --i) l.addList(i);
 
    //l.Delete(10);
    l.Show();
    return 0;
}

template<typename T>
struct Node
{
        T x;
        int index;
        Node *Next;
        Node *Prev;
};
 
template<typename T>
class List
{
        Node<T> *Head;
        Node<T> *Tail;
        int size;
 
public:
        List();
        ~List();
        void PushFront(T);
        void PushBack(T);
        void Delete(int);
        void ShowBack(TStrings*);
        void ShowFront(TStrings*);
        void ShowElement(int, TStrings*);
        void ReIndex();
        int ShowCount();
        void Sort();
        T& operator[](int);
        void ClearList();
};
 
template<typename T>
void List<T>::ClearList()
{
        Node<T> *tmp;
        while(Head != NULL)
        {
            tmp = Head -> Next;
            delete Head;
            Head = tmp;
        }
 
        Head = NULL;
        size = 0;
}
 
template<typename T>
void List<T>::ShowElement(int i, TStrings *s)
{
        Node<T> *tmp = Head;
        s -> Add("Íàéäåííûé ìàññèâ:");
        String s1, s2;
        while(tmp -> Next && tmp -> index != i)
        {
                tmp = tmp -> Next;
        }
        s1 = tmp -> index;
        s2 = tmp -> x;
        s -> Add("mas[" + s1 + "] = " + s2);
}
 
template <typename T>
T& List<T>::operator[](int i)
{
        Node<T> *p = Head;
        while(p != NULL && p -> index != i)
        {
                p = p -> Next;
        }
 
        return p -> x;
}
 
template<typename T>
void List<T>::ReIndex()
{
        int k = 1;
        Node<T> *p = Head;
        while(p != NULL)
        {
                p -> index = k++;
                p = p -> Next;
        }
}
 
template<typename T>
void List<T>::Sort()
{
        Node<T> *tmp;
        int n = 0, m;
        T swap;
        int iswap;
        while(true)
        {
                m = 0;
                tmp = Head;
                while(true)
                {
                        if(tmp -> x > tmp -> Next -> x)
                        {
                                swap = tmp -> x;
                                tmp -> x = tmp -> Next -> x;
                                tmp -> Next -> x = swap;
 
                                iswap = tmp -> index;
                                tmp -> index = tmp -> Next -> index;
                                tmp -> Next -> index = iswap;
                        }
                        tmp = tmp -> Next;
                        m++;
                        if(m == size - 1) break;
                }
                n++;
                if(n == size - 1) break;
        }
}
 
template<typename T>
int List<T>::ShowCount()
{
        return size;
}
 
template<typename T>
List<T>::List()
{
        size = 0;
        Head = Tail = NULL;
}
 
template<typename T>
List<T>::~List()
{
        Node<T> *tmp;
        while(Head != NULL)
        {
            tmp = Head -> Next;
            delete Head;
            Head = tmp;
        }
}
 
 
template<typename T>
void List<T>::PushFront(T n)
{
        Node<T> *p = new Node<T>;
        if(Head == NULL)
        {
                Head = Tail = p;
                p -> x = n;
                p -> Next = NULL;
                p -> Prev = NULL;
                ReIndex();
                size++;
                return;
        }
 
        Node<T> *q = Head;
        /*while(q -> Prev != NULL)
        {
                q = q -> Prev;
        }*/
 
        q -> Prev = p;
        p -> x = n;
        p -> Prev = NULL;
        p -> Next = q;
        Head = p;
        ReIndex();
        size++;
}
 
 
template<typename T>
void List<T>::PushBack(T n)
{
        Node<T> *p = new Node<T>;
        if(Tail == NULL)
        {
                Head = Tail = p;
                p -> x = n;
                p -> Next = NULL;
                p -> Prev = NULL;
                ReIndex();
                size++;
                return;
        }
 
        Node<T> *q = Tail;
        /*while(q -> Next != NULL)
        {
                q = q -> Next;
        }*/
 
        q -> Next = p;
        p -> x = n;
        p -> Next = NULL;
        p -> Prev = q;
        Tail = p;
        ReIndex();
        size++;
}
 
 
template<typename T>
void List<T>::ShowBack(TStrings *s)
{
        Node<T> *p;
        String s1, s2;
        p = Tail;
        s -> Add("Ìàññèâ:");
        while(p != NULL)
        {
            s1 = p -> index;
            s2 = p -> x;
            s -> Add("mas[" + s1 + "] = " + s2);
            p = p -> Prev;
        }
}
 
template<typename T>
void List<T>::ShowFront(TStrings *s)
{
        Node<T> *p;
        String s1, s2;
        p = Head;
        s -> Add("Ìàññèâ:");
        while(p != NULL)
        {
            s1 = p -> index;
            s2 = p -> x;
            s -> Add("mas[" + s1 + "] = " + s2);
            p = p -> Next;
        }
}
 
template<typename T>
void List<T>::Delete(int n)
{
    Node<T> *p = Head;
    int k = 1;
    if(n == 1)
    {
        Node<T> *tmp;
        tmp = Head;
        Head = p -> Next;
        delete tmp;
        size--;
        //ReIndex();
        return;
    }
 
    if(n == size)
    {
        while(k < n - 1)
        {
            p = p -> Next;
            k++;
        }
        p -> Next = NULL;
        size--;
        //ReIndex();
        return;
    }
 
    while(k < n - 1 && k < size)
    {
        //cout << p -> x << ' ';
        p = p -> Next;
        k++;
    }
    //cout << k << std::endl;
    //cout << p -> x << ' ';
    p -> Next = p -> Next -> Next;
    //ReIndex();
    size--;
    return;
}