Forum Pasja Informatyki - Najnowsze z tagiem lista-dwukierunkowa

Lista dwukierunkowa

Thu, 18 Jun 2020 14:39:13 +0000

Hej :)

Rozpisuję obecnie funkcje wymagane do zadanka z związanego z konstrukcją listy dwukierunkowej:

Oto treść wymagana do rozpisania funkcji:

Napisz program pozwalający użytkownikowi na wykonywanie dowolnej operacji na liście dwukierunkowej z poziomu konsoli (menu tekstowe).

W tym celu zaimplementuj listę wiązaną dwukierunkową, opartą o następujące struktury oraz API:

struct doubly_linked_list_t
{
  struct node_t *head;
  struct node_t *tail;
};

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

gdzie:

head - wskaźnik na pierwszy element listy, jeżeli lista jest pusta powinien być ustawiony na NULL,
tail - wskaźnik na ostatni element listy, jeżeli lista jest pusta powinien być ustawiony na NULL.
next - wskaźnik na następny element listy, jeżeli nie ma następnego elementu to NULL
prev - wskaźnik na poprzedni element listy, jeżeli nie ma poprzedniego elementu to NULL,
data - wartość przechowywana w elemencie listy
Przygotuj następujące funkcje, umożliwiające obsługę listy:

struct doubly_linked_list_t* dll_create();

int dll_push_back(struct doubly_linked_list_t* dll, int value);
int dll_push_front(struct doubly_linked_list_t* dll, int value);
int dll_pop_front(struct doubly_linked_list_t* dll, int *err_code);
int dll_pop_back(struct doubly_linked_list_t* dll, int *err_code);

int dll_back(const struct doubly_linked_list_t* dll, int *err_code);
int dll_front(const struct doubly_linked_list_t* dll, int *err_code);

struct node_t* dll_begin(struct doubly_linked_list_t* dll);
struct node_t* dll_end(struct doubly_linked_list_t* dll);

int dll_size(const struct doubly_linked_list_t* dll);
int dll_is_empty(const struct doubly_linked_list_t* dll);

int dll_at(const struct doubly_linked_list_t* dll, unsigned int index, int *err_code);

int dll_insert(struct doubly_linked_list_t* dll, unsigned int index, int value);
int dll_remove(struct doubly_linked_list_t* dll, unsigned int index, int *err_code);

void dll_clear(struct doubly_linked_list_t* dll);

void dll_display(const struct doubly_linked_list_t* dll);
void dll_display_reverse(const struct doubly_linked_list_t* dll);
Deklaracje wszystkich funkcji oraz struktur umieść w pliku nagłówkowym doubly_linked_list.h, a definicje w pliku doubly_linked_list.c.

struct doubly_linked_list_t* dll_create();
Funkcja przydziela pamięć na strukturę doubly_linked_list_t, inicjuje ją na pustą listę dwukierunkową i zwraca adres przydzielonej struktury. Jeżeli operacja się nie powiedzie to zwraca NULL.

int dll_push_back(struct doubly_linked_list_t* dll, int value);
int dll_push_front(struct doubly_linked_list_t* dll, int value);
Funkcje dodają element o wartości value na koniec (push_back) lub początek (push_front) listy dll. Funkcje zwracają:

0 w przypadku sukcesu,
1 w przypadku błędnych danych wejściowych lub
2 jeżeli nie uda się przydzielić pamięci.
int dll_pop_front(struct doubly_linked_list_t* dll, int *err_code);
int dll_pop_back(struct doubly_linked_list_t* dll, int *err_code);
Funkcje usuwają pierwszy (pop_front) lub ostatni (pop_back) element z listy dll zwracając jego wartość. Do zmiennej err_code, o ile to możliwe, zapisany powinien zostać kod błędu:

