如何判断选择排序的稳定性

问题遇到的现象和发生背景

问题相关代码，请勿粘贴截图

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

void swap(int a, int b, char* pch, int* pint) {
    char ch = *(pch + a);
    *(pch + a) = *(pch + b);
    *(pch + b) = ch;

    int tmp = *(pint + a);
    *(pint + a) = *(pint + b);
    *(pint + b) = tmp;
}

void BubbleSort(char* pch, int* pint, int n) {
    int i, j;
    for (i = 0; i < n; i++) {
        for (j = n - 1; j >= i + 1; j--) {
            if (*(pint + j) < *(pint + j - 1)) {
                swap(j, j - 1, pch, pint);
            }
        }
    }
}

void SelectionSort(char* pch, int* pint, int n) {
    int i, j;
    for (i = 0; i < n; i++) {
        int mini = i;
        for (j = i; j < n; j++) {
            if (*(pint + j) < *(pint + mini)) {
                mini = j;
            }
        }
        swap(i, mini, pch, pint);
    }
}

int Judge(int* arr_int, char* arr_ch, int* pint, char* pch, int n, int count) {
    int i;
    int j = 0;
    for (i = 0; i < n; i++) {
        if (*(pint + i) == arr_int[j]) {
            if (*(pch + i) == arr_ch[j]) { ; }
            else {
                return 0;
            }
            j++;
        }
    }
    return 1;
}

int main() {
    int n, i, j;
    scanf("%d", &n);
    getchar();
    char* p_ch = (char*)malloc(sizeof(char) * n);
    int* p_int = (int*)malloc(sizeof(int) * n);
    char* p_ch_select = (char*)malloc(sizeof(char) * n);
    int* p_int_select = (int*)malloc(sizeof(int) * n);

    if (!p_ch || !p_int || !p_ch_select || !p_int_select) {
        return 0;
    }

    for (i = 0; i < n; i++) {
        scanf("%c%d", p_ch + i, p_int + i);
        char c = getchar();
        if (c == '\n') {
            break;
        }
    }

    for (i = 0; i < n; i++) {
        *(p_ch_select + i) = *(p_ch + i);
        *(p_int_select + i) = *(p_int + i);
    }

    int mark = 0;
    int arr_int[36] = { 0 };
    char arr_ch[36] = { '0' };
    int count = 0;
    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            if (*(p_int + j) == *(p_int + i)) {
                arr_int[count] = *(p_int + i);
                arr_ch[count] = *(p_ch + i);
                count++;
                mark = 1;
                break;
            }
        }
    }

    for (i = 1; i < count; i++) {
        if (arr_int[i] < arr_int[count - 1]) {
            swap(i, i-1, arr_ch, arr_int);
        }
    }

    BubbleSort(p_ch, p_int, n);
    for (i = 0; i < n; i++) {
        if (i == n - 1) {
            printf("%c%d\n", *(p_ch + i), *(p_int + i));
            break;
        }
        printf("%c%d ", *(p_ch + i), *(p_int + i));

    }
    printf("Stable\n");
    SelectionSort(p_ch_select, p_int_select, n);
    for (i = 0; i < n; i++) {
        if (i == n - 1) {
            printf("%c%d\n", *(p_ch_select + i), *(p_int_select + i));
            break;
        }
        printf("%c%d ", *(p_ch_select + i), *(p_int_select + i));

    }

    if (mark == 0) {
        printf("Stable\n");
    }
    else {
        mark = Judge(arr_int, arr_ch, p_int_select, p_ch_select, n, count);
        if (mark) {
            printf("Stable\n");
        }
        else {
            printf("Not stable\n");
        }
    }
    return 0;
}

运行结果及报错内容

我自己进行多次次测试，结果没问题。提交反馈最后一行的输出有问题。

我的解答思路和尝试过的方法

我的思路是：冒泡排序在有加等号的情况下肯定是稳定的，所以只需要判断选择排序的的稳定性。对于选择排序的稳定性，我的思路是将待排序中所有含相同数值的卡牌的第一张存到数组中。当序列进行完排序之后，对排完的序列进行遍历，当遍历到与数组中的数字相同的元素之后，就去比较他们的字母，如果字母也相同，那么这个两个相同的元素就是稳定的，以此类推，只要有一组含相同元素的数组序列互换了，那么这次排序的就是不稳定的