Matrice blocs homogènes

Je crois que tu as mal saisi mon message...
Nous, on est là pour aider à partir d'un énoncé clair.
Si l'énoncé n'est pas clair au départ, on ne peut pas faire grand chose... Seul le rédacteur peut aider...
Bref, tant que tu ne seras plus clair, je crains que tu obtiennes de l'aide...

Bonjour, voilà l'énoncé exact:
On suppose qu'on a une matrice M de valeurs entières supposée carrée de taille n (n est une puissance de 2). On veut chercher les blocs homogènes de la matrice M et les stocker dans un tableau ou dans une liste chaînée. Chaque bloc homogène est identifié par ses coordonnées i et j, sa taille et sa moyenne. Les blocs homogènes sont les blocs qui ont un écart-type inférieur à un seuil S fixé.
Pour trouver les blocs homogènes, on procède de la manière suivante:
1 - Si ecart-type(M) < S (seuil fixé) on arrête
2- Sinon divisez la matrice en 4 blocs : M1, M2, M3, M4 et pour chaque bloc Mi (i=1, 2, 3, 4), refaire la même procédure jusqu'à trouver un bloc homogène ou la taille du bloc atteint 2x2.
M1 M2
M3 M4
Exemple:
int M[max][max]={ {10,10,20,20,40,40,40,40},
{10,10,20,20,40,40,40,40},
{30,30,50,50,40,40,40,40},
{30,30,50,50,40,40,40,40},
{60,60,60,60, 5, 5,20,20},
{60,60,60,60, 5, 5,20,20},
{60,60,60,60,20,20, 7,5},
{60,60,60,60,20,20, 7, 7}};
Les blocs homogènes de M, selon un seuil de valeur égale à 5, sont:
{0,0,2,10},{0,2,2,20},{2,0,2,30},{2,2,2,50},{0,4,4,40},{4,0,4,60},{4,4,2,5},{4,6,2,20},
{6,4,2,20},{6,6,2,7}.
Par exemple le bloc identifié par {2, 0, 2, 30} est le bloc qui commence à partir de la ligne n°2 et la colonne n°0, de taille 2 et de moyenne 30.

Travail demandé:
Utiliser les différentes structures de données manipulées en cours permettant de:
- De générer les blocs homogènes d'une matrice M donnée selon un seuil S fixé.
- A partir des blocs homogènes trouvés par la question 1, de générer une matrice qui sera une approximation de la matrice M initiale.
- Refaire le même travail, en supposant que la matrice sera remplie à partir d'un fichier contenant des données.

Bonjour,
Je n'ai pas eu le temps de voir en profondeur ton énoncer et ton code, mais avant tout as- tu corriger ton code source et où est-ce que tu es arrêté ?
à bientôt

slt fiddy.
Merci d'avoir pris la peine de voir mon code.J'ai effectué les rectifications que vous m'avez demandé sauf pour celle de la macro , j'ai essayé la majuscule et j'ai une erreur,et pour celle où je devais remplacer &liste par *liste car je n'ai pas compris pourquoi.
Bref voilà mon code avec la bonne valise:

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

#define maxD 64
#define s 5

 

typedef double matD[maxD][maxD];
typedef  struct noeud *ptr;


typedef struct bloc{
int ligne;
int colonne;
int taille;
double moyenne;
}bloc; 

struct noeud {
bloc cont;
ptr suiv;
};      



/****************************************************/
void inser_fin(ptr &liste,bloc a)
{ ptr p,q;

/* creer le noeud */
p=(ptr) malloc(sizeof(struct noeud));
if (p==0) {printf("Pas d'espace mémoire\n"); exit(1) ;}

/* remplir le noeud par les données */
 p->cont.ligne=a.ligne;
 p->cont.colonne=a.colonne;
 p->cont.taille=a.taille;
 p->cont.moyenne=a.moyenne;
 p->suiv=NULL;
/* si la liste est vide */
if (liste==NULL)liste=p;
else
{// recherche le dernier du noeud
 for(q=liste;q->suiv!=NULL;q=q->suiv);
//lier le dernier avec le noeud à insérer
 q->suiv=p;

}
}
/*************************************************/