0 w przypadku sukcesu,
1 w przypadku błędnych danych wejściowych.
int dll_front(const struct doubly_linked_list_t* dll, int *err_code);
int dll_back(const struct doubly_linked_list_t* dll, int *err_code);
Funkcje zwracają wartość pierwszego (front) lub ostatniego (back) elementu z listy dll bez usuwania tego elementu. Do zmiennej err_code, o ile to możliwe, zapisany powinien zostać kod błędu:

0 w przypadku sukcesu,
1 w przypadku błędnych danych wejściowych.
struct node_t* dll_begin(struct doubly_linked_list_t* dll);
struct node_t* dll_end(struct doubly_linked_list_t* dll);
Funkcje zwracają:

wskaźnik na pierwszy (begin) lub ostatni (end) elementu listy dll lub
NULL jeżeli nie będzie to możliwe.
int dll_size(const struct doubly_linked_list_t* dll);
Funkcja zwraca:

liczbę elementów w liście dll lub
-1 w przypadku błędnych danych wejściowych.
int dll_is_empty(const struct doubly_linked_list_t* dll);
Funkcja sprawdza czy lista dll jest pusta. Funkcja zwraca:

1 jeżeli lista jest pusta,
0 jeżeli w liście znajdują się jakieś elementy lub
-1 w przypadku błędnych danych wejściowych.
int dll_at(const struct doubly_linked_list_t* dll, unsigned int index, int *err_code);
Funkcja zwraca wartość elementu spod indeksu index listy dll. Indeks elementu liczony jest względem pierwszego elementu (head). Do zmiennej err_code, o ile to możliwe, zapisany powinien zostać kod błędu:

0 w przypadku sukcesu,
1 w przypadku błędnych danych wejściowych.
int dll_insert(struct doubly_linked_list_t* dll, unsigned int index, int value);
Funkcja dodają element o wartości value na pozycję index listy dll. Funkcja zwraca:

0 w przypadku sukcesu,
1 w przypadku błędnych danych wejściowych lub
2 jeżeli nie uda się przydzielić pamięci.
Przykład:

Dana jest lista sześciu elementów ll = ABCDEF.
Element x jest wstawiany na pozycję 3.
Lista ll po zmianie: ABCxDEFG.
int dll_remove(struct doubly_linked_list_t* dll, unsigned int index, int *err_code);
Funkcja usuwa element spod indeksu index z listy dll i zwraca jego wartość. Do zmiennej err_code, o ile to możliwe, zapisany powinien zostać kod błędu:

0 w przypadku sukcesu,
1 w przypadku błędnych danych wejściowych.
void dll_clear(struct doubly_linked_list_t* dll);
Funkcja usuwa wszystkie elementy z listy dll (zwalnia również pamięć).

void dll_display(const struct doubly_linked_list_t* dll);
Funkcja wyświetla wszystkie elementy z listy dll, w jednym wierszu, oddzielone spacjami. Jeżeli lista jest pusta to funkcja nie podejmuje żadnej akcji.


void dll_display_reverse(const struct doubly_linked_list_t* dll);

Funkcja wyświetla wszystkie elementy z listy dll, w jednym wierszu, oddzielone spacjami. Elementy należy wyświetlać od ostatniego (tail).

Jeżeli lista jest pusta to funkcja nie podejmuje żadnej akcji.

Sortowanie listy dwukierunkowej przez scalanie - rozdzielanie listy

Fri, 06 Dec 2019 22:33:34 +0000

Zaproponuj algorytm rozdzielania listy dwukierunkowej

ze szczególnym uwzględnieniem przypadków brzegowych

Myślę z pozostałymi funkcjami potrzebnymi do realizacji sortowania przez scalanie bym sobie

poradził choć chciałbym poznać wasz pomysł na konkatenacje bo

występuje ona podczas scalania

Scalanie dwóch posortowanych list

