Lista Dwukierunkowa

#include <iostream>
#include <time.h>
#include <stdio.h>

struct element {
int data;
element* next;
element* prev;
};

struct dlist {
element* head;
element* tail;
int el_count;
};

dlist create_empty_dlist();
element* create_element(int n_d);
void add_tail(int n_d, dlist &dl);
void add_head(int n_d, dlist &dl);
void add_position(int n_d, dlist &dl, int posit);
void delete_head(dlist &dl);
void delete_tail(dlist &dl);
void delete_position(dlist &dl, int posit);
void show_list(dlist dl);
void delete_list(dlist &dl);
void show_reversed(dlist dl);


using namespace std;

int main()
{
    dlist dl = create_empty_dlist();
    int wybor, posit;
    cout << "Podaj pozycje:" << endl;
    cin >> posit;
    srand(time(NULL));
    do{
        cout << "Co chcesz zrobic?" << endl;
        cout << "1. Dodac element na koniec listy" << endl;
        cout << "2. Dodac element na poczatek listy" << endl;
        cout << "3. Dodac element na pozycje" << endl;
        cout << "4. Usunac z konca" << endl;
        cout << "5. Usunac z poczatku" << endl;
        cout << "6. Usunac z pozycji" << endl;
        cout << "7. Usunac calosc" << endl;
        cout << "8. Wyswietlic calosc" << endl;
        cout << "9. Wyswietlic calosc od konca" << endl;
        cout << "10. Juz nic nie chcesz" << endl;
        cin >> wybor;
        switch(wybor){
    case 1: add_tail( rand(),dl); break;
    case 2: add_head( rand(),dl); break;
    case 3: add_position( rand(), dl, posit); break;
    case 4: delete_tail(dl); break;
    case 5: delete_head(dl); break;
    case 6: delete_position(dl, posit); break;
    case 7: delete_list(dl); break;
    case 8: show_list(dl); break;
    case 9: show_reversed(dl); break;
    case 10: cout << " Zakonczyles program";  break;
    default : cout <<" Zly numer, sprobuj jeszcze raz" << endl;
        }

    }
    while (wybor != 10);
    return 0;
}

dlist create_empty_dlist(){
dlist dl;
dl.head = nullptr;
dl.tail = nullptr;
dl.el_count = 0;
return dl;
}

element* create_element(int n_d){ // nie dodaje, tworzy element
element* n_e = new element;
n_e -> data = n_d;
n_e -> next = nullptr;
n_e -> prev = nullptr;
return n_e;
}

void add_tail(int n_d, dlist &dl){
element* n_e = create_element(n_d);
cout << "Numer ktory zostanie dodany: " << n_d << endl;
if (dl.el_count == 0)
    dl.head = n_e;
else{
    dl.tail -> next = n_e;
    n_e -> prev = dl.tail;
    }
dl.tail = n_e;
dl.el_count ++;
}

void add_head(int n_d, dlist &dl){
element* n_e = create_element(n_d);
cout << "Numer ktory zostanie dodany: " << n_d << endl;
if (dl.el_count == 0)
    dl.tail = n_e;
else{
    dl.head -> prev = n_e;
    n_e -> next = dl.head;
    }
dl.head = n_e;
dl.el_count ++;
}

element* find_position(dlist dl, int posit){

if (posit < 0 or posit > dl.el_count-1)
    return nullptr;

element* temp = dl.head;
for (int i =0; i < posit; i++)
    temp = temp -> next;
return temp;
}

void add_position(int n_d, dlist &dl, int posit){
cout << "Numer ktory zostanie dodany: " << n_d << endl;
if (posit < 1 or posit > dl.el_count){
    cout << " Niewlasciwa pozycja" << endl;
    return;
}
if (posit == 1)
    {
    add_head(n_d, dl);
    return;
    }
if( posit == dl.el_count)
    {
    add_tail(n_d, dl);
    return;
    }
element* temp = dl.head;
for(int i=0; i < posit -1; i++)
    temp = temp -> next;
element* n_e = new element;
n_e -> data = n_d;
n_e -> next = temp -> next;
temp -> next = n_e;
dl.el_count ++;
}

void delete_head(dlist &dl){
if (dl.el_count == 0)
    {
    cout << "Dwulista jest pusta" << endl;
    return;
    }
else{
element* temp = dl.head;
if(dl.el_count == 1)
    {
    dl.head = nullptr;
    dl.tail = nullptr;
    }
else
    {
    dl.head = dl.head -> next;
    dl.head -> prev = nullptr;
    }
delete temp;
dl.el_count --;
}
}

void delete_tail(dlist &dl){

if (dl.el_count == 0)
    {
    cout << " Dwulista jest pusta " << endl;
    return;
    }
else{
element* temp = dl.tail;
if (dl.el_count == 1)
    {
    dl.tail = nullptr;
    dl.head = nullptr;
    }
else
    {
    dl.tail = dl.tail -> prev;
    dl.tail -> next = nullptr;
    }
delete temp;
dl.el_count --;
}
}

void delete_position(dlist &dl, int posit){
if (posit < 1 or posit > dl.el_count)
        {
            cout << "Podano niewlasciwa pozycje" << endl;
        return;
        }
if (posit == 1)
    {
    delete_head(dl);
    return;
    }
if(posit == dl.el_count)
    {
    delete_tail(dl);
    return;
    }
element* temp = dl.head;
for (int i =1; i< posit -1; i++)
    {
    temp = temp -> next;
    }
element* temp_delete = temp -> next;
temp -> next = temp_delete -> next;
delete temp_delete;
dl.el_count --;
}

void show_list(dlist dl){
    element* temp = dl.head;
while (temp)
    {
    cout << temp -> data << endl;
    temp = temp -> next;
    dl.el_count --;
    }
}

void delete_list(dlist &dl){
while(dl.head != nullptr){
    delete_head(dl);
}
cout << "Lista zostala usunieta" << endl;
}

void show_reversed(dlist dl){
    element* temp = dl.tail;
while (temp)
    {
    cout << temp -> data << endl;
    temp = temp -> prev;
    dl.el_count --;
    }
}