Вопрос про циклический сдвиг массива С++

[Юлия12]

Дан массив размера N. Дано целое число k. Осуществить циклический сдвиг содержимого массива на k позицию.

#include<conio.h>
#include<stdio.h>
#include<locale.h>

void main()
{
 setlocale(LC_CTYPE, "Russian");
 int k, i, A[100], N, f;
 printf("введите размер массива: "); 
 scanf_s("%d", &N);
 for (i=0; i<N; i++)
  scanf_s ("%d", &A[i]);
 printf ("введите k= ");
 scanf_s ("%d", &k);
 if(k>0){
  while (k!=0)
  {
   i= N-1;
   f= A[i];
            for(i=N-1; i> 0; i--)
    A[i]= A[i-1];
       A[0]= f;
       k--;
  }
 }
 else
 {
  while (k!=0)
  {
   i= N+1;
   f= A[i];
   for (i=0; i< N-1; i++)
    A[i]= A[i+1];
       A[N]= f;
       k++;
  }
 }
  for (i= 0; i<N; i++)
   printf ("%d ", A[i]);
  _getch();
 }

Влево не получается сдвинуть.
При k= 1 (положительному числу) всё прекрасно работает, т.е {1,2,3} сдвигается на k вправо и получается {3,1,2}.
А вот при k= -1 (отриц. числу) {1,2,3} превращается в {2,3,3}, а должно в {2,3,1}. Вот.

[Carbon]

Как-то так:

#include <stdio.h>
#include <string.h>


int main( int, char ** )
{
	int * array; // массив
	unsigned N; // размер
	int k; // сдвиг
	
	printf( "Input array size:\n" );
	scanf( "%u", &N );
	
	if ( N ) // Если размер массива ненулевой
	{
		array = new int[ N ]; // Создаём массив
		
		// Читаем элементы массива
		printf( "Input %u elements of array:\n", N );
		for ( unsigned i = 0; i < N; ++i ) scanf( "%d", &array[ i ] );
		
		// Размер сдвига
		printf( "Input shift size:\n" );
		scanf( "%u", &k );
		
		// Вычисляем эквивалентный сдвиг
		if ( k < 0 ) k += ( ( -k + N - 1 )/N )*N; 
		else k %= N;
		
		if ( k ) // Если сдвиг есть
		{
			// Массив для хранения сдвигаемой части
			int * temp = new int[ k ];
			// Сдвигаемую часть помещаем в массив
			memmove( temp, &array[ N - k ], k*sizeof( array[ 0 ] ) );
			// Сдвигаем остальную часть в массиве
			memmove( &array[ k ], array, ( N - k )*sizeof( array[ 0 ] ) );
			// перемещаем в начало массива сдвигаемую часть
			memmove( array, temp, k*sizeof( array[ 0 ] ) );
			// Уничтожаем массив
			delete [] temp;
		}
		
		// Разультат
		printf( "Shifted array is:\n" );
		for ( unsigned i = 0; i < N; ++i ) printf( "%d ", array[ i ] );
		
		// Уничтожаем массив
		delete [] array;
	}
	
	getchar();
	
	return 0;
}

[Stilet]

Предлагаю свой вариант:

 int a[5];

void rorr(){
 int k=a[4],i;
 for(i=4;i>=0;i--){a[i+1]=a[i];}
 a[0]=k;
}

int main()
{
 const int k=2;
 int i;
 for(i=0;i<5;i++){
  a[i]=rand();printf("%d \t",a[i]);
 }
 for(i=0;i<k;i++){ rorr();}

 printf("\n");
 for(i=0;i<5;i++){
  printf("%d \t",a[i]);
 }
 getchar();
	return 0;
}

Смысл в том чтоб в цикле перебрать с конца, а последний заранее запомнить чтоб подставить в начало. Код не оптимален но работать будет.

[Carbon]

Можно и циклом сделать. Тогда будет так:

#include <stdio.h>


int main( int, char ** )
{
	int * array; // массив
	unsigned N; // размер
	int k; // сдвиг
	
	printf( "Input array size:\n" );
	scanf( "%u", &N );
	
	if ( N ) // Если размер массива ненулевой
	{
		array = new int[ N ]; // Создаём массив
		
		// Читаем элементы массива
		printf( "Input %u elements of array:\n", N );
		for ( unsigned i = 0; i < N; ++i ) scanf( "%d", &array[ i ] );
		
		// Размер сдвига
		printf( "Input shift size:\n" );
		scanf( "%u", &k );
		
		// Вычисляем эквивалентный сдвиг
		if ( k < 0 ) k += ( ( -k + N - 1 )/N )*N; 
		else k %= N;
		
		if ( k ) // Если сдвиг есть
		{
			for ( int i = 0; i < k; ++i )
			{
				int temp = array[ N - 1 ];
				for ( unsigned j = N - 1; j > 0; --j )
					array[ j ] = array[ j - 1 ];
					
				array[ 0 ] = temp;
			}
		}
		
		// Разультат
		printf( "Shifted array is:\n" );
		for ( unsigned i = 0; i < N; ++i ) printf( "%d ", array[ i ] );
		
		// Уничтожаем массив
		delete [] array;
	}
	
	getchar();
	
	return 0;
}

[Stilet]

Можно и циклом сделать.

Я просто побоялся что преподаватель автору даст на орехи за врядли изучаемое в универах memmove