2010-09-06 22 views
6

¿Cómo se mueven los elementos en un arreglo al siguiente elementomatriz cambiará al siguiente elemento

eg: x[5] = { 5, 4, 3, 2, 1 }; // initial values 
    x[0] = 6; // new values to be shifted 
    x[5] = { 6, 5, 4, 3, 2 }; // shifted array, it need to be shifted, 
           // not just increment the values. 

Esto lo que he hecho hasta ahora. Está mal, es por eso que necesito ayuda aquí. Gracias por adelantado.

#include <iostream> 

using namespace std; 

int main() 
{ 
    int x[5] = { 5, 4, 3, 2, 1 }; 

    int array_size = sizeof(x)/sizeof(x[0]); 

    x[0] = 6; 

    int m = 1; 

    for(int j = 0; j < array_size; j++) { 
    x[m+j] = x[j]; 
    cout << x[j] << endl; 
    } 

    return 0; 
} 
+0

inicio esta copia en serie del índice final de la matriz en lugar de comenzar, ya que al comenzar a copiar el elemento de principio que va a perder el siguiente elemento. Así que cambie el ciclo for –

+0

Tenga en cuenta "off by one": x [m + j] = x [j]; intentará sobrescribir el elemento con el índice "array_size", que es mayor que la matriz, es un comportamiento indefinido. – sharptooth

Respuesta

8
#include <iostream> 

int main() { 

    int x[5] = { 5, 4, 3, 2, 1 }; 

    int array_size = sizeof (x)/sizeof (x[0]); 

    for (int j = array_size - 1; j > 0; j--) { 

     x[j] = x[j - 1]; 
    } 

    x[0] = 6; 

    for (int j = 0; j < array_size; j++) { 

     std::cout << x[j]; 
    } 

    return 0; 
} 
+0

Muchas gracias. – Azam

+0

¿No se corre intencionalmente el riesgo de producir una falla de segmentación? – imkendal

4

En primer lugar, usted debe cambiar los viejos valores de la matriz antes de escribir el nuevo valor. Pero en lugar de un bucle, es mejor que uses memmove(). O mejor aún con std::vector en lugar de una matriz: maneja todos estos problemas de bajo nivel, incluido el redimensionamiento automático de la matriz cuando es necesario.

+0

+1 para 'memmove' –

+0

Pero supongo que esto es tarea, así que se requieren bucles y manipulación del índice, supongo. –

8

para "mover hacia la derecha" hay que recorrer desde el final de la matriz:

for(int j = array_size - 2; j >= 0; j--) { 
    x[m+j] = x[j]; 
    cout << x[j] << endl; 
} 

lo contrario sólo sobrescribir todos los elementos con el elemento 0 ª.

Por favor, tenga en cuenta array_size - 2 - de lo contrario, tiene "apagado por uno" tratando de acceder al elemento más allá del extremo de la matriz y ese es un comportamiento indefinido.

+1

+1 buena captura, perdida por todos los demás (incluido yo mismo :-) –

+0

no funciona. salida convertido en 2,3,4,6 – Azam

+1

@azam: Solo señalé el problema principal en tu código.Todavía tiene que poner el valor en el elemento [0] usted mismo y tendrá que iterar sobre la matriz por segunda vez para obtener el resultado. – sharptooth

1

En el caso general en el que necesita cambiar m elementos (donde 0 <= m <n): Comience desde el final de la matriz. Si comienza desde el principio (índice 0), sobrescribirá y luego mueve ese valor anulado.

El estudio del código fuente de std::memmove también puede ser instructivo.

+0

Creo que esta solución, y la que usa rotar son mejores que las que usan para el ciclo. Usar rutinas de biblioteca siempre es mejor que escribir su propio código. –

0

Puede comenzar desde el final de la matriz. Copiar el elemento

  • en 2ª última posición hasta la última posición ,
  • elemento en la tercera última posición a la segunda última posición,
  • ....
  • elemento en la primera posición (índice 0) a la 2da posición y finalmente
  • copie el nuevo número en la primera posición . .

.

for(j = array_size-1; j >0; j--) { 
x[j] = x[j-1]; 
} 
x[0] = 6; 
14
#include<algorithm> 

// ... 
std::rotate(x, x+4, x+5); 
x[0] = 6; 
+0

lo siento. no quiero usar algo. – Azam

+5

+1 De mí por proporcionar una solución C++. – fredoverflow

0
#include <iostream> 

    using namespace std; 

    int main() 
    { 
     int x[5] = { 5, 4, 3, 2, 1 }; 

     int array_size = sizeof(x)/sizeof(x[0]); 

     int m = 1; 

     for(int j = array_size-1; j > 0; j--) { 
      x[j] = x[j-m]; 
      cout << x[j] << endl; 
     } 

     x[0] = 6; 
     return 0; 
    } 
+0

su salida es 2,3,4,5 – Azam

Cuestiones relacionadas