【C 语言之项目实战】循环移动数组（详细版）

最新推荐文章于 2021-10-22 12:21:48 发布
最新推荐文章于 2021-10-22 12:21:48 发布
阅读量1.4k 收藏 8
点赞数 1
分类专栏： C 语言项目实战 文章标签： 算法 c语言 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45332776/article/details/116333199
版权

目录

1.项目要求
2.定义模块函数
3.各模块函数实现
4.项目源代码

1. 项目要求

1.1 循环移动数组，循环左移一个元素，循环右移一个元素。

1.2 循环左移 k 个元素 ，循环右移 k 个元素。

2. 定义模块函数

2.1 主函数：main()

2.2 打印函数：Print_Array()

2.3 循环左移：Left_Move_Array()

2.4 循环右移：Right_Move_Array()

2.5 逆置法：ReserveArray()

3. 各模块函数实现

3.1 打印函数：Print_Array()

/** 打印函数 */
void Print_Array(int* br, int n)
{
	assert(br != nullptr);
	for (int i = 0; i < n; ++i)
	{
		printf("%4d ", br[i]);
		if ((i + 1) % 10 == 0)			// 10 个元素换行
		{
			printf("\n");
		}
	}
	printf("\n");
}

3.2 逆置法：ReserveArray()

     ①. 算法思想： 逆置法，记录数组的起始位置 left ; 记录数组的末尾位置 right ; left 与 right 互换; 将 left 与 right 进行位置更新，left++，right - -。

     ②. 源程序

/** 交换函数 指针传递 进行交换*/
void Sweap_Int(int* ap, int* bp)
{
	assert(ap != nullptr && bp != nullptr);
	int tmp = *ap;
	*ap = *bp;
	*bp = tmp;
}

/** 逆置法 */
void ReserveArray(int* br, int left, int right)
{
	assert(br != nullptr);
	while (left < right)
	{
		Sweap_Int(&br[left], &br[right]);		// 调用交换函数 进行交换
		left++;
		right--;
	}
	
}

3.3 循环左移：Left_Move_Array()

     ①. 循环左移一位：Left_Move_Array()

     1）算法思想：数组中的数据元素依次向左移动一位，取出第一个元素，循环左移一位，最后将原数组中第一个元素放入到数组末端。

     2）源程序

/** 循环左移一个数据元素 */
void Left_Move_Array(int* br, int n)
{
	assert(br != nullptr && n > 1);		// 数据元素大于 1 进行左移
	int tmp = br[0];					// 取出第一个元素
	for (int i = 0; i < n - 1; ++i)
	{
		br[i] = br[i + 1];				// 循环左移
	}
	br[n - 1] = tmp;					// 将第一个元素放置到数组末端
}

     ②. 循环左移 k 位：Left_Move_Array_k()

     1）算法思想：方法一，调用循环移动一位函数进行移动，此方法算法时间复杂度较高，故采用方法二，通过逆置法进行移动。循环左移 k 个元素，数组前一部分（0 … k - 1）进行逆置，数组后一部分（k … n - 1）进行逆置，最后数组（0 … n - 1）整体逆置。（方法一代码详见项目全部源码，可提供调试，此处不在展示）

     2）源程序

/** 方法二：逆置法 循环左移 k 个元素 */
void Left_Move_Array_k(int* br, int n, int k)
{
	assert(br != nullptr && n > 1);
	ReserveArray(br, 0, k - 1);				// 数组前一部分 0 -- (k - 1) 逆置
	ReserveArray(br, k, n - 1);				// 数组后一部分 k -- (n - 1) 逆置
	ReserveArray(br, 0, n - 1);				// 数组整体逆置
}

3.4 循环右移：Right_Move_Array()

     ①. 循环右移一位：Right_Move_Array()

     1）算法思想：数组中的数据元素依次向右移动一位，取出最后一个元素，循环右移一位，最后将原数组中最后一个元素放入到数组首元素位置。

     2）源程序

