Como reverter uma matriz C ++
O inverso desta matriz é:
char arrr [] = 'q', 'p', 'o', 'n', 'm';Os personagens se tornam em ordem inversa, no Initializer_list. Observe que na ordem inversa, letra, 'O' permanece em sua posição. Isso ocorre porque o número de elementos na matriz é estranho.
Considere agora a seguinte matriz:
char arrf [] = 'l', 'm', 'n', 'o', 'p', 'q';O inverso desta matriz é:
char arrr [] = 'q', 'p', 'o', 'n', 'm', 'l';Os personagens se tornam em ordem inversa, no Initializer_list. Desta vez, os dois elementos do meio são trocados porque o número de elementos na matriz é uniforme.
Existem várias maneiras de reverter a matriz, e este artigo explora essas maneiras.
Conteúdo do artigo
- Introdução - Veja acima
- Usando uma matriz extra para reverter
- Array reverso trocando elementos
- Array reverter usando uma função recursiva
- Uso de std :: reverse ()
- Conclusão
Usando uma matriz extra para reverter
Com este método, crie outra matriz do mesmo tipo e tamanho que a matriz original, mas vazia. Em seguida, leia a primeira matriz da parte de trás e encaixe nos elementos da segunda matriz da frente usando um loop for. O programa a seguir ilustra o seguinte:
#incluirusando namespace std;
int main ()
char arrf [] = 'm', 'n', 'o', 'p', 'q';
int size = sizeof (Arrf)/sizeof (Arrf [0]); // obtendo o tamanho da matriz
char arrr [tamanho];
for (int i = 0, j = size-1; j> = 0; i ++, j--)
Arrr [i] = arrf [j];
para (int i = 0; i
cout<
A saída é:
Q p o n mA primeira declaração na função principal C ++ cria a primeira matriz sem indicar o tamanho. A segunda declaração obtém o tamanho dividindo o tamanho total da matriz em bytes pelo tamanho do primeiro elemento da matriz (afinal, todos os elementos de uma matriz C ++, são do mesmo tipo). A próxima declaração cria a segunda matriz do mesmo tipo e tamanho, mas vazia.
O segmento de código depois é o loop for. O loop for copia o último elemento da primeira matriz e o coloca na primeira posição da segunda matriz. Ele copia o último elemento, mas um da primeira matriz e coloca na segunda posição da segunda matriz. Ele copia o terceiro elemento da primeira matriz e coloca na terceira posição da segunda matriz e até o índice variável, que está “movendo” a segunda matriz atinge o último elemento da segunda matriz no índice tamanho 1. Índice, J "se move para baixo" a primeira matriz de tamanho 1 para 0. Eu movo a segunda matriz enquanto J se move pela primeira matriz.
Nos parênteses do loop for, eu e j são declarados na primeira declaração. Enquanto J for maior ou igual a zero, a cópia continuará - essa é a condição enquanto condiciona. O incremento de i e decréscimo de j, formam a última declaração nos parênteses.
O último loop impressa os elementos da segunda matriz.
Array reverso trocando elementos
Os últimos e os primeiros elementos podem ser trocados pela única matriz. O último, mas um e segundo elementos podem ser trocados por essa mesma matriz. O terceiro para o terceiro e o terceiro elementos pode ser trocado e até o ponto intermediário da matriz chegar e trocar as paradas. Se o número de elementos é estranho, o elemento intermediário não muda sua posição. Se o número de elementos forem, existem dois elementos do meio que são trocados.
Novamente, existem duas variáveis de índice: i e j, mas apenas para uma matriz. Eu sou incrementado e J é diminuído para cada iteração até que eles quase se encontrem. A condição de enquanto é (eu < j). The following program, illustrates this method:
#incluirusando namespace std;
int main ()
char arr [] = 'm', 'n', 'o', 'p', 'q';
int size = sizeof (arr)/sizeof (arr [0]);
para (int i = 0, j = size-1; i< j; i++,j--)
char temp = arr [i];
arr [i] = arr [j];
arr [j] = temp;
para (int i = 0; i
cout<
A saída é:
Q p o n mArray reverter usando uma função recursiva
Uma função recursiva é uma função que continua se chamando até que uma condição seja cumprida. Isso é melhor explicado com um exemplo. Considere a seguinte parte superior do programa:
#incluirusando namespace std;
char arr [] = 'm', 'n', 'o', 'p', 'q';
int siz = sizeof (arr)/sizeof (arr [0]);
Void ReversearRray (char arr [], int i)
// condição base
if (i == siz)
retornar;
Char elemento = arr [i]; // elemento de extração
reverseaRray (arr, i+1); // Chamada recursiva
arr [siz-i-1] = elemento; // Traceback
A matriz é declarada e o tamanho da matriz é determinado como siz (sem e). Depois disso, no código é a definição de função recursiva. O primeiro segmento de código na função (if construct) é a condição a ser atendida. O I é a variável de índice para acessar os elementos da matriz do índice 0 para o índice SIZ-1. Quando eu é igual ao SIZ, a função retorna e para de se chamar.
A função principal do C ++ tem a chamada,
reverseaRray (arr, 0);Isso chama a função recursiva com dois argumentos: o primeiro é o nome da matriz; o segundo é o índice inicial para i, zero.
Quando a função é chamada de primeira vez, 'M' é atribuído a um local na memória identificado pelo elemento. Após essa afirmação, a função é chamada novamente dentro da função com "Reversearray (arr, i+1);". A última declaração na função não foi atendida. Desta vez, a função é chamada com i = 1; e 'n' é atribuído a um local de memória diferente, ainda identificado por, elemento.
A terceira vez que a função é chamada, i = 2; e 'O' é atribuído a um terceiro local de memória ainda identificado pelo elemento By -REM. A quarta vez que a função é chamada, i = 3; e 'P' é atribuído a um quarto local de memória Remstill identificado pelo elemento. A quinta vez que a função é chamada, i = 4; e 'q' é atribuído a um quinto local de memória ainda identificado pelo elemento.
A sexta vez que a função é chamada, i = 5, que é o tamanho da matriz e a função retorna devido ao if consumo. O tempo todo, a última declaração na função não foi atendida. Esta última afirmação é:
arr [siz-i-1] = elemento;Com esta declaração, o que for mantido por elemento, é atribuído a uma posição de matriz. Lembre -se de que existem cinco locais na memória com o elemento identificador segurando os caracteres: 'm', 'n', 'o', 'p', 'q', nessa ordem.
É verdade que a função retornou vazio, mas a última declaração ainda precisa ser executada, cinco vezes. Para cada chamada da função, a última declaração foi registrada uma vez, na memória. A primeira vez que ele é executado, siz -i -1 = 5 - 0 - 1 = 4; na chamada para a qual a função retorna, mas usando o primeiro índice. E assim,
arr [4] = 'q'Voltando para trás. Na segunda vez que a última declaração é executada, siz -i -1 = 5 - 1 - 1 = 3. E assim,
arr [3] = 'p'
A terceira vez que a última declaração é executada, siz -i -1 = 5 - 2 - 1 = 2. E assim,
arr [2] = 'O'
A quarta vez que a última declaração é executada, siz -i -1 = 5 - 3 - 1 = 1. E assim,
arr [1] = 'n'
A quinta e a última vez que a última declaração é executada, siz -i -1 = 5 - 4 - 1 = 0. E assim,
arr [0] = 'm'
E assim a matriz foi revertida com uma função recursiva.
Uso de std :: reverse ()
O std :: reverse () da biblioteca de algoritmo também pode ser usado para reverter uma matriz, embora não seja óbvio. Para usar esta função, a biblioteca de algoritmo deve ser incluída no programa. O protótipo para a função é:
modeloconstexpr void reverso (bidirectionAterator Primeiro, bidirectionAterator Último);
O primeiro argumento é um iterador apontando para o primeiro elemento de um contêiner. O segundo argumento é outro iterador apontando logo após o último elemento do contêiner. Um ponteiro para o primeiro elemento da matriz pode ser usado como o primeiro argumento. Um ponteiro apontando logo após o último elemento da matriz pode ser usado como o segundo argumento.
Se o nome da matriz for arr, um ponteiro para o primeiro elemento é arr. Um ponteiro apontando logo após o último elemento da matriz é "arr + tamanho", onde o tamanho é o tamanho da matriz. O programa a seguir, mostra como o std :: reverse () pode ser usado para reverter uma matriz:
#incluir#incluir
usando namespace std;
char arr [] = 'm', 'n', 'o', 'p', 'q';
int siz = sizeof (arr)/sizeof (arr [0]); // tamanho da matriz
int main ()
reverso (arr, arr+siz);
para (int i = 0; i
cout<
A saída é:
Q p o n mConclusão
A reversão de uma matriz pode ser feita, usando uma matriz extra, trocando elementos de matriz, usando uma função recursiva ou usando std :: reverse ().