Tableau de listes chainées

#include <iostream>

using namespace std;

struct Node{
 int num;
 Node *nextNode;
 Node *prevNode;
};

void initializeLists(Node* head, Node* Arraylist[], int MAX_INDEX);
void addNode(int num, int arrayIndex, Node* Arraylist[], int countArray[]);
void affiche_apres_initialisation (Node *p, Node* Arraylist[]);
void affiche_apres_ajout (Node *ptr, Node* Arraylist[]);

int main()
{
    int MAX_INDEX(5);
    Node* Arraylist[5];
    int num;
    int arrayIndex;
    int countArray [2];                      // taille de chaque list.
    Node* head ;
    head = NULL;

while (1){
  int n;
  cout << "1. remplir et afficher le tableau initialisé de liste." << endl;
  cout << "2. remplir et afficher le tableau de liste apres ajout." << endl;
  cin >> n;

if(n==1){

     cout << "initialiser les differentes case: ";
     cin >> num;
     initializeLists( head, Arraylist, MAX_INDEX);
     cout << "afficher:";
     affiche_apres_initialisation (head, Arraylist);
    }

else if (n==2){

    cout << "ajouter autres elements dans chaque celleule(liste) du tableau: ";
    cin >> Arraylist[arrayIndex]->num;
    addNode( num, arrayIndex, Arraylist, countArray);
    cout << "afficher:";
    affiche_apres_ajout (head, Arraylist);
    }
else{
    cout << "BY"<< endl;
    break;
    }

    return 0;
}
}

void initializeLists(Node* head, Node* Arraylist[], int MAX_INDEX) {

    int idx;
    int num;

    for (idx = 0; idx < MAX_INDEX; idx++) {    //pour chaque liste du tableau.
        Node* newNode = new Node;              //créer un nouveau noeud.
        Arraylist[idx] = newNode;               //affecter ce noeud à un indice du tableau.
        head = newNode;                         //affecter ce noeud à la tete de la liste.
        newNode->nextNode = NULL;               //initialiser à null.
        newNode->prevNode = NULL;               //initialiser à null.
        newNode->num = num;                     //donner la valeur initial de la tete de chaque liste.

    }
    return;
}

void addNode(int num, int arrayIndex, Node* Arraylist[], int countArray[]) {

  int MAX_INDEX;
  for (arrayIndex = 0; arrayIndex < MAX_INDEX; arrayIndex++) {
    Node* newNode = new Node;                    //créer un nouveau noeud.
    Node* head = Arraylist[arrayIndex];           //affecter la tete de la liste à chaque case du tableau

       if (head->num == NULL) {

        head->num = num;

        }
        else {                                    


        newNode->nextNode = head->nextNode;       // inserer un noeud à une liste.
        head->nextNode = newNode;
        newNode->prevNode = head;


        if (newNode->nextNode != NULL) {
            newNode->nextNode->nextNode = newNode;
        }
        newNode->num = num;
        }
    countArray[arrayIndex]++;                      //incrementer le compteur de la liste.
    }
    return;
}

 void affiche_apres_initialisation (Node *p, Node* Arraylist[])
  {

    int MAX_INDEX(5);

    for (int idx = 0; idx < MAX_INDEX; idx++){
      while (p != NULL){
      cout << Arraylist[idx]->num << endl ;
        p = p->nextNode;
        p = p->prevNode;
     }
  }
  }

  void affiche_apres_ajout (Node *ptr, Node* Arraylist[])
  {
    int arrayIndex (5);

    while (ptr != NULL){
     cout << ptr->num << endl << endl;
     Arraylist[arrayIndex]->nextNode;
     ptr = ptr->nextNode;
     ptr = ptr->prevNode;
     }
  }

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

/* Macro Bool */
typedef enum{false,true}bool;

/***
* Structure Simple d'une Pile
***/
typedef struct _Pile{
	
	unsigned int iVal;
 	struct _Pile *pPrec;
}ts_Pile;

/***
*	Fonction vérification 
*   de la pile
***/
bool f_isEmpty(ts_Pile **pIn){
	
	return ( (*pIn == NULL ) ? true : false );
}

/***
* Fonction qui ajoute un élement
* dans la Pile
***/
void f_addPile(ts_Pile **pIn, unsigned int const iVal){
	
	ts_Pile *tmp = malloc( sizeof( ts_Pile ) );
 	if( !tmp ){
  		perror( "Erreur interne d'allocation\n" );
  		exit( 1 );
 	}
	
	/*	Ajout de l'élément	*/
 	tmp->iVal = iVal;
 	tmp->pPrec = *pIn;
 	*pIn = tmp;
}

/***
* fonction qui retire un élement
* de la Pile
***/
unsigned const int f_PopPile(ts_Pile **pIn){
	
	unsigned int iVal = 0;
 	
 	ts_Pile *tmp = NULL;
 	if( !*pIn  )
  		return ( -1 );
 	
 	tmp  = (*pIn)->pPrec;
 	iVal = (*pIn)->iVal;
 	
 	free( *pIn );
 	*pIn = tmp;
 	
 	return ( iVal );
}

/***
* Fonction qui libère
* la mémoire allouer
***/
void f_FreeAlloc( ts_Pile **pIn){
	
	ts_Pile *tmp = NULL;
	
	if( f_isEmpty( pIn ) != true ){
		
		while( *pIn ){
			tmp = (*pIn)->pPrec;
			free ( *pIn );
			*pIn = tmp;
		}
	
		*pIn = NULL;
		tmp = NULL;
	}
}


/***
* Fonction principale
***/
int main( void ) {
	
	int i = 0;	
	
	/* Déclaration des piles & initialisation */
	
 	ts_Pile *pile_1 = NULL;	/*	Pile (1)	*/
 	ts_Pile *pile_2 = NULL;	/*	Pile (2) 	*/
 	ts_Pile *pile_3 = NULL;	/*	Pile (3)	*/
 	
 	/*	tableau de Pointeur */
 	ts_Pile (*pTabAddr[3]) = { &pile_1, &pile_2, &pile_3 };
 	
 	/*	Ajouts des valeurs à la pile	*/
 	for(; i < 20 ; i++){
 		f_addPile(	pTabAddr[0], i );
 		f_addPile(	pTabAddr[1], (i*2) );
 		f_addPile( 	pTabAddr[2], (i*4) );
 	}
 	
 	/*	Affichage des Piles	*/
 	for(i = 0; i < 20 ; i++)
 		printf("Pile (1)\t= %d\n", f_PopPile(&pile_1) );
 		
 	for(i = 0; i < 20 ; i++)
 		printf("Pile (2)\t= %d\n", f_PopPile(&pile_2) );

 	for(i = 0; i < 20 ; i++)
 		printf("Pile (3)\t= %d\n", f_PopPile(&pile_3) );
 	
 	/*	Désalocation mémoire */
 	f_FreeAlloc( pTabAddr[0] );
 	f_FreeAlloc( pTabAddr[1] );
 	f_FreeAlloc( pTabAddr[2] );
 

 	return ( 0 );
}