c两个数组合并成一个有序数组并去重

假设两个数组分别为arr1和arr2，以下是一种可能的实现方法：

1. 将arr1和arr2合并为一个数组arr3：

arr3 = arr1 + arr2

2. 对arr3进行排序：

arr3.sort()

3. 去重：

arr3 = list(set(arr3))

完整代码如下：

arr1 = [1, 3, 5, 7, 9]
arr2 = [2, 4, 6, 8, 10]
arr3 = arr1 + arr2
arr3.sort()
arr3 = list(set(arr3))
print(arr3)

输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

相关问题

C语言合并数组并且转为有序去重集合

以下是一个示例代码，用于将两个数组合并为一个有序且去重的集合：

#include <stdio.h>

void merge(int arr1[], int len1, int arr2[], int len2, int result[], int *len) {
    int i = 0, j = 0, k = 0;
    while (i < len1 && j < len2) {
        if (arr1[i] < arr2[j]) {
            result[k++] = arr1[i++];
        } else if (arr1[i] > arr2[j]) {
            result[k++] = arr2[j++];
        } else {
            result[k++] = arr1[i++];
            j++;
        }
    }
    while (i < len1) {
        result[k++] = arr1[i++];
    }
    while (j < len2) {
        result[k++] = arr2[j++];
    }
    *len = k;
}

