#include<stdio.h> #include<stdlib.h> void swap2(int *p1,int *p2) { int *t; t=p1; p1=p2; p2=t; } void main() { int a=3; int b=5; int *pa=&a,*pb=&b; printf("俩个数据值为%d %d\n",a,b); if(a<b) swap2(pa,pb); printf("互换后的结果为%d %d\n",a,b); system("pause"); }为什么互换不成功

这个程序中的 `swap2` 函数并没有真正交换指针所指向的变量的值，而是只交换了指针本身的值。因此，当 `swap2` 函数返回后，`pa` 和 `pb` 指向的变量并没有发生交换，因此互换不成功。

要让函数真正交换指针所指向的变量的值，应该改为这样：

void swap2(int *p1,int *p2) {
    int t = *p1;
    *p1 = *p2;
    *p2 = t;
}

这样就可以成功交换 `pa` 和 `pb` 指向的变量的值了。

相关问题

实验名称：时间片轮转调度算法实验内容及要求：已知有三个进程P1、P2、P3，单独完成它们所需的时间为21、6、3，假定时间片S=4，运用时间片轮转调度算法打印出调度序列(用队列实现) 用c语言编写代码

实验名称中的“时间片轮转调度算法”是一种常见的处理器调度策略，它将CPU的时间划分为固定大小的时间片，每个时间段内，系统会为各个就绪进程轮流分配CPU资源。在这个实验中，你需要模拟这个过程，并跟踪进程的执行情况。

实验内容及要求包括：
1. 初始化三个进程P1、P2、P3，它们分别需要21、6和3个时间片才能完成任务。
2. 设定一个固定的时间片值S = 4。
3. 使用队列数据结构存储进程及其剩余执行时间。
4. 执行调度算法，即按顺序让每个进程运行4个时间片，然后检查是否所有进程都已完成，如果没有，则将未完成的进程放入队列继续下一轮。
5. 输出整个调度过程中的调度序列，也就是进程执行的次序。

下面是一个简单的C语言伪代码示例，展示了如何用队列实现这一过程：

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

// 定义进程结构体
typedef struct {
    int pid; // 进程ID
    int time_needed; // 进程执行所需时间
    int remaining_time; // 当前剩余时间
} Process;

void processScheduler(queue<Process> &processes, int time_slice) {
    while (!processes.empty()) {
        Process current_process = processes.front();
        processes.pop();

        if (current_process.remaining_time <= time_slice) {
            printf("Process %d executed for %d time slices\n", current_process.pid, current_process.remaining_time);
            current_process.remaining_time -= time_slice;
            if (current_process.remaining_time == 0) {
                printf("Process %d completed\n", current_process.pid);
            } else {
                queue<Process>::iterator it = find_if(processes.begin(), processes.end(), [current_process](const Process &p) { return p.pid == current_process.pid; });
                if (it != processes.end()) {
                    // 如果找到相同的进程，更新其剩余时间并重新插入队列
                    (*it).remaining_time = current_process.remaining_time;
                } else {
                    // 否则，进程已经结束，直接跳出循环
                    break;
                }
            }
        } else {
            // 时间片不足，只执行部分时间
            current_process.remaining_time -= time_slice;
            printf("Process %d executed for %d time slices (partial)\n", current_process.pid, time_slice);
            queue<Process> new_processes;
            for (auto &proc : processes) {
                proc.remaining_time -= time_slice;
                if (proc.remaining_time > 0) {
                    new_processes.push(proc);
                }
            }
            processes.swap(new_processes); // 更新队列
        }
    }
}

int main() {
    queue<Process> processes = { {1, 21, 21}, {2, 6, 6}, {3, 3, 3} };
    int time_slice = 4;

    processScheduler(processes, time_slice);

    return 0;
}

注意这只是一个简化版的示例，实际编码过程中可能还需要处理错误边界和异常情况。在运行这段代码之前，请确保队列库已经包含并且能正确工作。

写C语言代码实现：给定n个圆的整数半径序列，将这些圆放到一个矩形框中，每个圆都与矩形框的底边相切，则圆的不同排列会得到不同的排列长度，如下图： 1.jpg 注意：因为圆的半径可能很大，也可能很小，也许会有这种情况出现： 2.jpg 要求找到使得排列长度最小的n个圆的排列。 输入格式: 第一行输入n值（1≤n≤10）。 第二行输入n个圆的整数半径序列。 输出格式: 第一行输出最小的排列长度，精确到小数点后两位，第三位按四舍五入方式处理。 第二行输出该排列对应的半径序列，各半径之间用一个空格分隔。为方便处理，最末位半径后面存在一个空格。 输入样例1: 3 3 3 3 输出样例1: 18.00 1 2 3 输入样例2: 5 1 3 5 7 9 输出样例2: 44.97 1 4 2 5 3

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>

