Finally, am reusit sa termin si lectia despre liste ( O parte din ea )
In primul rand vom defini conceptul de lista.(apoi ne vom lungi cu niste teorie si exemple de cod)

  Lista = secventa de elemente de acelasi tip.
   
  Nota : chiar daca o lista nu are nici un element, tot lista se considera. Doar ca se va numi lista vida

  Sper ca ati citit macar lectiile nr. 6 si 9, fiindca listele sunt in legatura directa cu pointeri si structuri(veti vedea in continuare).

Partea teoretica

in C, o lista este tot o colectie, exact ca si structura. Dar exista o singura diferenta intre cele doua. Lista, spre deosebire de structura,este flexibila. Se poate micsora/creste,ocupa doar spatiul necesar in memorie (tipurile alocate static ocupa memorie chiar daca nu sunt folosite) si pot fi supuse unor operatii mai complexe( nu doar accesare si manipulare a elementelor unei liste).

Operatiile de baza pentru o lista sunt urmatoarele :
   * inserarea unui element in lista
   * stergerea unui element din lista
   * repozitionarea unui element in lista
   
La cerere, voi adauga la lectie si exemple de cod in care se fac operatii asupra listelor de fiecare tip(simpla,dubla,circulara). Deocamdata este doar un exemplu de cod la sfarsitul lectiei . Iar daca nimeni nu vrea noi exemple de cod, tot voi adauga doar ca nu am asa mult timp saptamanile acestea 

*************************************************************************************************************************************

Partea practica

La aceasta parte vreau sa acopar urmatoarele idei :
   * Lista simpla inlantuita
   * Lista dubla inlantuita
   * Lista circulara

Dupa cum am spus mai sus, listele sunt structuri flexibile. Flexibilitatea datelor este reprezentata de modul in care sunt alocate in memorie : static sau dinamic .
   
  a) Alocare statica
         
       - reprezinta orice declaratie normala de variabile .

       Exemplu
           

int a;
char x;
// etc...

b) Alocare dinamica
       - toate datele alocate dinamic sunt puse in Heap , nu pe stack sau pe segment.     
       - alocarea dinamica a datelor se face prin cuvantul cheie new
       - eliberarea memoriei(stergerea datelor alocate dinamic) se face prin cuvantul cheie delete
       - cand lucram cu liste, de fapt lucram cu pointeri spre anumite structuri   
       
     Forma generala

nume_tip *nume_pointer = new <dimensiune> nume_tip ;
     delete nume_pointer ;

Exemplu
     

...
       int main() {
          int *p;
          int *p= new int;  // in acest fel se aloca dinamic memorie pentru o valoare de tip int
          *p = 5 ;          //incarcam o valoare la adresa indicata de pointer
          printf("%d\n",*p) ; // afisam valoarea retinuta la adresa respectiva
        delete p;           // eliberam memoria mai sus alocata:)

Ok. am acoperit basic-ul despre alocarea dinamica.
  Acum sa trecem la liste

Liste

  Definitie
       
      - este o colectie de structuri alocate dinamic

   a) Lista simpla inlantuita
         - fiecare element( structura ) contine un pointer care indica spre urmatorul element
   b) Lista dubla inlantuita
         - fiecare element( structura ) contine 2 pointeri, fiecare indicand unul din elementele vecine.
   c) Lista circulara
         - lista simpla inlantuita la care pointer-ul din ultimul element indica spre primul element din lista

   Forma generala a unui element

   a) Lista simpla inlantuita si lista circulara
     

struct nume_structura {
           nume_tip1 nume_var1;
           //...................
           nume_tipN nume_varN;
           nume_structura *nume_pointer; // pointer de tip nume_structura care va indica spre urmatorul element
           };

b) Lista dublu inlantuita
       

struct nume_structura {
           nume_tip1 nume_var1;
           //...................
           nume_tipN nume_varN;
           nume_structura *nume_pointer1; // pointeri care indica spre 
           nume_structura *nume_pointer2; // elementele vecine
           };

Exemplu de element
       
    a)Lista simpla inlantuita si lista circulara
     

struct record {
         int number;
         record *next;
         };

b)Lista dublu inlantuita
     

struct record {
         int number;
         record *prev,*next;
         };

Operatorul pentru accesare campurilor unui element :  -> ( Accesare indirecta ) . Operatorul .(point) de la structuri reprezenta accesarea directa a unui camp, dar fiindca la liste folosim pointeri, se foloseste accesarea indirecta.
       
       Exemplu

record->number = 2; // am initializat variabila number d

Exemplu de cod

Urmatorul cod citeste un set de numere intr-o lista simpla inlantuita, apoi afiseaza lista pe ecran. ( Deci aici este acoperita operatia de inserare in lista   )

#include <stdio.h>

struct record{
   int number;
   record *next;
  };

record *first,*current;

int main(){
   int n;
   printf("Cate numere vor fi citite : ");
   scanf("%d",&n);
   
   int i,val;
   for(i=0;i<n;i++) {
      scanf("%d",&val);
      current = new record; 
      current->number = val;
      current->adr = first;
      first = current;
      }
   while(first){                 // NOTA : daca ati obs. mai sus, la citire, pointerul first va contine dupa citire
    printf("%d ",first->number); // o copie al ultimului element. Deci la afisare, numerele vor fi afisate in ordine
    first = first->next;         // inversa citirii acestora. Pentru a afisa numerele in ordine trebuie doar sa mai
   }                             // declarati un pointer de tip record si sa cititi primul element separat, si sa-l
   return 0;                     // copiati in acel pointer,iar la while,in loc de "first" puneti numele pointerului ce indica spre primul element
}

Inca nu am acoperit totul despre liste mai este mult. Voi adauga pe parcurs informatii la aceasta lectie.Desigur, daca ajung sa fac asta primul ,  poate apare vreun user cu ceva completari In perioada asta sunt extremly busy cu scoala , de aceea sunt mai lent ^^