定义函数void select( int a[],int n)，实现一维随机数组a元素进行冒泡法从大到小的排序

以下是实现一维随机数组a元素进行冒泡法从大到小排序的select函数的代码：

void select(int a[], int n) {
    for(int i = 0; i < n-1; i++) {
        for(int j = 0; j < n-i-1; j++) {
            if(a[j] < a[j+1]) {
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

该函数中，第一个for循环表示进行n-1次冒泡，每次冒泡都会将当前未排序的最大值移到数组的最前面；第二个for循环则是对每次冒泡中的相邻两个元素进行比较和交换，使得大的元素往前移动。最终，数组a中的元素就会按照从大到小的顺序排列好。

相关问题

随机生成0到100的10个整数，置于一维数组中，使用选择排序法对其递增排序。java写程序

好的，下面是Java代码实现：

import java.util.Random;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = new int[10]; // 声明一个长度为10的一维数组
        Random random = new Random(); // 创建 Random 类的实例
        System.out.print("随机生成的数组为：");
        for (int i = 0; i < arr.length; i++) { // 循环生成随机整数
            arr[i] = random.nextInt(101); // 生成0到100的随机整数
            System.out.print(arr[i] + " "); // 输出数组元素
        }
        selectSort(arr); // 调用选择排序函数
        System.out.print("\n排序后的数组为：");
        for (int i = 0; i < arr.length; i++) { // 循环遍历数组
            System.out.print(arr[i] + " "); // 输出数组元素
        }
    }

    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i; // 声明一个最小值索引
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) { // 如果后面的数比最小数还小，更新最小值索引
                    minIndex = j;
                }
            }
            if (minIndex != i) { // 如果最小值索引不等于i，交换两个数的位置
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }
}

运行结果：

随机生成的数组为：29 65 63 59 89 47 38 96 64 78 
排序后的数组为：29 38 47 59 63 64 65 78 89 96 

用C语言实现一维数组构建哈夫曼树

哈夫曼树是一种特殊的二叉树，可以用于数据压缩、编码等领域。一维数组构建哈夫曼树的过程可以分为以下几步：

1. 将待构建哈夫曼树的权值存储在一个一维数组中，根据权值大小进行排序。

2. 从数组中选取权值最小的两个节点作为哈夫曼树的左右子节点，构建一个新的父节点。将父节点的权值设置为左右子节点的权值之和。

3. 将新构建的父节点插入到数组中，使得数组仍然保持有序。

4. 重复步骤2和3，直到数组中只剩下一个节点，该节点即为哈夫曼树的根节点。

下面是用C语言实现一维数组构建哈夫曼树的代码示例：

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

#define MAX_SIZE 100

// 定义哈夫曼树节点结构体
typedef struct node {
    int weight;   // 权值
    int parent;   // 父节点下标
    int leftchild;   // 左子节点下标
    int rightchild;  // 右子节点下标
} node;

// 初始化哈夫曼树节点
void init_node(node *huff, int n) {
    for (int i = 0; i < 2 * n - 1; i++) {
        huff[i].weight = 0;
        huff[i].parent = -1;
        huff[i].leftchild = -1;
        huff[i].rightchild = -1;
    }
}

// 选择两个权值最小的节点
void select_min(node *huff, int n, int *min1, int *min2) {
    int i;
    for (i = 0; i < n; i++) {
        if (huff[i].parent == -1) {
            *min1 = i;
            break;
        }
    }
    for (; i < n; i++) {
        if (huff[i].parent == -1 && huff[i].weight < huff[*min1].weight) {
            *min2 = *min1;
            *min1 = i;
        } else if (huff[i].parent == -1 && huff[i].weight < huff[*min2].weight) {
            *min2 = i;
        }
    }
}

// 构建哈夫曼树
void create_huffman_tree(node *huff, int n, int *w) {
    int i, min1, min2;
    init_node(huff, n);
    for (i = 0; i < n; i++) {
        huff[i].weight = w[i];
    }
    for (i = 0; i < n - 1; i++) {
        select_min(huff, n + i, &min1, &min2);
        huff[min1].parent = n + i;
        huff[min2].parent = n + i;
        huff[n + i].leftchild = min1;
        huff[n + i].rightchild = min2;
        huff[n + i].weight = huff[min1].weight + huff[min2].weight;
    }
}

int main() {
    int n, i;
    int w[MAX_SIZE];
    node huff[MAX_SIZE];
    printf("请输入待构建哈夫曼树的节点数：");
    scanf("%d", &n);
    printf("请输入每个节点的权值：\n");
    for (i = 0; i < n; i++) {
        scanf("%d", &w[i]);
    }
    create_huffman_tree(huff, n, w);
    printf("哈夫曼树构建完成！\n");
    return 0;
}

在上述代码中，我们首先定义了一个node结构体，用于存储哈夫曼树的节点信息。然后定义了init_node、select_min和create_huffman_tree三个函数，分别用于初始化节点、选择权值最小的两个节点、构建哈夫曼树。最后在main函数中读入节点数和权值，调用create_huffman_tree函数构建哈夫曼树。