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/lista-dwukierunkowa-struktury-t491690.html

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