氣泡使用遞歸對數組排序（無循環）C ++

Question

#include <iostream>
#include <cstdlib>

using std:: cin;
using std:: cout;
using std:: endl;

const int N=10;

void readarray(int array[], int N);
int bubble_sort (int array[], int size, int round,
                 int place);

int main ()
{
    int array[N];
    readarray( array, N );

    int round, place;
    cout << bubble_sort(array, N, place, round);


    return EXIT_SUCCESS;
}


void readarray(int array[], int N)
{
    int i=0;
    if (i < N)
    {
        cin >> array[i];
        readarray(array+1, N-1);
    }
}


int bubble_sort (int array[], int size, int round,
                int place)
{
    round =0;
    place =0;

  if (round < N-1) // this goes over the array again making sure it has 
                   // sorted from lowest to highest
  {
     if (place < N - round -1) // this sorts the array only 2 cells at a 
                               // time
         if (array[0] > array[1])
         {
            int temp = array[1];
            array[1]=array[0];
            array[0]=temp;
            return (array+1, size-1, place+1, round);
         }
   return (array+1, size-1, place, round+1);
   }
}

我知道如何使用兩個for循環來進行冒泡排序，而我想使用遞歸來進行。 使用循環，您需要兩個for循環，而我想進行遞歸，則可能還需要兩個遞歸函數/調用。 到目前為止，這就是我所擁有的。 問題是它只輸出一個數字，即1或0。我不確定我的申報表是否正確。

Answer 1

在c ++ 11中，您可以執行以下操作：

#include <iostream>
#include <vector>


void swap(std::vector<int &numbers, size_t i, size_t j)
{
    int t = numbers[i];
    numbers[i] = numbers[j];
    numbers[j] = t;
}

bool bubble_once(std::vector<int> &numbers, size_t at)
{
    if (at >= numbers.size() - 1)
        return false;
    bool bubbled = numbers[at] > numbers[at+1];
    if (bubbled)
        swap(numbers, at, at+1);
    return bubbled or bubble_once(numbers, at + 1);
}

void bubble_sort(std::vector<int> &numbers)
{
    if ( bubble_once(numbers, 0) )
        bubble_sort(numbers);
}

int main() {
    std::vector<int> numbers = {1,4,3,6,2,3,7,8,3};
    bubble_sort(numbers);

    for (size_t i=0; i != numbers.size(); ++i)
        std::cout << numbers[i] << ' ';
}

通常，您可以使用以下遞歸函數替換每個循環：

1. 檢查警衛->如果失敗返回。
2. 否則執行身體
3. 遞歸調用函數，通常帶有遞增的計數器或其他內容。

但是，為了防止（n個實際的） 堆棧溢出 ，在循環同樣足夠的情況下避免遞歸是一種好習慣。 此外，循環具有非常規范的形式，因此對於許多程序員來說很容易閱讀，而遞歸可以在許多程序中完成，因此很難閱讀，測試和驗證。 哦，由於創建新的堆棧框架，遞歸通常較慢（需要引用，但不太確定）。

編輯

使用普通數組：

#include <iostream>
#include <vector>

#define N 10

void swap(int *numbers, size_t i, size_t j)
{
    int t = numbers[i];
    numbers[i] = numbers[j];
    numbers[j] = t;
}

bool bubble_once(int *numbers, size_t at)
{
    if (at >= N - 1)
        return false;
    bool bubbled = numbers[at] > numbers[at+1];
    if (bubbled)
        swap(numbers, at, at+1);
    return bubbled or bubble_once(numbers, at + 1);
}

void bubble_sort(int *numbers)
{
    if ( bubble_once(numbers, 0) )
        bubble_sort(numbers);
}

int main() {
    int numbers[N] = {1,4,3,6,2,3,7,8,3,5};
    bubble_sort(numbers);

    for (size_t i=0; i != N; ++i)
        std::cout << numbers[i] << ' ';
}

Answer 2

請閱讀這篇文章

function pass(i,j,n,arr)
{
  if(arr[i]>arr(j))
    swap(arr[i],arr[j]);

  if(j==n)
  {
    j=0;
    i=i+1;
  }
  if(i==n+1)
    return arr;

  return pass(i,j+1,n,arr);
}