Scalanie(L,A,B)

      L=NIL

     dopóki lista A jest niepusta oraz lista B jest niepusta wykonuj

            Jeżeli klucz pobrany z głowy listy A jest mniejszy bądź równy kluczowi pobranemu z głowy listy B to

                              Usuń węzeł z głowy listy A i zapamiętaj go w lokalnej zmiennej

              w przeciwnym przypadku

                              Usuń węzeł z głowy listy B i zapamiętaj go w lokalnej zmiennej

              Wstaw zapamiętany węzeł na koniec listy L

     /* Teraz co najmniej jedna lista powinna być pusta ale nie wiemy która więc

         łączymy obie listy A oraz B z listą L przy czym łączenie to redukuje się do tzw konkatenacji */

     Połącz listę L z listą A

     Połącz listę L z listą B

Sortowanie(L)

      Jeżeli głowa listy L nie pokazuje na NIL oraz następnik głowy listy L nie pokazuje na NIL to

                 Rozdziel listę L na połowę

                 Posortuj rekurencyjnie obydwie połowy

                 Scal posortowane połowy

wskazniki-lista dwukierunkowa

Thu, 27 Sep 2018 10:09:35 +0000

witam,

Kompletnie nie wiem jak zabrać się za tą listę. proszę o jakieś wskazówki/

Do napisania jest funkcja która zamienia poczatek a końcem i druga ktora usuwa osoby strasze o jakims okreslonym wieku.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXLEN 30
//usuwa strasze osoby i zwraca liczbe osob po ususnieciu.
//zamienia pierwsza pozycje z druga/

struct Dane
{
	char Imie[MAXLEN];
	char Nazwisko[MAXLEN];
	int RokUr;
};

struct Element
{
	struct Dane dane;
	struct Element *Poprz;
	struct Element *Nast;
};

struct Lista
{
	struct Element *Poczatek;
	struct Element *Koniec;
	int Rozmiar;
};

void DrukujDane(struct Dane dn) {
	printf("%s %s, rok ur: %d\n", dn.Imie, dn.Nazwisko, dn.RokUr);
}

void Drukuj(struct Lista *lst) {
	struct Element *p;
	//p = lst->Poczatek;
	//while (p != NULL) {
	//	DrukujDane(p->dane);
	//	p = p->Nast;
	//}
	for (p = lst->Poczatek; p != NULL; p = p->Nast)
		DrukujDane(p->dane);

	printf("=== Liczba elementow: %d ====\n", lst->Rozmiar);
}

void DodajPoczatek(struct Lista* lst, struct Dane dn) {

	struct Element *nel;
	nel = (struct Element*)malloc(sizeof(struct Element));
	//(*nel).dane = dn;
	nel->dane = dn;
	if (lst->Poczatek == NULL) {
		//lista pusta
		lst->Poczatek = nel;
		lst->Koniec = nel;
		nel->Poprz = NULL;
		nel->Nast = NULL;
	}
	else {
		//lista niepusta
		nel->Poprz = NULL;
		nel->Nast = lst->Poczatek;
		lst->Poczatek->Poprz = nel;
		lst->Poczatek = nel;
	}
	lst->Rozmiar++;
}

void DodajKoniec(struct Lista* lst, struct Dane dn) {
	struct Element *nel;
	nel = (struct Element*)malloc(sizeof(struct Element));
	nel->dane = dn;
	if (lst->Poczatek == NULL) {
		lst->Poczatek = nel;
		lst->Koniec = nel;
		nel->Poprz = NULL;
		nel->Nast = NULL;
	}
	else {
		nel->Nast = NULL;
		nel->Poprz = lst->Koniec;
		lst->Koniec->Nast = nel;
		lst->Koniec = nel;
	}
	lst->Rozmiar++;
}

