2016-04-19 9 views
7

Ho un array di 3 valori in virgola mobile:C - In ordine galleggiare matrice tenendo traccia di indici

float norms[3]; 

norms[0] = 0.4; 
norms[1] = 3.2; 
norms[2] = 1.7; 

voglio ordinare questa matrice per decrescente tenendo traccia degli indici originali dei valori nell'array.

In altre parole, data la gamma norms[] = {0.4, 3.2, 1.7} con corrispondenti indici {0, 1, 2}, io fondamentalmente vogliono ottenere una serie di corrispondenti ints che riflette le posizioni originali dei valori float in norms[] seguenti quello discendente. In questo caso sarebbe {1, 2, 0}.

Qual è il modo migliore/più pulito per raggiungere questo obiettivo?

+3

Creare un array di tipo int con la stessa dimensione contenente gli indici. Quando si ordina l'array float si rispecchia semplicemente qualsiasi operazione di swap sul proprio array int. – jboockmann

+1

Utilizzare una struttura con un campo indice, scrivere l'indice di ciascun elemento prima dell'ordinamento e che manterrà la posizione originale nell'array. –

+0

Basta fare una copia dell'array originale. Questo è tutto. Non sono necessari algoritmi di ottimizzazione pre-mature e fangosi. Andando avanti ... – Lundin

risposta

7

Utilizzare una struttura per memorizzare il valore e l'indice e quindi ordinare in base al valore.

struct str 
{ 
    float value;int index; 
}; 
int cmp(const void *a,const void *b) 
{ 
    struct str *a1 = (struct str *)a; 
    struct str *a2 = (struct str*)b; 
    if((*a1).value>(*a2).value)return -1; 
    else if((*a1).value<(*a2).value)return 1; 
    else return 0; 
} 
int main() 
{ 
    float arr[3]={0.4,3.12,1.7}; 
    struct str objects[3]; 
    for(int i=0;i<3;i++) 
    { 
     objects[i].value=arr[i]; 
     objects[i].index=i; 
    } 
    //sort objects array according to value maybe using qsort 
    qsort(objects,3,sizeof(objects[0]),cmp); 
    for(int i=0;i<3;i++) 
    printf("%d ",objects[i].index);//will give 1 2 0 
    // your code goes here 
    return 0; 
} 
2

Basta usare qualsiasi algoritmo di ordinamento 'aliasing' per l'accesso all'array originale. Esempio con bubblesort

int len = 3; 
bool switched = false; 

float myFloatArr[3]; 
int myFloatIndex[3] = {0, 1, 2}; 

do 
{ 
    switched = false; 
    for(i = 1; i < len; i++) 
    { 
     if(myFloatArr[myFloatIndex[i - 1]] < myFloatArr[myFloatIndex[i]]) 
     { 
      int temp = myFloatIndex[i]; 
      myFloatIndex[i] = myFloatIndex[i - 1]; 
      myFloatIndex[i - 1] = temp; 
      switched = true; 
     } 
    } 
} 
while(switched); 
3

Il modo più pulito in cui posso pensare è creare una struttura che contenga sia float che indice.

typedef struct str { 
float val; 
int index; 
} str; 

quindi creare una matrice di questa struttura e ordinare secondo le val.