Lista dwukierunkowa [C] - struktury.

0

Witam! Usiłuję napisać listę wiązaną dwukierunkową korzystając ze struktur. Po wielu h udało mi się napisać, jednak program nie działa. Prosiłbym o pomoc,wskazanie błędów i ewentualne poprawienie.

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

typedef struct element
{
    int v;
    struct lista_dwukierunkowa *nast, *pop;
}elementy;

struct element *pocz=NULL;
struct element *koniec=NULL;
int sizee=0;

 struct element *push_front(elementy *p, int w)
 {
      p->nast = pocz; 
      p->pop = NULL;
      if(pocz) 
          pocz->pop = p;
      pocz = p;
      if(!koniec) 
          koniec = pocz;
      p->v=w;
      sizee++;
      return pocz;
 }

 struct element *push_back(elementy *p, int w)
 {
      if(koniec) 
          koniec->nast = p;
      p->nast = NULL;
      p->pop = koniec;
      koniec = p;
      if(!pocz) 
          pocz = koniec;
      p->v=w;
      sizee++;
      return koniec;
 }

 struct element *insert(elementy *p1, elementy *p2, int w)
 {
      int temp;
      p1->nast = p2->nast; 
      p1->pop = p2;
      p2->nast = p1;
      if(p1->pop) 
          p1->nast->pop = p1;
      else koniec = p1;
      p1->v=temp;
      p2->v=p1->v;
      p1->v=w;
      sizee++;
      return p1;
 }

struct element *pop_front()
{
      elementy *p;      
      if(pocz)
      {
        p = pocz;
        pocz = pocz->nast;
        if(!pocz) 
            koniec = NULL;
        else pocz->pop = NULL;
        sizee--;
        return p;
      }
      else return NULL;
}

struct element *pop_back()
{
      elementy *p;      
      if(koniec)
      {
        p = koniec;
        if(p == pocz) 
            pocz = koniec = NULL;
        else
            {
                koniec = koniec->pop;
                koniec->nast = NULL;
            }
        sizee--;
        return p;
      }
      else return NULL;
}

struct element *remove(elementy *p)
{
    elementy *p1;

    if(p->pop)
        p->pop->nast = p->nast;
    else pocz = p->nast;
    if(p->nast) 
        p->nast->pop = p->pop;
    else koniec = p->pop;
    sizee--;
    return p;
} 

void print()
{
    elementy *p;
    if(!pocz) 
        printf("Lista jest pusta \n");
      else
      {
        p = pocz;
        while(p)
        {
          printf("%d", p->v);
          p = p->nast;
        }
        printf("\n");
      }
}

void print_backward()
{
    elementy *p;
    if(!koniec) 
        printf("Lista jest pusta \n");
      else
      {
        p = koniec;
        while(p)
        {
          printf("%d", p->v);
          p = p->pop;
        }
        printf("\n");
      }
}

struct element *at(int n)
{
      elementy *p;

      if((!n) || (n > sizee)) 
          return NULL;
      else if(n == sizee) 
          return koniec;
      else if(n < sizee / 2)
      {
        p = pocz;
        while(--n) p = p->nast;
        return p;
      }
      else
      {
        p = koniec;
        while(sizee > n++) p = p->pop;
        return p;
      }  
}

int front()
{
    return pocz->v;
}

int back()
{
    return koniec->v;
}

int size()
{
    return sizee;
}

int isEmpty(elementy *p)
{
    if (p==NULL)
        return 0;
    else if(p!=NULL)
        return 1;
}

