C++排序数组递归

C++ Sorting Array Recursion

本文关键字：递归 数组 排序 C++      更新时间：2023-10-16

我正在创建一个小程序，该程序应该按升序对数组中的整数进行排序，但我非常拘泥于应该使用的算法。我不能遍历数组，必须使用递归函数。我被允许有一个辅助函数，可以找到数组中最小的索引，我已经成功地做到了，但我最难弄清楚如何在递归函数中使用该函数对数组进行排序。这是我到目前为止的代码，我知道我的sortIntegers功能太差了

int main()
{
    int numbers[] = {8, 2, 5, 1, 3};
    sortingIntegers(numbers, 5);
    return 0;
}
void sortingIntegers(int *list, int size) {
    if (size == 1) {
        for (int i = 0; i < size; i++) {
            cout << list[i] << ", ";
        }
    } else {
        for (int z = 0; z < size; z++) {
            if (list[size - 1] == smallestIndex(list)) {
                for (int y = 0; y < size; y++) {
                    swap(list[z], list[y]);
                }
            }
        }
        sortingIntegers(list, size - 1);
    }
}
int smallestIndex(int *array) {
    int smallest = array[0];
    for (int i = 1; i < sizeof(array); i++) {
        if (array[i] < smallest) {
            smallest = array[i];
        }
    }
    return smallest;
}

int main()
{
    int numbers[] = {8, 2, 5, 1, 0};
    sortingIntegers(numbers, 0, 5);
    for (int i=0;i<5;i++)
        cout << numbers[i] << ' ';
    return 0;
}
void sortingIntegers(int *list, int left, int size) {
    if (left == size)
        return;
    int smallest = smallestIndex(list, left, size);
    int c = list[smallest];
    list[smallest] = list[left];
    list[left] = c;
    sortingIntegers(list, left+1 ,size);
}
int smallestIndex(int *array, int left, int size) {
    int smallest = array[left];
    int smIndex = left;
    for (int i = left+1; i < size; i++) {
        if (array[i] < smallest) {
            smallest = array[i];
            smIndex = i;
        }
    }
    return smIndex;
}

这是我基于你的解决方案。首先，sizeof(array)返回指针的大小。其次，我返回最小项的索引，而不是它的值，然后将它和列表中的第一个元素交换。然后我调用从另一个元素（left参数）开始的列表的排序，因为我知道直到left-1的列表已经排序了。

一个完全递归的解决方案：

要对数组进行排序，请找到最小的元素并将其交换到第一个位置。然后对数组的其余部分进行排序，直到只剩下一个元素为止。

要找到数组中最小的元素，请取数组其余部分中-第一个元素和-最小元素中的最小元素，直到只剩下一个元素。

int SmallestIndex(int Array[], int From, int To)
{
  if (From == To-1)
    return From; // Single element left
  // Index of the smallest in the rest
  int Index= SmallestIndex(Array, From + 1, To);
  // Index of the smallest
  return Array[From] < Array[Index] ? From : Index;
}
void Sort(int Array[], int From, int To)
{
  if (From == To-1)
    return; // Single element left
  // Locate the smallest element
  int Index= SmallestIndex(Array, From, To);
  // Swap it to the first place
  int Swap= Array[Index]; Array[Index]= Array[From]; Array[From]= Swap;
  // Sort the rest
  Sort(Array, From + 1, To);
}

用(Array, 0, N)调用Sort。

您可以使用此代码段使用递归对数组进行排序。如果你的数组长度是N递归排序N-1长度的数组，并且你只需要对一个N元素进行排序，或者你可以说是最后一个元素，你就不难这样想了。我给你举一个例子，假设你必须对这个数组进行排序=[50，40，10，30，20]，如果递归给你一个数组=[10，30，40，50，20]这个数组，你只需要把20放在正确的位置就可以对数组进行排序。

private static void sort(int[] array, int length) {
            if (length == 1) return;
            sort(array, length - 1);
    
            var lastIndex = length - 1;
            for (int index = lastIndex; index > 0; index --){
                if (array[index] < array[index - 1]){
                    int temp = array[index];
                    array[index] = array[index - 1];
                    array[index - 1] = temp;
                }
            }
    
        }
相关文章：