Pomocy! lista pisana wspak

// lab12_zad3_lista.cpp      STRUKTURY DYNAMICZNE : LISTA ( funkcje new, delete)

/******************************************************************/
/* OPIS PROGRAMU :                                                */
/* Program tworzy liste jednokierunkowa bez sortowania elementow. */
/* Element roboczy listy przechowuje wartosc typu calkowitego     */
/* oraz wskaznik na nastepny element.                             */
/* Utowrzona lista jest ukierunkowana "do przodu".                */
/* Program umozliwia rowniez wyswietlenie kolejnych wartosci      */
/* calkowitych znajdujacych sie na liscie oraz usuwanie listy.    */
/******************************************************************/

//POLECENIA:
// 1. Zapoznaj sie z programem i sprawdz jego dzialanie.
// 2. Dopisz 3 funkcje i wlacz je do menu w main() [uzupelnij linie //$$$]:
//
// a. [1 pkt] Wzorujac sie na procedurze:   void Pisz_Liste(INFO *Lista)
//    napisz i wlacz do programu procedure: void Pisz_Parzyste(INFO *Lista) ,
//    ktora wypisuje na ekranie tylko "Wartosci" parzyste z listy.
// b. [2 pkt] Wzorujac sie na procedurze:   void Usun_Liste(INFO *Lista)
//    napisz i wlacz do programu procedure: void Usun_K_z_Listy(INFO *Lista) ,
//    ktora  usuwa tylko K liczb z poczatku listy. Jezeli lista
//    zawiera mniej niz K elementow, to usuwane sa wszystkie. Liczba
//    K jest wczytywana wewnatrz tej procedury.
// c. [3 pkt] Wzorujac sie na przykladzie_2 oraz na procedurze void Pisz_Liste(INFO *Lista)
//     napisz i wlacz do programu procedure rekurencyjna: void Pisz_Wspak(int j,struct El *Biezacy) ,
//     ktora po wywolaniu : Pisz_Wspak(1,Lista->Glowa);
//     wypisuje na ekranie liste od ostatniego do pierwszego elementu   

#include <iostream.h>
#include <conio.h> // funkcja getch()

typedef struct El // struktura elementu roboczego
{ int Wartosc;
    struct El * Nastepny; // wska«nik do nast©pnego elementu
} ELEMENT;
typedef struct // struktura elementu informacyjnego
{ ELEMENT * Glowa;
    ELEMENT * Ogon;
} INFO;

//INFO *Lista;                    // wskaznik do elementu informacyjnego
// dla uproszczenia zadeklarowano go jako zmienna globalna,
//gdyby byl deklarowany w main(), naglowki funkcji musialyby zawierac
// parametr : INFO *Lista
void Pisz_Menu();
void Do_Listy( INFO * Lista, int W );
void Dopisz_K_elem_do_Listy( INFO * Lista );
void Pisz_Liste( INFO * Lista );
void Usun_Liste( INFO * Lista );
void Pisz_Parzyste( INFO * Lista ); //$$$
void Usun_K_z_Listy( INFO * Lista ); //$$$
void Pisz_Wspak( int j, struct El * Biezacy ); //$$$ j- numer biezacego elementu o adresie Biezacy

//=====================================================================
main()
{
    char znak;
    INFO * Lista; // wskaznik do elementu informacyjnego
   
    Lista = new INFO;
    Lista->Glowa = NULL;
    Lista->Ogon = NULL;
   
    do
    { system( "cls" );
        Pisz_Menu();
        znak = getch();
        switch( znak )
        {
        case '1': Dopisz_K_elem_do_Listy( Lista ); break;
        case '2': Pisz_Liste( Lista ); break;
        case '3': Usun_Liste( Lista ); break;
        case '4': Pisz_Parzyste( Lista ); break; //$$$ zdejm komentarz z funkcji
        case '5': Usun_K_z_Listy( Lista ); break; //$$$ ktore dopisales
            /*   case '6': Pisz_Wspak(1,Lista->Glowa);               
                         cout << "Wypisano wspak elementy z listy - nacisnij klawisz\n";
                         getch();
                         break;                                       //$$$
            */
        }
    }
    while( znak != '0' );
    //       koniec programu
    Usun_Liste( Lista );
}

//=========================================================PROCEDURY=====

void Pisz_Menu()
{
    cout << "\n************************************************\n";
    cout << "PRZYKLADOWE OPERACJE NA LISCIE DYNAMICZNEJ\n";
    cout << "1. Dopisz k liczb do listy\n";
    cout << "2. Pokaz cala liste\n";
    cout << "3. Usun cala liste\n";
    cout << "4. Pokaz elementy o wartosciach parzystych\n"; //$$$ po napisaniu danej
    cout << "5. Usun K elementow z listy\n"; //$$$  funkcji usun slowa
    cout << "6. Pokaz liste wspak- do zrobienia\n"; //$$$  "- do zrobienia"
    cout << "0. Zakoncz program\n";
    cout << "************************************************\n";
}

//-------------------------------------------------------------------------
void Do_Listy( INFO * Lista, int W )
/* Procedura dolacza nowy element do listy - na koniec listy */
{
    ELEMENT * Nowy;
    Nowy = new ELEMENT;
    if( Lista->Glowa == NULL ) // dolaczenie nowego elementu
    { // do listy pustej
        Lista->Glowa = Nowy;
        Lista->Ogon = Lista->Glowa;
    }
    else // dolaczenie nowego elementu
    { Lista->Ogon->Nastepny = Nowy; // na koäcu listy niepustej
        Lista->Ogon = Nowy;
    }
    Nowy->Wartosc = W;
    Nowy->Nastepny = NULL;
}

//---------------------------------------------------------------------
void Dopisz_K_elem_do_Listy( INFO * Lista )
/* Procedura dopisuje K elementow na koniec listy */
{
    int i, K, W;
   
    cout << "Ile elementow dopisujemy do listy (podaj K<6): ";
    cin >> K;
    cout << "Wprowadz kolejne elementy listy:\n";
    for( i = 1; i <= K; i++ )
    {
        cout << "element_";
        cout.width( 2 );
        cout << i << " = ";
        cin >> W;
        Do_Listy( Lista, W );
    }
    cout << "Elementy dopisano do listy - nacisnij klawisz\n";
    getch();
}

//------------------------------------------------------------------------
void Pisz_Liste( INFO * Lista )
/*  Procedura wyswietla elementy listy w kierunku od poczatku do konca */
{
    ELEMENT * Biezacy;
    int i = 0;
   
    Biezacy = Lista->Glowa;
    if( Lista->Glowa == NULL )
         cout << "Lista jest pusta\n";
    else while( Biezacy != NULL )
    {
        i++;
        cout << "element_" << i << " : ";
        cout.width( 10 ); cout << Biezacy->Wartosc << endl;
        Biezacy = Biezacy->Nastepny;
    }
    cout << "Wypisano elementy z listy - nacisnij klawisz\n";
    getch();
}

//-------------------------------------------------------------------------
void Usun_Liste( INFO * Lista )
/* procedura usuwa elementy z listy od pierwszego do ostatniego */
{
    int i = 0;
    ELEMENT * Usuniety;
   
    if( Lista->Glowa == NULL )
         cout << "Lista jest pusta - nacisnij klawisz";
    else { while( Lista->Glowa != NULL )
        {
            i++;
            Usuniety = Lista->Glowa;
            Lista->Glowa = Lista->Glowa->Nastepny;
            delete Usuniety;
        }
        if( Lista->Glowa == NULL )
        cout << "\nListe usunieto ( " <<
             i << " element. ) - nacisnij klawisz" << endl;
       
    }
    getch();
}
//=================================================================================================
//------------------------------------------------DOPISZ BRAKUJACE FUNKCJE------------------------


void Pisz_Wspak( int j, struct El * Biezacy )
// funkcja REKURENCYJNA wypisuje wartosci listy wspak,
// gdzie Biezacy -to adres elementu poczartowego o numerze j
{
   
   
   
   
   
   
    // UZUPELNIJ
}
//-------------------------------------------------------------------------
void Usun_K_z_Listy( INFO * Lista )
// funkcja wczytuje liczbe int k i usuwa k pierwszych elementow z listy,
// lecz nie wiecej niz do konca listy
{
    int i = 0;
    ELEMENT * Usuniety;
    int k;
    cout << "Ile elementow usunac ? "; cin >> k;
    for( int j = 0; j < k; j++ )
    {
        i++;
        Usuniety = Lista->Glowa;
        Lista->Glowa = Lista->Glowa->Nastepny;
        delete Usuniety;
        if( Lista->Glowa == NULL ) break;
       
    }
    cout << "\nZ listy usunieto ( " <<
    i << " element. ) - nacisnij klawisz" << endl;
   
    getch();
}
//-------------------------------------------------------------------------
void Pisz_Parzyste( INFO * Lista )
/*  Procedura wyswietla elementy o wartosciach parzystych z listy w kierunku od poczatku do konca */
{
    ELEMENT * Biezacy;
    int i = 0;
    Biezacy = Lista->Glowa;
    if( Lista->Glowa == NULL )
         cout << "Lista jest pusta\n";
    else while( Biezacy != NULL )
    {
        i++;
        if( Biezacy->Wartosc % 2 == 0 ) // dzielimy na 2 jezeli =0 to parzysta
             cout << "element_" << i << " : " << Biezacy->Wartosc << endl;
       
        Biezacy = Biezacy->Nastepny;
    }
    cout << "Wypisano parzyste elementy z listy - nacisnij klawisz\n";
    getch();
}