void sort(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++) {
        for (j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

void dedup(int arr[], int *len) {
    int i, j;
    for (i = 0, j = 0; j < *len; j++) {
        if (arr[i] != arr[j]) {
            arr[++i] = arr[j];
        }
    }
    *len = i + 1;
}

int main() {
    int arr1[] = {1, 3, 5, 7, 9};
    int len1 = sizeof(arr1) / sizeof(arr1[0]);

    int arr2[] = {2, 4, 6, 8, 10};
    int len2 = sizeof(arr2) / sizeof(arr2[0]);

    int result[100];
    int len = 0;

    merge(arr1, len1, arr2, len2, result, &len);
    sort(result, len);
    dedup(result, &len);

    int i;
    for (i = 0; i < len; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");

    return 0;
}

在这个示例中，我们首先定义了两个数组 `arr1` 和 `arr2`，并分别计算它们的长度。然后我们定义了一个 `result` 数组，用于存放合并后的结果。我们还定义了一个 `len` 变量，用于表示 `result` 数组的长度。

我们调用了 `merge` 函数，将 `arr1` 和 `arr2` 合并到 `result` 数组中，同时更新了 `len` 变量。然后我们调用了 `sort` 函数，将 `result` 数组排序。最后我们调用了 `dedup` 函数，将 `result` 数组去重。

在 `dedup` 函数中，我们使用了两个指针 `i` 和 `j`，分别表示当前已经去重过的元素的末尾位置和当前正在处理的元素的位置。我们从头开始遍历数组，如果当前元素不等于前一个已经去重过的元素，就将它加入到已去重的序列中。

最后，我们打印了去重后的结果。

对一个班某门课程成绩进行处理，用顺序表实现对一个班的一门课程成绩信息的显示、查询、插入、删除功能，并对已排好序（非递减有序）的两个班成绩合并 （用c语言）

对于一个班的一门课程成绩信息，我们可以使用顺序表来实现其显示、查询、插入和删除功能。顺序表是一种基于数组实现的线性数据结构，它的主要优势是支持随机访问，可以方便地进行元素的查找、插入和删除等操作。

具体来说，对于一个班的成绩信息，我们可以使用一个结构体来表示每个学生的成绩记录，如下所示：

typedef struct {
    char name[20];  // 学生姓名
    int score;      // 学生成绩
} ScoreRecord;

然后，我们可以使用一个数组来存储该班所有学生的成绩记录，如下所示：

#define MAX_SIZE 100  // 最大容量

ScoreRecord scoreList[MAX_SIZE];  // 成绩列表
int length = 0;  // 列表长度

接下来，我们可以依次实现以下功能：

1. 显示成绩信息：遍历数组，依次输出每个学生的姓名和成绩即可。

2. 查询成绩信息：遍历数组，查找指定学生的成绩记录，如果找到则输出其姓名和成绩。

3. 插入成绩信息：先查找要插入的位置，然后将后面的元素依次后移一位，最后在指定位置插入新的记录。

4. 删除成绩信息：先查找要删除的位置，然后将后面的元素依次前移一位，最后将列表长度减一。

5. 合并两个班的成绩信息：将两个班的成绩列表合并为一个有序列表，并去重。

以下是代码示例：

#include <stdio.h>
#include <string.h>

// 学生成绩记录
typedef struct {
    char name[20];  // 学生姓名
    int score;      // 学生成绩
} ScoreRecord;

#define MAX_SIZE 100  // 最大容量

ScoreRecord scoreList[MAX_SIZE];  // 成绩列表
int length = 0;  // 列表长度

// 显示成绩信息
void displayScores() {
    printf("姓名\t成绩\n");
    for (int i = 0; i < length; i++) {
        printf("%s\t%d\n", scoreList[i].name, scoreList[i].score);
    }
}

// 查询成绩信息
void queryScore(char* name) {
    for (int i = 0; i < length; i++) {
        if (strcmp(scoreList[i].name, name) == 0) {
            printf("%s的成绩为%d\n", name, scoreList[i].score);
            return;
        }
    }
    printf("%s未找到\n", name);
}

// 插入成绩信息
void insertScore(char* name, int score) {
    if (length >= MAX_SIZE) {
        printf("已达到最大容量\n");
        return;
    }
    int i;
    for (i = length - 1; i >= 0; i--) {
        if (strcmp(scoreList[i].name, name) > 0) {
            scoreList[i + 1] = scoreList[i];
        } else {
            break;
        }
    }
    strcpy(scoreList[i + 1].name, name);
    scoreList[i + 1].score = score;
    length++;
}

// 删除成绩信息
void deleteScore(char* name) {
    int i;
    for (i = 0; i < length; i++) {
        if (strcmp(scoreList[i].name, name) == 0) {
            break;
        }
    }
    if (i == length) {
        printf("%s未找到\n", name);
    } else {
        for (; i < length - 1; i++) {
            scoreList[i] = scoreList[i + 1];
        }
        length--;
        printf("%s已删除\n", name);
    }
}

// 合并两个班的成绩信息（去重）
void mergeScores(ScoreRecord* scores1, int length1, ScoreRecord* scores2, int length2, ScoreRecord* mergedScores, int* mergedLength) {
    int i = 0, j = 0, k = 0;
    while (i < length1 && j < length2) {
        if (strcmp(scores1[i].name, scores2[j].name) < 0) {
            mergedScores[k++] = scores1[i++];
        } else if (strcmp(scores1[i].name, scores2[j].name) > 0) {
            mergedScores[k++] = scores2[j++];
        } else {
            mergedScores[k++] = scores1[i++];
            j++;
        }
    }
    while (i < length1) {
        mergedScores[k++] = scores1[i++];
    }
    while (j < length2) {
        mergedScores[k++] = scores2[j++];
    }
    *mergedLength = k;
}

int main() {
    // 初始化班级A的成绩列表（已排序）
    ScoreRecord scoresA[] = {{"张三", 80}, {"李四", 90}, {"王五", 85}, {"赵六", 92}};
    int lengthA = sizeof(scoresA) / sizeof(scoresA);

    // 初始化班级B的成绩列表（已排序）
    ScoreRecord scoresB[] = {{"李四", 92}, {"孙七", 87}, {"周八", 88}, {"钱九", 93}};
    int lengthB = sizeof(scoresB) / sizeof(scoresB);

    // 显示班级A的成绩列表
    printf("班级A的成绩列表：\n");
    for (int i = 0; i < lengthA; i++) {
        printf("%s\t%d\n", scoresA[i].name, scoresA[i].score);
    }

    // 显示班级B的成绩列表
    printf("\n班级B的成绩列表：\n");
    for (int i = 0; i < lengthB; i++) {
        printf("%s\t%d\n", scoresB[i].name, scoresB[i].score);
    }

    // 合并班级A和班级B的成绩列表，并去重
    ScoreRecord mergedScores[MAX_SIZE];
    int mergedLength;
    mergeScores(scoresA, lengthA, scoresB, lengthB, mergedScores, &mergedLength);

    // 显示合并后的成绩列表
    printf("\n合并后的成绩列表：\n");
    for (int i = 0; i < mergedLength; i++) {
        printf("%s\t%d\n", mergedScores[i].name, mergedScores[i].score);
    }

    return 0;
}