/** 循环右移一个数据元素 */
void Right_Move_Array(int* br, int n)
{
	assert(br != nullptr && n > 1);
	int tmp = br[n - 1];				// 取出最后一个元素
	for (int i = n - 1; i > 0; --i)
	{
		br[i] = br[i - 1];				// 循环右移一个元素
	}
	br[0] = tmp;						// 将最后一个元素放置到数组首元素位置
}

     ②. 循环右移 k 位：Right_Move_Array_k()

     1）算法思想：方法一，调用循环移动一位函数进行移动，此方法算法时间复杂度较高，故采用方法二，通过逆置法进行移动。循环右移 k 个元素，数组前一部分（0 … n - k - 1）进行逆置，数组后一部分（n - k … n - 1）进行逆置，最后数组（0 … n - 1）整体逆置。（方法一代码详见项目全部源码，可提供调试，此处不在展示）

     2）源程序

/** 逆置法 循环右移 k 个元素 */
void Right_Move_Array_k(int* br, int n, int k)
{
	assert(br != nullptr && n > 1);			// 数组前一部分 0 -- (n - k - 1) 逆置
	ReserveArray(br, 0, n - k - 1);			// 数组后一部分 (n - k) -- (n - 1) 逆置
	ReserveArray(br, n - k, n - 1);			// 数组整体逆置
	ReserveArray(br, 0, n - 1);
}

3.5 主函数

/** 主函数 */
int main()
{
	const int n = 10;				// 常整型 只可读不可写
	int ar[] = { 12, 23, 34, 45, 56, 67, 78, 89, 90, 100 };

	printf("循环移动之前：\n");
	Print_Array(ar, n);				// 调用打印函数 进行输出打印

	printf("循环左移一位元素之后：\n");
	Left_Move_Array(ar, n);			// 调用左移一位函数 进行数组循环左移一位
	Print_Array(ar, n);

	printf("循环右移一位元素之后：\n");
	Right_Move_Array(ar, n);		// 调用右移一位函数 进行循环数组右移一位
	Print_Array(ar, n);

	printf("循环左移 k 位元素之后：\n");
	Left_Move_Array_k(ar, n, 6);	// 调用左移 k 位函数 进行循环数组左移 6 位
	Print_Array(ar, n);

	printf("循环右移 k 位元素之后：\n");
	Right_Move_Array_k(ar, n, 3);	// 调用右移 k 位函数 进行循环数组右移 3 位
	Print_Array(ar, n);
	return 0;
}

4. 项目源代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

/**
* 要求：
* 循环移动数组
* 循环左移一个元素 循环右移一个元素
* 循环左移 k 个元素  循环右移 k 个元素
* 方法一：调用循环移动一位函数进行移动
* 方法二：逆置法 进行移动（提高算法时间复杂度）
*/

/** 循环左移一个数据元素 */
void Left_Move_Array(int* br, int n)
{
	assert(br != nullptr && n > 1);		// 数据元素大于 1 进行左移
	int tmp = br[0];					// 取出第一个元素
	for (int i = 0; i < n - 1; ++i)
	{
		br[i] = br[i + 1];				// 循环左移
	}
	br[n - 1] = tmp;					// 将第一个元素放置到数组末端
}

/** 循环右移一个数据元素 */
void Right_Move_Array(int* br, int n)
{
	assert(br != nullptr && n > 1);
	int tmp = br[n - 1];				// 取出最后一个元素
	for (int i = n - 1; i > 0; --i)
	{
		br[i] = br[i - 1];				// 循环右移一个元素
	}
	br[0] = tmp;						// 将最后一个元素放置到数组首元素位置
}

/** 方法一：效率较低
// 循环左移 k 个元素
void Left_Move_Array_k(int* br, int n, int k)
{
	assert(br != nullptr && n > 1);
	k = k % n;							// 循环左移 3 个元素和循环左移 13 个元素相同
	if (k >= 0)
	{
		while (k--)						// k 大于 0 左移
		{
			Left_Move_Array(br, n);		// 调用循环左移一位函数 进行循环左移 k 个元素
		}
	}
	else								// k 小于 0 右移
	{
		while (k++)
		{
			Right_Move_Array(br, n);    // 调用循环右移一位函数 进行循环右移 k 个元素
		}
	}
}

//循环右移 k 个数据元素
void Right_Move_Array_k(int* br, int n, int k)
{
	assert(br != nullptr && n > 1);
	Left_Move_Array_k(br, n, -k);		// 调用循环左移 k 个元素， k 小于 0 右移 ，k 大于 0 左移
}
*/