void ZamienPoczatekKoniec(struct Element *lst,struct Dane dn){
    struct Element *temp;
    temp=(struct Element*)malloc(sizeof(struct Element));

    temp=lst->Koniec;

    temp->Nast=lst->Koniec->Nast;
    temp->Poprz=lst->Koniec->Poprz;
   lst-> Koniec->Nast=lst->Poczatek->Nast;
    lst->Koniec->Poprz=lst->Poczatek->Poprz;
    lst->Poczatek->Poprz=temp->Poprz;
    lst->Poczatek->Nast=temp->Nast;

}
struct Element* ZnajdzNazwisko(struct Lista* lst, char *Nazwisko) {
	struct Element *p;

	for (p = lst->Poczatek; p != NULL; p = p->Nast)
		if (strcmp(p->dane.Nazwisko, Nazwisko) == 0)
			break;
	return p;
}

void UsunNajstarszy(struct Lista *lst,int *RokUr){
    struct Element *p;
    for (p = lst->Poczatek; p != NULL; p = p->Nast){
        if(RokUr>70)
            UsunElement(*lst,p);

    }
    lst->Rozmiar--;
        return 0;

}
void UsunElement(struct Lista* lst, struct Element* pBiezacy) {

	if (pBiezacy->Poprz == NULL)
		lst->Poczatek = pBiezacy->Nast;
	else
		pBiezacy->Poprz->Nast = pBiezacy->Nast;
	if (pBiezacy->Nast == NULL)
		lst->Koniec = pBiezacy->Poprz;
	else
		pBiezacy->Nast->Poprz = pBiezacy->Poprz;
	free(pBiezacy);
	lst->Rozmiar--;
}

void UsunKoniec(struct Lista* lst) {
	if (lst->Koniec == NULL)
		return;
	UsunElement(lst, lst->Koniec);
}

void UsunPoczatek(struct Lista* lst) {
	if (lst->Poczatek == NULL)
		return;
	UsunElement(lst, lst->Poczatek);
}

void UsunWszystko(struct Lista* lst) {
	while (lst->Poczatek != NULL)
		UsunElement(lst, lst->Poczatek);
}


int main()
{
	char Bufor[MAXLEN];

	struct Lista KierInform;
	struct Lista KierKosmit;

	struct Element* pEl;

	KierInform.Poczatek = NULL;
	KierInform.Koniec = NULL;
	KierInform.Rozmiar = 0;

	struct Dane dane = { "Jan", "Kowalski",1990 };
	DodajPoczatek(&KierInform, dane);

	dane = (struct Dane) { "Marcin", "Wolski", 1980 };
	DodajPoczatek(&KierInform, dane);
	Drukuj(&KierInform);

	dane = (struct Dane) { "Szymon", "Stepniak", 1970 };
	DodajPoczatek(&KierInform, dane);
	Drukuj(&KierInform);

	dane = (struct Dane) { "Anna", "Walczak", 1999 };
	DodajKoniec(&KierInform, dane);
	Drukuj(&KierInform);

	printf("Podaj nazwisko: ");
	scanf("%29s", Bufor);
	pEl = ZnajdzNazwisko(&KierInform, Bufor);
	if (pEl == NULL)
		printf("Nie znaleziono.\n");
	else {
		//DrukujDane(pEl->dane);
		UsunElement(&KierInform, pEl);
		Drukuj(&KierInform);
	}
	UsunWszystko(&KierInform);
	Drukuj(&KierInform);


	return 0;
}

lista dwukierunkowa błąd w kodzie

Sat, 26 May 2018 08:57:37 +0000

Witam

Nie chce mi się skompilować lista i nie mogę znaleźć błędu.Jak by ktos pomógł będę wdzięczny.

#include <iostream>

using namespace std;
struct dane
    {
        int data;
        dane* next;
        dane* prev;

    };
    struct kurs
    {
    dane* head;
    dane* tail;
    int ilosc;

    };
