使用指针从键盘输入10个整数，找出其中最小值

可以使用如下代码实现：

#include <iostream>
using namespace std;

int main() {
    int arr[10];
    int *p = arr;
    int minVal = INT_MAX; // 初始化为最大值

    cout << "请输入10个整数：" << endl;
    for(int i=0; i<10; i++) {
        cin >> *(p+i); // 等价于 cin >> arr[i];
        if(*(p+i) < minVal) { // 等价于 if(arr[i] < minVal)
            minVal = *(p+i);
        }
    }

    cout << "最小值为：" << minVal << endl;
    return 0;
}

其中，定义了一个指针 `p`，指向数组 `arr` 的首地址，使用 `*(p+i)` 可以访问数组中的元素。使用 `INT_MAX` 可以初始化最小值为整型的最大值，这样保证了最小值一定会被更新。

相关问题

设计完整的程序实现以下功能：从键盘上输入3个整数，通过指针运算，找出3个数中的最大值与最小值和它们的地址，并实现最大值与最小值的交换（要求用指针作为函数参数处理）

好的，以下是实现该功能的完整程序：

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void find_max_min(int *a, int *b, int *c, int **max, int **min) {
    *max = *min = a;
    if (*b > **max) {
        *max = b;
    } else if (*b < **min) {
        *min = b;
    }
    if (*c > **max) {
        *max = c;
    } else if (*c < **min) {
        *min = c;
    }
}

int main() {
    int a, b, c;
    printf("请输入3个整数：\n");
    scanf("%d %d %d", &a, &b, &c);
    int *max, *min;
    find_max_min(&a, &b, &c, &max, &min);
    printf("最大值为：%d，地址为：%p\n", *max, max);
    printf("最小值为：%d，地址为：%p\n", *min, min);
    swap(max, min);
    printf("交换后：\n");
    printf("最大值为：%d，地址为：%p\n", *max, max);
    printf("最小值为：%d，地址为：%p\n", *min, min);
    return 0;
}

程序流程解析：

1. 定义了一个 `swap` 函数，用于交换指针指向的值。
2. 定义了一个 `find_max_min` 函数，用于找出三个数中的最大值和最小值，以及它们的指针地址。该函数的参数为三个整型指针和两个指向指针的指针，函数内部通过比较大小，更新最大值和最小值的指针地址。
3. 在 `main` 函数中，首先通过 `scanf` 函数从键盘上输入三个整数，然后调用 `find_max_min` 函数，找出最大值和最小值以及它们的指针地址，并将它们赋值给 `max` 和 `min` 指针。
4. 调用 `swap` 函数，交换 `max` 和 `min` 指针指向的值。
5. 最后输出交换后的最大值和最小值以及它们的地址。

一、从键盘输入6个整数，存入数组a[6]中。要求 1、找出6个数中的最大值和最小值。 2、逆序输出。 3、使用冒泡排序法选择排序从6个数实现从大到小排序，并输出

首先，我们来分步骤解决这个问题：

1. **找出最大值和最小值**：
- 初始化两个变量`max_num`和`min_num`，分别设置为数组的第一个元素 `a[0]`。
- 遍历整个数组 `a[1]` 到 `a[5]`，如果当前元素大于`max_num`，更新`max_num`；如果小于`min_num`，更新`min_num`。
- 遍历结束后，`max_num`和`min_num` 就分别是数组中的最大值和最小值。

2. **逆序输出**：
- 使用两个指针，一个指向数组开始（`a[0]`），另一个指向数组结束（`a[5]`）。
- 然后交换这两个位置上的数字，每次移动较大的指针向左一位，直到两个指针相遇，完成逆序。

3. **冒泡排序算法从大到小排序并输出**：
- 冒泡排序的基本思想是从第一个元素开始，两两比较，如果前面的元素比后面的元素小，则交换它们的位置，这个过程会逐轮将当前未排序部分的最大值“冒”到数组尾部。
- 对于从大到小排序，只需稍作修改：如果前一个元素小于后一个元素，则不交换。
- 重复这个过程，直到数组完全有序，即一轮遍历下来没有发生交换，说明已经排好序。

以下是伪代码形式的示例：

// 定义数组 a 和初始值 max_min
int[] a = {键盘输入的6个整数};
int max_num = a[0];
int min_num = a[0];

// 找出最大值和最小值
for (int i = 1; i < 6; i++) {
    if (a[i] > max_num) {
        max_num = a[i];
    }
    if (a[i] < min_num) {
        min_num = a[i];
    }
}

// 输出最大值和最小值
System.out.println("最大值：" + max_num);
System.out.println("最小值：" + min_num);

// 逆序输出
int reverse_index = 0;
for (int i = 5; i >= 0; i--) {
    System.out.print(a[i]);
    if (i != reverse_index) {
        System.out.print(",");
    }
    reverse_index++;
}

// 冒泡排序
for (int j = 0; j < 5; j++) {
    for (int k = 0; k < 5-j; k++) {
        if (a[k] < a[k+1]) {
            // 保持降序，不交换
        } else {
            int temp = a[k];
            a[k] = a[k+1];
            a[k+1] = temp;
        }
    }
}
System.out.println("\n按从大到小排序后的数组:");
for (int i : a) {
    System.out.print(i + " ");
}