/** 交换函数 */
void Sweap_Int(int* ap, int* bp)
{
	assert(ap != nullptr && bp != nullptr);
	int tmp = *ap;
	*ap = *bp;
	*bp = tmp;
}

/** 逆置法 */
void ReserveArray(int* br, int left, int right)
{
	assert(br != nullptr);
	while (left < right)
	{
		Sweap_Int(&br[left], &br[right]);		// 调用交换函数 进行交换
		left++;
		right--;
	}
	
}

/** 方法二：逆置法 循环左移 k 个元素 */
void Left_Move_Array_k(int* br, int n, int k)
{
	assert(br != nullptr && n > 1);
	ReserveArray(br, 0, k - 1);				// 数组前一部分 0 ... (k - 1) 逆置
	ReserveArray(br, k, n - 1);				// 数组后一部分 k ... (n - 1) 逆置
	ReserveArray(br, 0, n - 1);				// 数组整体逆置
}

/** 方法二：逆置法 循环右移 k 个元素 */
void Right_Move_Array_k(int* br, int n, int k)
{
	assert(br != nullptr && n > 1);			// 数组前一部分 0 ... (n - k - 1) 逆置
	ReserveArray(br, 0, n - k - 1);			// 数组后一部分 (n - k) ... (n - 1) 逆置
	ReserveArray(br, n - k, n - 1);			// 数组整体逆置
	ReserveArray(br, 0, n - 1);
}

/** 打印函数 */
void Print_Array(int* br, int n)
{
	assert(br != nullptr);
	for (int i = 0; i < n; ++i)
	{
		printf("%4d ", br[i]);
		if ((i + 1) % 10 == 0)			// 10 个元素换行
		{
			printf("\n");
		}
	}
	printf("\n");
}

/** 主函数 */
int main()
{
	const int n = 10;				// 常整型 只可读不可写
	int ar[] = { 12, 23, 34, 45, 56, 67, 78, 89, 90, 100 };

	printf("循环移动之前：\n");
	Print_Array(ar, n);				// 调用打印函数 进行输出打印

	printf("循环左移一位元素之后：\n");
	Left_Move_Array(ar, n);			// 调用左移一位函数 进行数组循环左移一位
	Print_Array(ar, n);

	printf("循环右移一位元素之后：\n");
	Right_Move_Array(ar, n);		// 调用右移一位函数 进行循环数组右移一位
	Print_Array(ar, n);

	printf("循环左移六位元素之后：\n");
	Left_Move_Array_k(ar, n, 6);	// 调用左移 k 位函数 进行循环数组左移 6 位
	Print_Array(ar, n);

	printf("循环右移三位元素之后：\n");
	Right_Move_Array_k(ar, n, 3);	// 调用右移 k 位函数 进行循环数组右移 3 位
	Print_Array(ar, n);
	return 0;
}

运行结果
在这里插入图片描述
     循环移动数组改进版《【C 语言之项目实战】循环移动数组（结构体实现）必看》，请点击此处查阅…

