rango - Valores aleatorios cuando se utiliza la combinación en la ordenación de combinación C++

srand en c

Question

Para una pequeña tarea, se supone que debo escribir una función de combinación simple cuyo prototipo se vea así:

void merge(int a[], int left_low,  int left_high, int right_low, int right_high)

Las instrucciones dicen que, para simplificar, solo estamos incorporando una sola matriz, a[] y que right_low = left_high + 1 . También estamos almacenando los valores finales en la matriz original a[] que se pasó. Esencialmente, para una matriz con valores a[] = {1,3,10,4,7,8} se ve así:

a = {1, 3,     10 ,         4,    7,      8}
     ^         ^            ^             ^ 
  left_low  left_high    right_low     right_high

Para esta tarea, tenemos algunas pruebas que tenemos que pasar. El primero es una simple fusión entre dos matrices. La segunda es la función merge_sort de los profesores que invoca en algunas matrices ordenadas al azar. Aquí está mi implementación de merge() :

void merge(int a[], int left_low,  int left_high,
                    int right_low, int right_high) {
    int temp[right_high + 1]; // temporary array to store the result
    int left_i = left_low, right_i = right_low, temp_i = 0;

    // while the temporary array is not filled
    while(temp_i != right_high + 1)
    {
        if(left_i == left_high + 1)
            temp[temp_i++] = a[right_i++];
        else if(right_i == right_high + 1)
            temp[temp_i++] = a[left_i++];
        else if(a[left_i] < a[right_i])
            temp[temp_i++] = a[left_i++];
        else
            temp[temp_i++] = a[right_i++];
    } // end while
    for(int i = 0; i < temp_i; ++i)
        a[i] = temp[i];
}

Cuando él llama a la primera prueba, donde solo verifica la fusión de dos arreglos, mi función funciona, y el arreglo único ahora está ordenado. Sin embargo, cuando él llama a su función merge_sort, termino obteniendo valores de basura. Aquí están sus funciones de prueba:

template<class T>
void print (std::string label, T a[], int length, bool report_sorted) {
  bool sorted = true;
  std::cout << label;
  for (int i=0; i<length; ++i) {
    std::cout << a[i];
    if (i == length-1)
      std::cout << std::endl;
    else {
      std::cout << ", ";
      if (a[i] > a[i+1])
        sorted = false;
    }
  }
  if (report_sorted)
    std::cout << (sorted ? "    Sorted" : "    Not Sorted") << std::endl;
}

void shuffle(int values[], int length) {
  std::vector<int> v_values;
  for (int i=0; i<length; ++i)
    v_values.push_back(values[i]);
  std::random_shuffle(v_values.begin(),v_values.end());
  for (int i=0; i<length; ++i)
    values[i] = v_values[i];
}

//Recursive Merge Sort
template<class T>
void merge_sort(T a[], int low, int high) {
  if (high - low < 1)               //Base case: 0 or 1 value to sort -> sorted
    return;
  else {
    int mid = (low + high)/2;       //Split in 1/2
    merge_sort(a, low, mid);        //Recursively sort low to mid
    merge_sort(a, mid+1, high);     //Recursively sort mid+1 to high
    merge(a, low,mid, mid+1,high);  //Merge sorted parts of array
  }
}

//Standard Merge Sort (calls a generalized one, with more parameters)
template<class T>
void merge_sort(T a[], int length) {
  merge_sort(a, 0, length-1);
}

std::cout << "/n/nTesting merge in merge sort" << std::endl;
    int test_merge_sort[10] = {1,2,3,4,5,6,7,8,9,10};
    for (int i=0; i<5; i++) {
      shuffle(test_merge_sort, 10);
      print("/n  Array before sort: ", test_merge_sort, 10, false);
      merge_sort(test_merge_sort, 10);
      print("  Array after  sort: ", test_merge_sort, 10, true);
    }

Y por alguna razón, mi salida termina pareciéndose a esto:

 Array before sort: 3, 9, 2, 5, 8, 4, 6, 10, 1, 7
  Array after  sort: -944749486, 4, 5439488, 0, 5443192, 5443196, 1975317641, -944749486, 4, 1995111146
    Not Sorted

  Array before sort: 1995111146, 1975317641, 4, 0, -944749486, 5443192, 5443196, 5439488, 4, -944749486
  Array after  sort: -944749486, 4, 5439488, 0, 5443192, 5443196, 1975317641, -944749486, 4, 1995111146
    Not Sorted

  Array before sort: -944749486, -944749486, 5443196, 4, 5439488, 1995111146, 5443192, 1975317641, 0, 4
  Array after  sort: -944749486, 4, 5439488, 0, 5443192, 5443196, 1975317641, -944749486, 4, 1995111146
    Not Sorted

  Array before sort: 1975317641, -944749486, 4, 4, 5439488, 5443192, 5443196, -944749486, 0, 1995111146
  Array after  sort: -944749486, 4, 5439488, 0, 5443192, 5443196, 1975317641, -944749486, 4, 1995111146
    Not Sorted

  Array before sort: -944749486, 5443192, 5443196, 1975317641, 4, 0, -944749486, 5439488, 1995111146, 4
  Array after  sort: -944749486, 4, 5439488, 0, 5443192, 5443196, 1975317641, -944749486, 4, 1995111146
    Not Sorted

¿Qué está mal con mi código de combinación que podría estar causando esto?

Answer 1

El problema es que estás calculando el número de entradas en temp incorrecta: tu código cree que es right_high + 1 , pero la fórmula correcta es right_high - left_low + 1 .

Por ejemplo, cuando una llamada le da índices 10, 15, 16, 26, su código intenta fusionar 27 valores, mientras que debería fusionar solo 17 (es decir, los índices 10 a 26, inclusive).

Esto no hace ninguna diferencia cuando left_low es cero, por lo que su caso de prueba funciona bien. Pero tan pronto como left_low convierte en un valor distinto de cero, por ejemplo, cuando se clasifica la mitad derecha de la matriz, su código "sobrepasa" ambas matrices, colocando valores de basura en tmp y escribiendo los valores en la matriz a también.

También las asignaciones en el último bucle for deben estar en offset left_low también:

for(int i = 0; i < temp_i; ++i)
    a[i+left_low] = temp[i];