Ciao a tutti,
ho una lista di interi doppiamente concatenata. Non capisco come spezzare questa lista e crearne due, la prima conterrà i primi x valori, l'altra conterrà i restanti.
Ad esempio se ho una lista contenente [3 4 5 7 9 6 3] e inserisco x=2, devo stampare la lista [3 4] e la lista [5 7 9 6 3].
Sono riuscito a spezzare la lista secondo il valore dato in input, settando il next dell'elemento uguale all'indice a NULL, quello che non capisco è come creare la nuova lista con gli elementi restanti.
strutture.h
struct node{
int iData;//elemento della lista
struct node *prev; //puntatore all'elemento precedente della lista;
struct node *next; //puntatore all'elemento successivo della lista;
};
struct list {
char cNomeLista[10]; //array contenente il nome della lista
int iNumeroElementi; //numero elementi della lista
struct node *header; //puntatore al primo elemento della lista
struct node *tail; //puntatore all'ultimo elemento della lista
struct list *next; //puntatore alla successiva lista
//struct list *; //puntatore alla prima lista
};
operation_on_list.c
#include "header.h"
#include "strutture.h"
/**
* Funzione che mi permette di stampare
* la lista passata come argomento.
*/
void print_list(struct list* list){
struct node* tempNode;
tempNode = list -> header;
int i;
printf("\n%s [", list -> cNomeLista);
if(list -> iNumeroElementi == 0){
printf("Nil");
}else{
for(i = 0; i < list -> iNumeroElementi; i++){
printf(" %d ", tempNode->iData);
tempNode = tempNode -> next;
}
}
printf("]");
}
/**
* Funzione che stampa tutte le liste
* che sono state create e che sono
* presenti in memoria. Ogni lista
* presente in memoria viene passata come
* argomento alla funzione print_list
* che si occupa di stamparla.
*/
void print_allList(struct list* list, int numListe){
int i;
for(i = 1; i <= numListe; i++){
print_list(list->next);
list = list -> next;
}
}
/**
* Funzione che stampa tutti i nomi
* delle liste presenti in memoria.
*/
void printNameOfAllList(struct list *list, int temp){
int i;
for(i=0;i<temp;i++){
list = list -> next;
printf("\n%s", list -> cNomeLista);
}
}
void testSplit(struct list* list, int k, int contList){
int x = (list -> iNumeroElementi)/k;
int i, j;
int temp;
struct node* tempNode;
//struct list* tempL = init_list();
struct list* newList;
tempNode = list -> header;
for(i=0; i < list -> iNumeroElementi; i++){
if(i == (x-1)){ //appena l'indice i e' uguale al valore calcolato x
tempNode = tempNode -> next;
newList -> header = tempNode -> next;
newList = insert_list(newList, ++contList);
print_list(newList);
tempNode = tempNode -> next=NULL;
list -> iNumeroElementi = x;
print_list(list); //faccio vedere che la lista contiene i primi x elementi
// si puoò vedere anche chiamando l'opzione 'v' dal menu'
break; //interrompo il ciclo for
}
tempNode = tempNode -> next;
}
}
/**
* Funzione che controlla se il nome di lista
* inserito corrisponde con un nome di lista
* presente in memoria.
*/
void listPresentOrNotPresent(struct list* list, char *sEnteredName, int contList){
//printf("Sono dentro la funzione listPresentOrNotPresent\n");
int i; int k;
//printf("sEnteredName vale: %s\n", sEnteredName);
for(i=0; i < contList; i++){
list = list -> next;
if(strcmp(list -> cNomeLista, sEnteredName)==0){ //verifico che il nome della lista corrisponde a quello da me inserito
printf("Uguali\n");
printf("La lista %s e' composta da %d elementi.\n", list -> cNomeLista, list -> iNumeroElementi);
do{ //Se la lista esiste richiedo di inserire il valore di k, controllando di inserire un valore >1.
printf("Inserisci un valore intero positivo(maggiore di 1): ");
scanf("%d", &k);
}while(k<=1);
testSplit(list, k, contList);
break;
}else{
printf("Non uguali\n");
}
}
}
/**
* Funzione che, se richiamata, mi permette di
* di inizilizzare la lista.
*/
struct list* init_list (){
printf("Inizializzo la struttura delle liste\n");
struct list *temp;
temp = malloc(sizeof(struct list));
temp -> iNumeroElementi=0;
temp -> header = NULL;
temp -> tail = NULL;
temp -> next = NULL;
return temp;
}
/**
* Funzione che nserisce una nuova lista in memoria
* con nome nel formato List-contList (che è progressivo).
*/
struct list* insert_list(struct list* list, int contList){ //modifica
//creo una nuova lista
struct list *new_list;
//alloco spazio per la nuova lista
new_list = malloc(sizeof(struct list));
sprintf(new_list->cNomeLista, "List-%d", contList);
//new_list -> cNomeLista;
new_list -> iNumeroElementi = 0;
new_list -> header = NULL;
new_list -> tail = NULL;
list -> next = new_list;
new_list -> next = NULL;
return new_list;
}
operation_on_node.c
#include "strutture.h"
#include "header.h"
void insert_node(struct list *list, int iElemento){
//creo un nuovo nodo
struct node *new_node;
//alloco spazio per il nuovo nodo
new_node = malloc(sizeof(struct node));
new_node -> iData = iElemento;
new_node -> next = NULL;
if(list -> iNumeroElementi==0){
new_node -> prev = NULL;
list -> header = new_node;
}else{
new_node -> prev = list -> tail;
list -> tail -> next = new_node;
}
list -> tail = new_node;
list -> iNumeroElementi++;
}
int scan_node(struct list* list, int indice){
indice--;
if(indice >= list -> iNumeroElementi){
printf("Errore: hai inserito un indice che supera le dimensioni della lista");
return 0;
}
int i;
int iElemento;
struct node* tempNode;
tempNode = list -> header;
for(i = 0; i < list -> iNumeroElementi; i++){
if(i == indice){
iElemento = tempNode -> iData;
return iElemento;
}
tempNode = tempNode -> next;
}
return 0;
}
main.c
int main (void){
char cScelta;
struct list* first = init_list();
int contList=0;
int iElementoDellaLista;
int iRestituito;
int k;
char aczNameOfList[100];
struct list* last_list = first;
/*Ciclo while che gira fino a quando e' verificata la condizione 1.
Dentro al ciclo faccio la chiamata alla funzione stampaMenu e salvo
il valore restituito in una variabile di tipo char che mi permette
di scegliere uno dei case corrispondenti.*/
while(1){
cScelta=stampaMenu();
switch (cScelta){
case 'a':
printf("Inserisci gli elementi della lista.\n 0 per terminare l'inserimento\n\n");
contList++;
last_list = insert_list(last_list, contList);
printf("Elemento: ");
scanf("%d", &iElementoDellaLista);
while(iElementoDellaLista!=0){
insert_node(last_list, iElementoDellaLista);
printf("Elemento: ");
scanf("%d", &iElementoDellaLista);
}
break;
case 'v':
if(contList==0){
printf("Non ci sono liste da stampare\n");
break;
}else{
print_allList(first, contList);
}
break;
case 'b':
printf("Inserisci il nome di una lista (nel formato List-i) a cui applicare lo split: ");
scanf("%s", aczNameOfList);
listPresentOrNotPresent(first, aczNameOfList, contList);
break;
}
}
}
così facendo riesco solo a troncare la lista originale, mentre la newList che viene creata è del tipo [Nil] cioè la nuova lista contiene 0 elementi, e infatti controllando newList -> iNumeroElementi risulta essere =0...ma non capisco perchè