WartenSIEl
关注
专栏目录
C语言数组循环移动
萧海的博客
11-23 737
void array_right(int *array,int size) { int last=array[size-1]; /* 全部元素往右移动一个位值 */ for (int i = size-1; i > 0; i--) { array[i] = array[i-1]; } array[0]=last; } void array_left(int *array,int size) { int last=array[0]; /* 全部
数组循环移位的几种解法
热门推荐
chomo的专栏
08-23 2万+
题目描述： 设计一个算法,把一个含有N个元素的数组循环右移K位。解法一: 最容易想到的就是每次将数组中的元素右移一位，循环K次。#include<iostream> using namespace std; void RightShift(int *arr, int N, int K){ while(K--){ int t =
数组元素循环移动
PursueLuo的博客
04-18 8014
数组元素循环移动 数组元素循环移动分为循环左移和循环右移。由于两种情况类似。就以循环右移为例。 数组元素循环右移
数组的循环移动
LilyNothing的博客
03-21 3680
数组的循环移动是考查的算法中比较常见的，有循环左移，循环右移之类的。当然，不会直接就考查移动的算法，还会有一定的时间复杂度，空间复杂度的要求之类的，这才是算法要求的，所以这两天刚好看到类似的题目，就记录一下。题目要求如有数组abcd1234,让数组向右边移动两位，变成了34abcd12。这就是数组的循环右移操作，那么要求在尽可能少的时间复杂度下实现将整个数组移动m次的这个操作。不考虑时间复杂度的实现
数组循环移动
qq_33194825的博客
03-17 379
数组循环右移可以把数组分成两份，第一部分是循环右移的数目，剩下的是另一部分设要移动的为A，剩下的为B那么这个数组的就是AB循环移动后数组变成BA实例：AB = 0    1    2    3    4    5    6    7A    =0    1    2B    =3    4    5    6    7我们需要实现的结果是BA = 3    4    5    6    7    ...
循环移动数组元素
双杯献酒的专栏
09-01 834
// 循环移动数组元素 // 一种大部分数据只移动一次的算法 // 方法: //   将数据循环移动, 可以直接计算出每个数据的最终位置, 直接移动即可 // 分析: //   这种算法基本可看做每个数据只需要移动一次 //   但是每个数据移动的位置需要计算, 算法
嵌入式C实战项目开发技巧:对一个有规律的数组表进行位移操作的方法
08-26
本文主要介绍了嵌入式C实战项目开发技巧中对一个有规律的数组表进行位移操作的方法，并介绍了相关的知识点，包括数组表的位移操作、循环和位运算的结合、C语言实现、延时函数的应用、LED灯的控制、程序设计和软件...
c语言贪吃蛇-项目实战
最新发布
04-20
在本项目中，我们使用C语言来编写贪吃蛇游戏，这将涉及到变量声明、函数定义、条件判断、循环控制等基础知识。 二、游戏框架构建 1. 初始化：游戏开始前，需要初始化游戏环境，包括设置屏幕大小、创建蛇的身体、...
Swift语言教程 ：Swift 项目实战
02-26
本教程“Swift语言教程：Swift项目实战”旨在通过实际项目开发，深入理解Swift语言的各个方面，帮助开发者提升技能并实现应用创新。 一、Swift基础 Swift的基础语法简洁明了，支持类型安全和可选类型，这使得代码...
c语言实战项目游戏源码Turbo C下写的俄罗斯方块
05-30
《C语言实战： Turbo C 下的俄罗斯方块游戏源码解析》 俄罗斯方块是一款经典的电子游戏，由苏联程序员阿列克谢·帕基特诺夫于1984年创作。这款游戏简单易懂，玩法有趣，深受全球玩家喜爱。在IT领域，用C语言编写...
C语言数组元素的循环移位方法
08-27
今天小编就为大家分享一篇C语言数组元素的循环移位方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
C语言项目实战-贪吃蛇
03-05
总的来说，"C语言项目实战-贪吃蛇"是一个综合性的实践项目，涵盖了C语言基础、数据结构和算法等多个重要概念。通过这个项目，你不仅可以巩固C语言的知识，还能提升解决问题和编程设计的能力。在实际操作中，遇到问题...
C语言 数组循环左移问题
weixin_34109408的博客
07-10 649
https://blog.csdn.net/u014453898/article/details/77773216#comments
c语言数组的循环左移,如何将一个数组的元素循环左移？
weixin_42302026的博客
05-22 240
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#include#defineSIZE(a)(sizeof(a)/sizeof(a[0]))#defineHBIT(a)((a&0x00000080)!=0)#defineLBIT(a)((a&0x00000001)!=0)intTAB[]={0x10,0x71,0x12,0x1...
两种方法循环移动数组
weixin_46153828的博客
10-22 824
定义一个数组 int a[10]={1,2,3,4,5,6,7,8,9,10};若将它循环右移两次，结果为{9,10,1,2,3,4,5,6,7,8},若将其循环右移12次，结果也为{9,10,1,2,3,4,5,6,7,8}，所以移动数组，要考虑一个重要的因素就是移动次数需取余(%)数组长度来避免移动次数过多。 方法一代码如下： #include<stdio.h> #define N 10 //n代表元素个数，k代表移动次数，right代表最后一个元素的下标，如果有十个元素，则right值为9
数组的循环移位
零丁若叹
03-22 1166
有数组a[],有n个元素，实现它的循环移位，向左移位k位。有多种方法，这里仅列举三种 （1）申请O(k)的附加空间，先将要移位的k位放入附加空间，把后面的元素前移，然后将这k位数加到数组的尾部。这种方法消耗的空间较多。 代码为： （2）只使用O（1）的空间，定义函数，函数实现的功能是每次移动一位，k次调用函数，即可实现循环移位，这种方式需要多次调用函数，程序的效率会降低 （3）使用翻转的方
关于数组的循环移位
weixin_43712228的博客
12-08 2277
经常可以见到所谓的数组循环移位的问题，那么什么是数组的循环移位呢？数组的循环移位指的是这样一个过程。假设数组构成了一个链环，整个数组作为链环的一个部分存在，那么我们任取这个链环的一部分，可能超过这个数组的长度，也可能小于等于这个数组的长度。现在考虑我们所取的部分长度等于数组的长度，那么它可能是一个完整的链环的一节，但更多情况下，是某一个链环和它相邻链环的一部分。这样得到的部分实际上就是数组循环移位...
C++算法分析与设计——数组 A[n]中所有元素循环左移 k 个位置
瑞新の博客：bennyrhys
03-30 7356
//6. 设计分治算法，实现将数组 A[n]中所有元素循环左移 k 个位置 , 要求时间复杂性为 O(n)，空间复杂性为 O(1)。例如，对 abcdefgh循环左移 3 位得到 defghabc。 // 采用分治法 // 将数组分为 0-k-1 和 k-n-1 两块 // 将这两块分别左移 // 然后再合并左移 #include <iostream> using namespace ...
使用指针实现数组循环移动
05-25
数组循环移动可以通过指针来实现，具体实现过程如下： ```c #include <stdio.h> void cycle_shift(int arr[], int n, int k) { int *p = arr; // 定义指向数组第一个元素的指针 int *q = arr + n - k; // 定义指向数组倒数第k个元素的指针 int temp[k]; // 定义临时数组，用于保存后k个元素 // 将后k个元素保存到临时数组中 for (int i = 0; i < k; i++) { temp[i] = *q++; } // 将前n-k个元素向后移动k个位置 for (int i = 0; i < n - k; i++) { arr[n - i - 1] = *(p + n - k - i - 1); } // 将临时数组中的k个元素放到数组前面 for (int i = 0; i < k; i++) { arr[i] = temp[k - i - 1]; } } int main() { int arr[] = {1, 2, 3, 4, 5, 6, 7}; int n = sizeof(arr) / sizeof(int); int k = 3; printf("Before shift:\n"); for (int i = 0; i < n; i++) { printf("%d ", arr[i]); } cycle_shift(arr, n, k); printf("\nAfter shift:\n"); for (int i = 0; i < n; i++) { printf("%d ", arr[i]); } return 0; } ``` 运行结果如下： ``` Before shift: 1 2 3 4 5 6 7 After shift: 5 6 7 1 2 3 4 ``` 在这个例子中，我们通过指针实现了数组循环移动，其中定义了两个指针p和q，分别指向数组第一个元素和倒数第k个元素。通过指针的移动，我们可以将后k个元素保存到临时数组中，然后将前n-k个元素向后移动k个位置，最后将临时数组中的k个元素放到数组前面，就完成了数组的循环移动。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值