二维数组排序后保留原来的编号

当你需要对二维数组按照某个规则排序，同时保持原始元素的顺序，可以采用一种称为“稳定排序”的算法。稳定的排序算法会在排序过程中保证相等元素之间的相对顺序不会改变。例如，在Python的Pandas库中，你可以先使用`sort_values()`函数对二维数组按某一列排序，然后通过`reset_index(drop=True)`保留原始索引并移除默认添加的新行索引。

import pandas as pd

# 假设有个二维数组df
data = {
   'A': [5, 2, 8, 4],
   'B': ['d', 'a', 'b', 'c']
}

df = pd.DataFrame(data)

# 按照'A'列升序排序
sorted_df = df.sort_values('A', ascending=True, stable=True)

# 保留原索引
sorted_df['Index'] = range(1, len(sorted_df) + 1)
sorted_df.set_index('Index', inplace=True)

sorted_df

在这个例子中，原始数组按'A'列值排序后，原有的行编号作为新的索引被保留在结果中。

相关问题

二维数组排序后保留原来的编号--C语言

在C语言中，如果你想对二维数组按照某种规则进行排序并同时保留原始元素的位置（即保持每个元素的编号不变），你需要先创建一个新的二维数组来存储排序后的结果，并通过遍历原数组的同时记录元素的位置信息。这里假设我们想要按行排序，并保留列索引作为元素的新位置。

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

#define ROWS 3
#define COLS 4

// 定义结构体来保存元素值和位置
typedef struct {
    int value;
    int row, col; // 行、列位置
} Element;

void sort_and_preserve(Element arr[ROWS][COLS], Element sorted_arr[ROWS][COLS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS - 1; j++) { // 注意最后一个元素无需比较
            if (arr[i][j] > arr[i][j + 1]) {
                // 交换两个元素及其位置
                int temp_value = arr[i][j];
                arr[i][j] = arr[i][j + 1];
                arr[i][j + 1] = temp_value;
                
                // 记录新位置到sorted_arr
                sorted_arr[i][j] = temp_value; // 假设value就是新的位置编号
                sorted_arr[i][j + 1] = arr[i][j]; // 原来的位置编号
            }
        }
    }
}

int main() {
    Element unsorted[ROWS][COLS] = {{5, 0, 0}, {2, 1, 0}, {7, 2, 0}}; // 假设这是你要排序的二维数组
    Element sorted[ROWS][COLS];

    sort_and_preserve(unsorted, sorted);

    printf("Original array with position indices:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d (%d,%d) ", unsorted[i][j].value, unsorted[i][j].row, unsorted[i][j].col);
        }
        printf("\n");
    }

    printf("Sorted array with position indices as values:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d (%d,%d) ", sorted[i][j], sorted[i][j], sorted[i][j]); // 因为值本身就是位置编号
        }
        printf("\n");
    }

    return 0;
}

用c语言实现某大奖赛有n(1<n<40)个选手参赛，m (2<m<20)个评委为依次参赛的选手评判打分：最高10分，最低0分。统分规则为：每个选手所得的m个得分中，去掉一个最高分，去掉一个最低分，最后平均为该选手的最后得分。根据n个选手的最后得分从高到低排出名次表，以便确定获奖名单。 输入 输入选手的数目n(1<n<40)，评委的数目m (2<m<20)，以及评委对每位选手的打分。 输出 选手的排名及最终的得分值（小数点后保留两位）。 样例输入 3,5 5.6 7.8 9.4 5.8 8.8 7.8 6.7 8.3 6.9 5.5 6.7 9.2 8.8 8.3 9.0 样例输出 第1名:3号选手,得分8.70 第2名:1号选手,得分7.47 第3名:2号选手,得分7.13

这是一个非常典型的统计问题，需要用到排序和求平均数的知识。以下是可能的C语言实现：

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

typedef struct {
    int id;    //选手编号
    double score;  //选手得分
} Player;

int compare(const void* a, const void* b) {   //用于qsort排序的比较函数
    double a_score = ((Player*)a)->score;
    double b_score = ((Player*)b)->score;
    if (a_score > b_score) {
        return -1;  //从大到小排序
    } else if (a_score < b_score) {
        return 1;
    } else {
        return 0;
    }
}

int main() {
    int n, m;
    printf("请输入选手数n和评委数m：");
    scanf("%d,%d", &n, &m);
    double** scores = (double**) malloc(n * sizeof(double*));
    for (int i = 0; i < n; i++) {
        scores[i] = (double*) malloc(m * sizeof(double));
        printf("请输入第%d个选手的%d个得分：", i+1, m);
        for (int j = 0; j < m; j++) {
            scanf("%lf", &scores[i][j]);
        }
    }
    Player* players = (Player*) malloc(n * sizeof(Player));
    for (int i = 0; i < n; i++) {
        players[i].id = i+1;
        double min_score = 10.0, max_score = 0.0;
        double score_sum = 0.0;
        for (int j = 0; j < m; j++) {
            if (scores[i][j] < min_score) {
                min_score = scores[i][j];
            }
            if (scores[i][j] > max_score) {
                max_score = scores[i][j];
            }
            score_sum += scores[i][j];
        }
        players[i].score = (score_sum - min_score - max_score) / (m-2);  //按照题目要求计算排名得分
    }
    qsort(players, n, sizeof(Player), compare);  //排序
    for (int i = 0; i < n; i++) {
        printf("第%d名:%d号选手,得分%.2lf\n", i+1, players[i].id, players[i].score);
    }
    //释放内存
    for (int i = 0; i < n; i++) {
        free(scores[i]);
    }
    free(scores);
    free(players);
    return 0;
}

需要注意的几点：

1. 输入格式比较特殊，需要用逗号隔开，可以用`scanf`的`%d,%d`格式读入。
2. 由于题目中n和m都比较小，我们可以用二维数组`scores`存储每个选手的得分。如果数据量很大，这种方法可能会导致内存不够用，需要使用其他的数据结构，比如链表或者树。
3. 将选手得分计算出来后，可以用一个结构体数组`players`存储每个选手的编号和得分，而不需要二维数组。
4. 为了方便排序，我们写了一个比较函数`compare`，将得分从大到小排序。C语言中的`qsort`函数需要用到这个比较函数。
5. 最后别忘了释放动态分配的内存，避免内存泄露。