int main()
{
    int s,t,war, il, kt,z, us,i,ktr,wart;
    struct element el; 

    printf("\n\nAktualna liczba elementow listy %d\n\n", size());

    printf("\n\nCo chcesz zrobic?\n");
    printf("1. Wpisac elementy od poczatku listy\n");
    printf("2. Wpisac element od konca listy\n\n");
    scanf("%d", &s);
    system("cls");
    switch(s)
    {
        case 1:
                printf("Ile elementow chcesz wpisac?\n");
                scanf("%d", &il);
                for(i=1; i<il; i++)
                {
                    printf("Podaj wartosc elementu?\n");
                    scanf("%d", &war);
                    push_front(&el, war);
                }
                break;
        case 2:
                printf("Ile elementow chcesz wpisac?\n");
                scanf("%d", &il);
                for(i=1; i<il; i++)
                {
                    printf("Podaj wartosc elementu?\n");
                    scanf("%d", &war);
                    push_back(&el, war);
                }
    }
    system("CLS");

    printf("\n\nAktualna liczba elementow listy %d\n\n", size());

    printf("\n\nCo chcesz zrobic?\n");
    printf("1. Usunac pierwszy element listy\n");
    printf("2. Usunac ostatni element listy\n\n");
    printf("3. Usunac dowolny element listy\n");
    printf("4. Wpisać element w środku listy\n\n");
    printf("5. Wyswietlic liste\n\n");
    scanf("%d", &t);
    system("CLS");
    switch(t)
    {
        case 1: 
                pop_front();
                printf("Pierwszy element usuniety \n");
                break;
        case 2:
                pop_back();
                printf("Ostatni element usuniety \n");
                break;
        case 3:
                printf("Ktory elemnt chcesz usunac?\n");
                scanf("&d", &kt);
                remove(at(kt));
                printf("\nWybrany element zostal usuniety\n");
                break;
        case 4:
                printf("\n\nAktualna liczba elementow listy %d\n\n", size());
                printf("Ktory element chcesz wpisac?\n");
                scanf("%d", &ktr);
                printf("Podaj wartosc tego elementu\n");
                scanf("%d", &wart);
                insert(at(ktr), at(ktr-1), wart);
                printf("Element dodany\n");
        case 5:
                printf("\n\nCo chcesz zrobic?\n");
                printf("1. Wyswietlic pierwszy element listy\n");
                printf("2. Wyswietlic ostatni element listy\n\n");
                printf("3. Wyswietlic cala liste\n");
                printf("4. Wyswietlic cala liste od konca\n");
                scanf("%d", &z);
                switch(z)
                {
                case 1:
                       printf("Pierwszy element listy = %d", front());
                       system("PAUSE");
                       break;
                case 2:
                       printf("Ostatni element listy = %d", front());
                       system("PAUSE");
                       break;
                case 3:
                        printf("Zawartosc listy: \n");
                        print();
                        system("PAUSE");
                        break;
                case 4: 
                        printf("Zawartosc list od konca: \n");
                        print_backward();
                        system("PAUSE");
                        break;
                }

    }
    system("CLS");
    printf("Czy chcesz usunac cala liste?\n");
    printf("1. Tak\n");
    printf("2. Nie \n");

    if(us==1)
    {
        while(size())
            pop_front();
        printf("Lista wyczyszczona\n");
    }

    printf("\n\nAktualna liczba elementow listy %d\n\n", size());

    if(isEmpty(&el)==1)
        printf("Lista posiada elementy\n)");
    else printf("Lista jest pusta\n");

    system("PAUSE");
    return 0;
}
0
typedef struct element
{
        int v;
        struct lista_dwukierunkowa *nast, *pop;
}elementy;

jak robisz typedef struct to nie musisz potem wszędzie pisać struct element tylko elementy. co to za struktura lista_dwukierunkowa? nigdzie nie widzę definicji. powinno być raczej element. ja bym to tak napisał:

typedef struct element {
        int v;
        struct element *nastepny, *poprzedni;
} element;

z kolei zamiast zmiennych globalnych stworzył bym strukturę przechowującą listę:

typedef struct lista {
        element *poczatek, *koniec; // wskaźniki na 1 i ostatni element listy
        int rozmiar;
} lista;

no i funkcja która tworzy nową listę:

lista *new_list() {
        lista *t = (lista*)malloc(sizeof(lista));
        t->poczatek = NULL;
        t->koniec = NULL;
        t->rozmiar = 0;
}

a w funkcji main utworzył listę:

lista *mojaLista = new_list();

oczywiście wszystkie funkcje muszą przyjmować jako argument tą listę.
napiszę Ci jedną funkcję, który dodaje element na początek listy, resztę zrobisz analogicznie:

element *push_front(lista *l, int w) {
        element *nowyElement;
        nowyElementy = (element*)malloc(sizeof(element)); // alokujemy pamięć na nowy element
        nowyElement->v = w; // przypisujemy mu wartość
        nowyElement->nastepny = l->poczatek; // po nowym elemencie następuje element, który wcześniej był pierwszy
        nowyElement->poprzedni = NULL; // nowy element nie ma poprzednika
        l->poczatek->poprzedni = nowyElement; // poprzednikiem elementu, który wcześniej był pierwszy jest nowy pierwszy
        l->poczatek = nowyElement; // nowy element jest teraz pierwszym elementem listy
        // wazna jest kolejnosc wszystkich operacji ^
        l->rozmiar += 1; // zwiększa licznik elementów w liście o 1
        return nowyElement; // funkcja zwraca wskaznik na nowo dodany element listy
}

gdy chcemy wstawić liczbę 5:

push_front(mojaLista, 5);
0
element *wstaw(lista *l, element *poprzednik, int wartosc)
{
    element *nowy = (element*)malloc(sizeof(element));
    nowy->wartosc = wartosc;
    nowy->pop = poprzednik;
    nowy->nast = (poprzednik != NULL) ? poprzednik->nast : l->poczatek; 

    *(nowy->pop != NULL ? &nowy->pop->nast : &l->poczatek) = nowy;
    *(nowy->nast != NULL ? &nowy->nast->pop : &l->koniec) = nowy;
}

element *dodaj_z_przodu(lista *l, int wartosc)
{
    return wstaw(l, NULL);
}

element *dodaj_na_koncu(lista *l, int wartosc)
{
    return wstaw(l, l->koniec);
}
0

Wspólnymi siłami kilku forów odwalacie pracę dla nieroba.
http://forum.dobreprogramy.pl[...]unkowa-struktury-t491690.html

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0