/*******************************************************/
void affiche(ptr liste)
{
ptr p;

for(p=liste;p!=NULL;p=p->suiv)
printf("%d\t%d\t%d\t%f ",p->cont.ligne,p->cont.colonne,p->cont.taille,p->cont.moyenne);

printf("\n");

}
/*************************************************************/


/*********************************************************************/
void saisir_mat(matD M,int &n)
{int i,j;
     printf("Donnez la dimension de la matrice M puissance de 2:\n");
   scanf("%d",&n);

   for(i=0;i<n;i++)
     for(j=0;j<n;j++)
    {  
       M[i][j]=rand()%10;               
      printf("M[%d][%d]=%f\n",i,j,M[i][j]);
                  
    }
} 
/**********************************************************************/

   
/****************************************************/    
float moyenne(matD M,int i,int j,int n)
{int p,q;
 double moy=0;

  for(p=i;p<n;p++)
    for(q=j;q<n;q++)
         moy=moy+M[p][q];
         moy=moy/(n*n);
       
       return(moy);
         
 }
/****************************************************/ 
 
 
/**************************************************/     
float ecart_type(matD M,int i,int j,int n)
{int p,q;
 double ect=0;
   
   for(p=i;p<n;p++)
    for(q=j;q<n;q++)
     ect=ect+pow(  (M[p][q]-moyenne(M,i,j,n)),2   );
     ect=ect/(n*n);
     ect=sqrt(ect);
     
     
       return(ect);
     
 }  
/**************************************************/ 
 
 
/****************************************************************/ 
void parcourt(matD M,matD N,int i,int j,int &n)
{int p,q;
       
  for(p=i;p<n/2;p++)
    for(q=j;q<n/2;q++)
    { N[p][q]=M[p][q];
    //printf("N[%d][%d]= %lf\n",p,q,N[p][q]);
     }
        
    n=n/2;
}   
/***********************************************************************/


/******************************************************/    
void homogene(matD M,int i,int j,int n,ptr homog)
{ int m; 
  bloc b;
  matD N;

     if(ecart_type(M,i,j,n) < s)
      { 
         b.ligne=i;
         b.colonne=j;
         b.taille=n;
         b.moyenne=moyenne(M,i,j,n);
        inser_fin(homog,b);
        affiche(homog);  
      }  
     else
         {
            parcourt(M,N,i,j,n);            
            m=n;
                                
            /***Bloc 1***/
            do
            homogene(N,i,j,n,homog);
            while( n>2 && n!=m) ;                         
            n=m;
              
           /***Bloc 2***/  
             do
             { 
               j=j+2;
               homogene(N,i,j,n,homog);
             }
             while( n>2 && n!=m) ;                         
             n=m;
            
            /***Bloc 3***/    
            do
             {
               i=i+2;      
               j=j-2;
               homogene(M,i,j,n,homog);
             }
             while( n>2 && n!=m) ;                         
             n=m;
             
           /***Bloc 4***/      
          do
             {
               j=j+2;
               homogene(M,i,j,n,homog);
             }
             while( n>2 && n!=m) ;                   
          
                       
     }
    
   
}      
/******************************************************************************/


//programme principal
int main()
{ matD M={ {10,10,20,20,40,40,40,40},
           {10,10,20,20,40,40,40,40},
           {30,30,50,50,40,40,40,40},
           {30,30,50,50,40,40,40,40},
           {60,60,60,60, 5, 5,20,20},
           {60,60,60,60, 5, 5,20,20},
           {60,60,60,60,20,20, 7, 5},
           {60,60,60,60,20,20, 7, 7}};
  int n=8;         
  int i=0,j=0;
  ptr homog;
  
     //saisir_mat(M,n);
       printf("Les blocs homogenes de M sont :\n");  
       homogene(M,i,j,n,homog);  
       
      getchar();            
    return 0; 

}

J'ai toujours le même problème.

Ben normal, tu n'as pas corrigé tout ce que j'ai dit (prototype void inser_fin(ptr &liste,bloc a). Refait une passe pour bien tout prendre en compte.
Reposte ton code une fois que c'est corrigé et met également le message d'erreur que tu obtiens.