void poczatek (kurs *r)
{
    int v=22;
    dane * p=new dane;

  p->data = v;
  p->prev = NULL;
  p->next = head;
  head  = p;
  ilosc++;
  if(p->next)
  {
      p->next->prev = p;
  }
  else
    tail = p;
}
void przed(kurs *r)
{
    int poz;
    int v=10;
    cout<<"Podaj pozycje:";
    cin>>poz;
    dane * p=new dane;

  if(poz == head)
  {
      poczatek(r);
  }
  else
  {
    p = new dane;
    p->data = v;
    p->next = poz;
    p->prev = poz->prev;
    ilosc++;
    poz->prev->next = p;
    poz->prev = p;
  }
}
void wyswietl(kurs *r)
{

  dane * p=new element;


  while(p)
  {
    cout << " " << p->data;
    p = p->next;
  }

}

int main()
{
   kurs*r=new kurs;
   r=NULL;

   int w;
  do
   {
       cout<<"1.Dodawanie elementu  na poczatek listy"<<endl;
        cout<<"2.Dodanie przed element "<<endl;
        cout<<3.Wyswietl liste"<<endl;
        cout<<"Wybor:";
        cin>>w;
        switch(w)
        {
        case 1:
            poczatek(r);
            break;
        case 2:
            przed(r);
            break;
        case 3:
            wyswietl(r);
            break;
        }

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

Lista dwukierunkowa - rekurencja

Fri, 04 May 2018 16:02:00 +0000

Cześć

Muszę napisać podane funkcję za pomocą rekurencji. Tyle, że nie do końca wiem jak to można zrobić. Mógłby ktoś mi podpowiedzieć jak to zrobić.

Kod oryginalnego programu:

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

struct dll_node
{
    int data ;
    struct dll_node *prev, * next ;
};

struct dll_node * create_list ( int data )
{
    struct dll_node * front = ( struct dll_node *)
                              malloc ( sizeof ( struct dll_node ) ) ;
    if ( NULL != front )
    {
        front -> data = data ;
        front -> prev = front -> next = NULL ;
    }
    return front ;
}

struct dll_node * insert_front ( struct dll_node *front,
                                 struct dll_node * new_node )
{
    new_node -> next = front ;
    front -> prev = new_node ;
    return new_node ;
}

struct dll_node * find_spot ( struct dll_node *front, int data )
{
    struct dll_node * prev = NULL ;
    while (( NULL != front ) && (front -> data > data ) )
    {
        prev = front ;
        front = front -> next ;
    }
    return prev ;
}

void insert_after ( struct dll_node *node, struct dll_node * new_node )
{
    new_node -> prev = node ;
    new_node -> next = node -> next ;
    node ->next -> prev = new_node ;
    node -> next = new_node ;
}

void insert_back ( struct dll_node *back, struct dll_node * new_node )
{
    back -> next = new_node ;
    new_node -> prev = back ;
}

struct dll_node * insert_node ( struct dll_node *front, int data )
{
    if ( NULL == front )
        return NULL ;

    struct dll_node * new_node = ( struct dll_node *)
                                 malloc ( sizeof ( struct dll_node ) ) ;
    if ( NULL != new_node )
    {
        new_node -> data = data ;
        new_node -> prev = new_node -> next = NULL ;
        if (front -> data <= data )
            return insert_front (front, new_node ) ;
        else
        {
            struct dll_node * node = find_spot (front, data ) ;
            if ( NULL != node -> next )
                insert_after (node, new_node ) ;
            else
                insert_back (node, new_node ) ;
        }
    }
    return front ;
}

struct dll_node * delete_front ( struct dll_node * front )
{
    struct dll_node * next = front -> next ;
    if ( NULL != next )
        next -> prev = NULL ;
    free ( front ) ;
    return next ;
}

struct dll_node * find_node ( struct dll_node *front, int data )

{
    while (( NULL != front ) && (front -> data != data ) )
        front = front -> next ;
    return front ;
}

void delete_within ( struct dll_node * node )
{
    node ->next -> prev = node -> prev ;
    node ->prev -> next = node -> next ;
    free ( node ) ;
}

void delete_back ( struct dll_node * back )
{
    back ->prev -> next = NULL ;
    free ( back ) ;
}

struct dll_node * delete_node ( struct dll_node *front, int data )
{
    if ( NULL == front )
        return NULL ;

    if (front -> data == data )
        return delete_front ( front ) ;

    struct dll_node * node = find_node (front, data ) ;
    if ( NULL != node )
    {
        if ( NULL != node -> next )
            delete_within ( node ) ;
        else
            delete_back ( node ) ;
    }
    return front ;
}

void print_list ( struct dll_node * front )
{
    for (; NULL != front ; front = front -> next )
        printf ("%d ", front -> data ) ;
    printf ("\n") ;
}

void print_list_backwards ( struct dll_node * front )
{
    if ( NULL != front )
    {
        for (; NULL != front -> next ; front = front -> next ) ;
        for (; NULL != front ; front = front -> prev )
            printf ("%d ", front -> data ) ;
    }
    printf ("\n") ;
}

void remove_list ( struct dll_node ** front )
{
    struct dll_node * next = NULL ;
    while ( NULL != * front )
    {
        next = (* front ) ->next ;
        free (* front ) ;
        * front = next ;
    }
}

int main ()
{
    struct dll_node * front = create_list (1) ;
    int i;

    for (i=2; i <5; i++)
        front = insert_node (front, i) ;
    for (i=6; i <10; i++)
        front = insert_node (front, i) ;
    printf (" List elements :\n") ;
    print_list ( front ) ;
    printf (" List elements printed backwards :\n") ;
    print_list_backwards ( front ) ;

    front = insert_node (front, 0) ;
    printf (" List elements after insertion of 0:\n") ;
    print_list ( front ) ;
    front = insert_node (front, 5) ;
    printf (" List elements after insertion of 5:\n") ;
    print_list ( front ) ;
    front = insert_node (front, 7) ;
    printf (" List elements after insertion of 7:\n") ;
    print_list ( front ) ;
    front = insert_node (front, 10) ;
    printf (" List elements after insertion of 10:\n") ;
    print_list ( front ) ;

    front = delete_node (front, 0) ;
    printf (" List elements after deletion of 0:\n") ;
    print_list ( front ) ;
    front = delete_node (front, 1) ;
    printf (" List elements after deletion of 1:\n") ;
    print_list ( front ) ;
    front = delete_node (front, 1) ;
    printf (" List elements after deletion of 1:\n") ;
    print_list ( front ) ;
    front = delete_node (front, 5) ;
    printf (" List elements after deletion of 5:\n") ;
    print_list ( front ) ;
    front = delete_node (front, 7) ;
    printf (" List elements after deletion of 7:\n") ;
    print_list ( front ) ;
    front = delete_node (front, 10) ;
    printf (" List elements after deletion of 10:\n") ;
    print_list ( front ) ;

    remove_list (& front ) ;
    return 0;
}

lista dwukierunkowa

Thu, 02 Nov 2017 18:30:34 +0000

Witam, mam problem z lista dwukierunkową. Funkcja insert podczas dodawania na koniec listy nie przepina wskaźnika końca. Chodzi dokładnie o instrukcje w if. Wszystko sobie rozpisałam i powinno działać, a jednak coś jest nie tak :(

class lista{
      public:
             class ogniwo{
                   public:
                   ogniwo * next;
                   ogniwo * prev;
                   int value;
                   };
             class interator{
                   public:
                   ogniwo * wsk;
                   interator next(interator it);
                   };
...

lista::interator lista::insert_list(interator it, int v){
     ogniwo * a = it.wsk;
     ogniwo * b = new ogniwo;
     ogniwo * c = a->next;
     b->next = c;
     b->prev = a;
     b->value = v;
     c->prev = b;
     a->next = b;
     if(b->next == b){
               koniec.wsk =b;
     }
     size++;
     return it;
}

Z góry dzięki za pomoc

Inicjalizacja listy dwukierunkowej

Tue, 04 Apr 2017 09:40:50 +0000

Chyba czegoś nie ogarniam ze wskaźnikami... ktoś mógłby mi wskazać błąd?
head.h

#ifndef HEAD_H_INCLUDED
#define HEAD_H_INCLUDED

typedef struct dane Dane;
typedef struct lista Lista;
void clearIn();
void endl();
void init(Lista *);
void addBegining(Lista *);

#endif // HEAD_H_INCLUDED

fn.c

#include <stdio.h>
#include <stdlib.h>
#include "head.h"

struct dane {
    char *imie, * nazwisko;
    int pesel;
    Dane *next, *prev;
};

struct lista {
    Dane *head, *tail;
    unsigned count;
};

void clearIn(){
     while(getchar()!='\n');
}

void endl(){
    printf("\n");
}

void init(Lista * start) {
    start -> head = NULL;
    start -> tail = NULL;
    start -> count = 0;
}

void addBegining(Lista *lista) {
    Dane *element = (Dane*)malloc(sizeof(Dane));
    char *imie = (char*)malloc(64*sizeof(char));
    printf("Podaj imie: ");
    gets(imie);
    char *nazwisko = (char*)malloc(64*sizeof(char));
    printf("Podaj nazwisko: ");
    gets(nazwisko);
    int pesel;
    scanf("%d", &pesel);
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "head.h"

int main()
{
    Dane *my_list;
    Lista *start;
    init(start);
    printf("Lista dwukierunkowa\n\n");
    printf("a. dodaj do listy\tb. wyswietl liste\n");
    switch(getchar()){
    case 'a':
    case 'A':
        addBegining(start);
        break;
    }
}

Chodzi mi knokretnie o funkcję init. Która ma inicjalizować listę. W mainie tworzę wskaźnik start i chcę przekazać go do funkcji który zainicjalisuje tą listę zerami. Jednak po włączeniu program crashuje.

Inna sprawa to w funkcji main chciałem zrobić coś takiego:

Lista *start = (Lista*)malloc(sizeof(Lista);

to dostaję zwrot z kompilatora:
"error: invalid application of 'sizeof' to incomplete type 'Lista {aka struct lista}'|"

Jak to ogarnąć? Co robię źle ;/?

EDIT. Może zdąże zanim ktos przeczyta:
char *imie = (char*)malloc(64*sizeof(char));

Takie cudo.... czy muszę tam określać że ma wielkość 64? Jak bym zrobił np.
char *imie = (char*)malloc(sizeof(char));
to czy program sam będzie dostosowywać wielkość w zależności od tego co wpiszę? Czy raczej może być to niebezpieczne?

[C] Sortowanie listy dwukierunkowej

Fri, 27 Jan 2017 23:25:36 +0000

Hejo, wiem że są podobne tematy, ale nie znalazłem satysfakcjonującej odpowiedzi.
Mam sobie listę dwukierunkową, milion różnych danych w niej (typu imię, nazwisko, wiek itd itd). Jak napisać funkcje sortującą tą listę wg zadanego parametru?
Bardziej niż na kodzie zależy mi na omówieniu jakiegoś schematu/algorytmu, nie musi być nlogn. Tym razem prostota > efektywność. (raczej nie quick, chciałbym załatwić to bez rekursji, napisałem już swoją wersję funkcji swap)
Nie odsyłajcie proszę do googla, chciałbym żeby wytłumaczył to ktoś przedstawiając swój sposób myślenia.

Struktury dynamiczne napisane obiektowo

Mon, 19 Dec 2016 21:29:30 +0000

Poszukuję tutorialów, kursów, filmików, książek, cokolwiek co omówi temat struktur dynamicznych tj. lista jednokierunkowa, lista dwukierunkowa oraz drzewa z tym, że napisanych obiektowo.

Czy coś ciekawego znacie? :)