#define MAX_N 10

// 圆结构体
typedef struct Circle {
    int r; // 半径
    int x; // 圆心横坐标
    int y; // 圆心纵坐标
} Circle;

// 矩形结构体
typedef struct Rectangle {
    int w; // 矩形宽度
    int h; // 矩形高度
} Rectangle;

// 计算两个圆的切点
bool get_tangent_points(Circle c1, Circle c2, Circle* p1, Circle* p2) {
    int d = sqrt(pow(c2.x - c1.x, 2) + pow(c2.y - c1.y, 2)); // 圆心距离
    if (d < c1.r + c2.r) { // 两圆相交
        return false;
    }
    double sin_alpha = (double)(c2.y - c1.y) / d; // sin alpha
    double cos_alpha = (double)(c2.x - c1.x) / d; // cos alpha
    double sin_beta = (double)c1.r / d; // sin beta
    double cos_beta = (double)c2.r / d; // cos beta
    double sin_theta = sin_alpha * cos_beta - cos_alpha * sin_beta; // sin theta
    double cos_theta = cos_alpha * cos_beta + sin_alpha * sin_beta; // cos theta
    p1->x = c1.x + c1.r * cos_theta;
    p1->y = c1.y + c1.r * sin_theta;
    p2->x = c2.x - c2.r * cos_theta;
    p2->y = c2.y - c2.r * sin_theta;
    return true;
}

// 计算圆与矩形的交点
bool get_intersection_point(Circle c, Rectangle r, Circle* p1, Circle* p2) {
    if (c.x - c.r < 0 || c.x + c.r > r.w || c.y - c.r < 0) { // 圆超出矩形
        return false;
    }
    p1->x = c.x;
    p1->y = c.y;
    p2->x = c.x;
    p2->y = r.h;
    return true;
}

// 计算排列长度
double get_permutation_length(Circle* circles, int n) {
    double length = 0;
    for (int i = 1; i < n; i++) {
        Circle p1, p2;
        bool has_tangent_points = false;
        for (int j = i - 1; j >= 0; j--) {
            Circle t1, t2, p3, p4;
            if (get_tangent_points(circles[i], circles[j], &t1, &t2)) {
                if (!has_tangent_points) {
                    p1 = t1;
                    p2 = t2;
                    has_tangent_points = true;
                } else {
                    double d1 = sqrt(pow(t1.x - p2.x, 2) + pow(t1.y - p2.y, 2));
                    double d2 = sqrt(pow(t2.x - p1.x, 2) + pow(t2.y - p1.y, 2));
                    if (d1 < d2) {
                        p1 = t1;
                        p2 = p2;
                    } else {
                        p1 = p1;
                        p2 = t2;
                    }
                }
            }
            if (get_intersection_point(circles[i], (Rectangle){p2.x - p1.x, p2.y}, &p3, &p4)) {
                if (!has_tangent_points) {
                    p1 = p3;
                    p2 = p4;
                    has_tangent_points = true;
                } else {
                    double d1 = sqrt(pow(p3.x - p2.x, 2) + pow(p3.y - p2.y, 2));
                    double d2 = sqrt(pow(p4.x - p1.x, 2) + pow(p4.y - p1.y, 2));
                    if (d1 < d2) {
                        p1 = p3;
                        p2 = p2;
                    } else {
                        p1 = p1;
                        p2 = p4;
                    }
                }
            }
        }
        length += sqrt(pow(p2.x - p1.x, 2) + pow(p2.y - p1.y, 2)) + 2 * circles[i].r;
    }
    return length;
}

// 交换两个圆
void swap(Circle* c1, Circle* c2) {
    Circle tmp = *c1;
    *c1 = *c2;
    *c2 = tmp;
}

// 全排列
void permutation(Circle* circles, int n, int i, double* min_length, Circle* min_circles) {
    if (i == n) {
        double length = get_permutation_length(circles, n);
        if (length < *min_length) {
            *min_length = length;
            for (int j = 0; j < n; j++) {
                min_circles[j] = circles[j];
            }
        }
    } else {
        for (int j = i; j < n; j++) {
            swap(&circles[i], &circles[j]);
            permutation(circles, n, i + 1, min_length, min_circles);
            swap(&circles[i], &circles[j]);
        }
    }
}

int main() {
    int n;
    scanf("%d", &n);
    Circle circles[MAX_N];
    for (int i = 0; i < n; i++) {
        scanf("%d", &circles[i].r);
        circles[i].x = 0;
        circles[i].y = circles[i].r;
    }
    double min_length = INFINITY;
    Circle min_circles[MAX_N];
    permutation(circles, n, 0, &min_length, min_circles);
    printf("%.2f ", min_length);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (circles[j].r == min_circles[i].r) {
                printf("%d ", j + 1);
                break;
            }
        }
    }
    putchar(' ');
    return 0;
}