lab0 double_connected lists ver 4.0

#include <iostream>
#include <ostream>
#include <fstream>
#include <string>

using namespace std;

template <typename TElement> struct Node //узел
{
    TElement value;
    Node<TElement>* next;
    Node<TElement>* prev;//Указатели на адреса следующего и предыдущего элементов списка
};

template <typename TElement> class ListSequence {
private:
    int Length;
    Node<TElement>* head;
    Node<TElement>* tail;
public:
    void Init() {
        head = NULL;
        tail = NULL;
        Length = 0;
    }

    void Append(TElement item) {
        struct Node<TElement>* temp;
        temp = (struct Node<TElement>*)malloc(sizeof(Node<TElement>));
        temp->value = item;
        if (head == NULL) { //если список пустой
            head = temp;
            tail = temp;
            head->prev = NULL;
            tail->next = NULL;
            Length = 1;
        }
        else { //список не пустой
            temp->prev = tail;
            tail->next = temp;
            tail = temp;
            tail->next = NULL;
            Length += 1;
        }
    }

    void Prepend(TElement item) {
        struct Node<TElement>* temp;
        temp = (struct Node<TElement>*)malloc(sizeof(Node<TElement>));
        temp->prev = NULL;
        temp->value = item;
        if (head == NULL) { //если список пустой
            head = temp;
            tail = temp;
            temp->next = NULL;
            Length = 1;
        }
        else { //список не пустой
            temp->next = head;
            head = temp;
            Length += 1;
        }
    }

    void InsertAt(int index, TElement item) {
        if (index == 1) return Prepend(item);
        if (index == Length + 1) return Append(item);
        if (index < 1 || index > Length + 1)
            cout << "This index out of length" << endl;
        else {
            struct Node<TElement>* temp;
            struct Node<TElement>* p;
            temp = (struct Node<TElement>*)malloc(sizeof(Node));
            int i;
            p = head;
            cout << p->value << endl;
            for (i = 1; i < index; i++) {
                p = p->next;
                cout << p->value << endl;
            }
            temp->value = item;
            temp->prev = p->prev;
            temp->next = p;
            p=p->prev;
            p->next = temp;
            p = temp->next;
            p->prev = temp;
            Length += 1;
        }
    }

    int getLength() {
        cout << "Lenght of sequence: ";
        cout << Length << endl;
        return Length;
    }

    int getIsEmpty() {
        if (Length == 0) {
            cout << "Sequence is empty" << endl;
            return 1;
        }
        else {
            cout << "Sequence isn't empty" << endl;
            return -1;
        }
    }

    TElement Get(TElement index) {
        if ((Length <= index) || (index < 0)) {
            cout << "Element with index " << index << " didn't find" << endl;
            return -1;
        }
        else {
            int i;
            Node<TElement>* temp;
            temp = head;
            for (i = 0; i < index; i++) {
                temp = temp->next;
            }
            cout << "Element with index " << index << ": ";
            cout << temp->value << endl;
            return temp->value;
        }
    }

    TElement GetFirst() {
        cout << "First element. ";
        return Get(0);
    }

    TElement GetLast() {
        cout << "Last element. ";
        return Get(Length - 1);
    }

    void Remove(TElement item) {
        int i;
        Node* p = head;
        Node* p2 = head;
        if (head->value == item) {
            RemoveFirst();
            Length -= 1;
        }
        else {
            for (i = 1; i < Length; i++) {
                if ((p->next->value == item) && (p->next->next != NULL)) {
                    Length -= 1;
                    p->next = p->next->next;
                    p = p->next;
                    p->prev = p2;
                    break;
                }
                if ((p->next->value == item) && (p->next->next == NULL)) {
                    RemoveLast();
                    break;
                }
                p = p->next;
                p2 = p2->next;
            }
        }
    }

    void RemoveFirst() {
        if (head == tail) {
            head = NULL;
            tail = NULL;
        }
        else {
            Node* q = head;
            head = q->next;
            q->next->prev = head;
        }
    }

    void RemoveLast() {
        Node* l = tail;
        tail = l->prev;
        l->prev->next = tail;
        tail->next = NULL;
    }

    ListSequence GetSubsequence(int startIndex, int endIndex) {
        ListSequence B;
        B.Init();
        Node<TElement>* p = head;
        if ((startIndex < 0) || (endIndex < 0) || (endIndex < startIndex) || (endIndex >= Length)) {
            cout << "Error with index" << endl;
        }
        else {
            for (int i = 0; i < startIndex; i++) {
                p = p->next;
            }
            for (int j = startIndex; j <= endIndex; j++) {
                B.Append(p->value);
                p = p->next;
            }
        }
        return B;
    }

    void Show() {
        Node<TElement>* temp = head;
        while (temp != NULL) {
            cout << temp->value << " ";
            temp = temp->next;
        }
        cout << endl;
    }
};



/*наследование
виртуальный метод
*/

int main() {
    ListSequence<char> A1;
    A1.Init();
    A1.Append('a');
    A1.Append('b');
    A1.Show();
    A1.getLength();

    cout << endl;
    cout << endl;
    ListSequence<int> A;
    A.Init();
    A.getIsEmpty();
    A.getLength();
    cout << endl;
    A.Append(23);
    A.getLength();
    A.GetFirst();
    A.GetLast();
    A.Get(0);
    A.Get(-1);
    A.Get(1);
    cout << endl;
    A.Append(43);
    A.Show();
    A.getLength();
    A.GetFirst();
    A.GetLast();
    A.Get(0);
    A.Get(1);
    A.Get(-1);
    A.Get(2);
    cout << endl;
    A.Prepend(53);
    A.getLength();
    A.GetFirst();
    A.GetLast();
    A.Get(0);
    A.Get(1);
    A.Get(-1);
    A.Get(3);
    cout << endl;
    ListSequence<int> A2;
    A2 = A.GetSubsequence(1, 1);
    A2.getLength();
    A2.GetFirst();
    A2.GetLast();

    return 0;
}