Question

我知道如何对数组进行排序（即冒泡排序），但我不知道如何根据第n项对数组进行排序。如果有的话，你能给我一些想法或例子吗？谢谢你们所有赞赏的回答。 @edit：程序怎么能用零感测一个数字我的意思是1个程序感应0001或00001 ......？

Example:
2 --> nth digit
4 45 62 1 900 105 --> inputs

输出： 0 0 1 0 0 4 1 0 5 9 0 0 0 4 5 0的 6 5

void bubble_sort(int iarr[], int num) {
   int i, j, k, temp;

   printf("\nUnsorted Data:");
   for (k = 0; k < num; k++) {
      printf("%5d", iarr[k]);
   }

   for (i = 1; i < num; i++) {
      for (j = 0; j < num - 1; j++) {
         if (iarr[j] > iarr[j + 1]) {
            temp = iarr[j];
            iarr[j] = iarr[j + 1];
            iarr[j + 1] = temp;
         }
      }

      printf("\nAfter pass %d : ", i);
      for (k = 0; k < num; k++) {
         printf("%5d", iarr[k]);
      }
   }
}

Answer 1

快速回答是您的比较功能需要查看第n个数字而不是整数。

因此，如果你的原始比较是这样的：

if (a < b)     // handle a before b case
elseif (b < a) // handle b before a case

您需要将其更改为：

aDigit = getNthDigit(a, n);
bDigit = getNthDigit(b, n);

if (aDigit < bDigit)     // handle a before b case
elseif (bDigit < aDigit) // handle b before a case

您还必须实现getNthDigit，这将涉及整数除法和模运算符。

Answer 2

查看qsort了解泛型函数所需的内容。对于您的具体问题，请查看要实现的排序算法（即冒泡排序），并使用对订单函数的函数调用替换元素的比较。然后，您的比较功能应提取第二个数字并比较这些数字。

根据您的代码，您应该使用if (iarr[j] > iarr[j + 1])更改if(comp_gt(iarr[j], iarr[j + 1]))。而且，我会通过

实施comp_gt

int comp_gt(int a, int b)
{
    int a_second_digit = (a / 10) % 10;
    int b_second_digit = (b / 10) % 10;

    return (a_second_digit < b_second_digit);
}

Answer 3

这意味着您可以根据第n位数对数字进行排序。

在您的示例中，您会看到粗体数字（每个数字中的第二个数字）是定义输出顺序的数字。

以下是一个关于如何解决它的示例（我现在正在调整它，因为它用于查找数字的方法是错误的）：

#include <stdio.h>
#include <math.h>

void quickSort(int a[], int first, int last, int n_th);
int pivot(int a[], int first, int last, int n_th);
void swap(int* a, int* b);
int n_th_digit(int number, int n);
void print(int array[], const int N);

int main() {
  int test[] = { 7, 9, 1, 3, 6, 5, 2, 4 };
  int N = sizeof(test) / sizeof(int);
  int n_th = 0;  // digit(from the end) to sort by

  printf("Size of test array : %d\n", N);

  printf("Before sorting : \n");
  print(test, N);

  quickSort(test, 0, N - 1, n_th);

  printf("After sorting : \n");
  print(test, N);

  return 0;
}

/**
 * Quicksort.
 * @param a The array to be sorted.
 * @param first The start of the sequence to be sorted.
 * @param last The end of the sequence to be sorted.
 * @param n_th The digit to sort by
 */
void quickSort(int a[], int first, int last, int n_th) {
  int pivotElement;

  if (first < last) {
    pivotElement = pivot(a, first, last, n_th);
    quickSort(a, first, pivotElement - 1, n_th);
    quickSort(a, pivotElement + 1, last, n_th);
  }
}

/**
 * Find and return the index of pivot element.
 * @param a The array.
 * @param first The start of the sequence.
 * @param last The end of the sequence.
 * @param n_th The digit to sort by
 * For example the third digit of 137
 * requires n_th to be 0.
 *
 */
int pivot(int a[], int first, int last, int n_th) {
  int i, p = first;
  int pivotElement = a[first];

  for (i = first + 1; i <= last; i++) {
    if (n_th_digit(a[i], n_th) <= n_th_digit(pivotElement, n_th)) {
      p++;
      swap(&a[i], &a[p]);
    }
  }

  swap(&a[p], &a[first]);

  return p;
}

/**
 * Swap the parameters.
 * @param a The first parameter.
 * @param a The second parameter.
 */
void swap(int* a, int* b) {
  // You still can use the swap that
  // does not uses an extra variable
  // from the C++ implementation.
  int temp = *a;
  *a = *b;
  *b = temp;
}

int n_th_digit(int number, int n) {
  if (number < 0)
    number *= -1;
  return fmod((number / pow(10, n)), 10);
}

/**
 * Print an array.
 * @param a The array.
 * @param N The size of the array.
 */
void print(int a[], const int N) {
  int i;
  for (i = 0; i < N; i++)
    printf("array[%d] = %d\n", i, a[i]);
}

我了解了如何从here找到第n个数字，从here找到快速排序。

Answer 4

替换

void bubble_sort(int iarr[], int num) {
  ....
  if (iarr[j] > iarr[j + 1])

使用

void bubble_sort(int iarr[], int num, int term) {
  unsigned pow10 = upow10(term - 1);
  ....
  if (compareu(iarr[j], iarr[j + 1], pow10) > 0)

// To calculate pow(10, x) quickly
static unsigned upow10(unsigned y) {
  unsigned z = 1;
  unsigned base = 10;
  while (y) {
    if (y & 1) {
      z *= base;
    }
    y >>= 1;
    base *= base;
  }
  return z;
}

int compareu(int a1, int a2, unsigned pow10) {
  unsigned b1 = abs(a1);
  unsigned b2 = abs(a2);
  b1 = (b1 / pow10) % 10;
  b2 = (b2 / pow10) % 10;
  if (b1 > b2) return 1;
  if (b1 < b2) return -1;
  return (a1 > a2) - (a1 < a2);
}

[编辑]每个OP的更新

问：程序怎么能用零来检测一个数字我的意思是1个程序感应0001或00001？
答：这是读取未发布的输入的代码的一部分。如果代码需要区分“0001”和“00001”，则整个问题是字符串而不是整数。在这种情况下，将每个元素保存为字符串，并从文本的视点进行比较。

但我怀疑这不是真正的编码目标。只需使用算术比较而不关心不同的前导零。

printf()功能是另一回事。要使用引导term打印至少 0个数字，请使用"%0*d"。

term = 2; // or 6 or 9, etc.
// printf("%5d", iarr[k]);
printf("%0*d ", term, iarr[k]);

根据第n个项对数字进行排序

4 个答案: