C语言实现轮转数组

题目:

给定一个数组nums,将数组中的元素向右轮转k个位置,其中k是非负数。

示例一:

输入:nums=[1,2,3,4,5,6,7] , k = 3

输出:[5,6,7,1,2,3,4]

解法1:把最后一位数字移动到数组的第一位,然后将第二位开始的每一位往前移动一位
           这种方法的时间复杂度=O(N^2)
                            空间复杂度=O(1)

rotate(int* arr, int n, int k)
{
	k %= n;
	int i = 0;
	for (i = 0; i < k; i++)
	{
		int tmp = arr[n - 1];
		int j = 0;
		for (j = n - 1; j > 0; j--)
		{
			arr[j] = arr[j - 1];
		}
		arr[0] = tmp;
	}

	int a = 0;
	for (a = 0; a < n; a++)
	{
		printf("%d", arr[a]);
	}
	
}

int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	int n = sizeof(arr) / sizeof(arr[0]);
	int k = 0;
	scanf("%d", &k);
	rotate(arr, n, k);
	return 0;
}

解法2:重新创建一个数组,把需要旋转的拿几个数字放在数组中,然后再把剩余的数放到这个新数组的后面
这种方法的时间复杂度=O(N)
                 空间复杂度=O(N)

void rotate(int* nums, int numsSize, int k) 
{
	int* tmp = (int*)malloc(sizeof(int) * numsSize);
	k = k % numsSize;
	memcpy(tmp, nums + numsSize - k, sizeof(int) * k);
	memcpy(tmp+k, nums, sizeof(int) * (numsSize-k));
	memcpy( nums,tmp,  sizeof(int) * numsSize);
	free(tmp);

}

解法3:原地解决(三旋法)——最优法
这种方法的时间复杂度=O(N)
空间复杂度=O(1) 

void reve(int arr[], int left, int right)
{
	while (left < right)
	{
		int tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
		left++;
		right--;
	}
}
rotate(int* arr, int n, int k)
{
	k %= n;
	reve(arr, n - k, n - 1);
	reve(arr, 0, n - k - 1);
	reve(arr, 0, n - 1);
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	int n = sizeof(arr) / sizeof(arr[0]);
	int k = 0;
	scanf("%d", &k);
	rotate(arr, n, k);
	return 0;
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
时间片轮转算法是一种常见的进程调度算法,它的基本思想是将所有处于就绪状态的进程按照先后顺序排成一个队列,然后每个进程按照一定的时间轮流占用CPU。当一个进程用完它分配的时间片后,它就会被移到队列的末尾,等待下一次调度。 下面是一个简单的C语言实现时间片轮转算法的例子: ``` #include <stdio.h> #include <stdlib.h> #include <stdbool.h> struct process { int pid; // 进程ID int burst_time; // 进程执行时间 int remaining_time; // 进程剩余执行时间 int arrival_time; // 进程到达时间 int waiting_time; // 进程等待时间 int turnaround_time; // 进程周转时间 }; void calculate_waiting_time(struct process *procs, int n, int quantum) { int total_time = 0; // 总执行时间 int remaining_procs = n; // 剩余未执行进程数 int current_time = 0; // 当前时间 int i, j; // 计算剩余执行时间 for (i = 0; i < n; i++) { procs[i].remaining_time = procs[i].burst_time; } // 时间片轮转 while (remaining_procs > 0) { for (i = 0; i < n; i++) { if (procs[i].remaining_time <= 0) { continue; } if (procs[i].remaining_time > quantum) { // 执行一个时间片 current_time += quantum; procs[i].remaining_time -= quantum; } else { // 执行完整个进程 current_time += procs[i].remaining_time; procs[i].remaining_time = 0; remaining_procs--; // 计算等待时间和周转时间 procs[i].turnaround_time = current_time - procs[i].arrival_time; procs[i].waiting_time = procs[i].turnaround_time - procs[i].burst_time; if (procs[i].waiting_time < 0) { procs[i].waiting_time = 0; } total_time += procs[i].waiting_time; } } } // 计算平均等待时间 double avg_waiting_time = (double) total_time / n; printf("Average waiting time: %.2f\n", avg_waiting_time); } int main() { // 创建进程数组 int n = 5; struct process procs[] = { {1, 6, 0, 0, 0, 0}, {2, 8, 0, 1, 0, 0}, {3, 7, 0, 2, 0, 0}, {4, 3, 0, 3, 0, 0}, {5, 4, 0, 4, 0, 0} }; // 计算等待时间 int quantum = 3; calculate_waiting_time(procs, n, quantum); return 0; } ``` 这个例子中,我们定义了一个进程结构体,它包含进程的ID、执行时间、剩余执行时间、到达时间、等待时间和周转时间。然后,我们实现了一个`calculate_waiting_time`函数,它采用时间片轮转算法计算每个进程的等待时间和周转时间,并最终计算出平均等待时间。在`main`函数中,我们创建了一个包含5个进程的进程数组,并调用`calculate_waiting_time`函数计算等待时间,时间片长度为3个时间单位。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值