如何在不使用循环的情况下进行排序 如何在C++中使用循环来排序数组？我想它可能使用递归，但我不知道如何实现它。

我想你在寻找的是

我想你在寻找的是

有更多的方法来排序数组

如果您试图递归地实现循环，您可以查看wikipedia的一篇文章。这在“递归计算机科学”中有很好的解释。 否则，您可以尝试实现不同的排序算法。众所周知的是和。

---

有许多排序算法

对数组进行排序的方法有很多种

#include<stdio.h>

int * sort(int *p,int i,int j,int size)
{
     if(i<size)
     { 
         if(j<size-i-1)
         {
             if(p[j]>p[j+1])
             {
                int temp = p[j];
                p[j] = p[j+1];
                p[j+1] = temp;
             }


         }
         else
         {
             j=0;
             ++i;
         }

      p = sort(p,i,++j,size);
   }

如果您试图递归地实现循环，您可以查看wikipedia的一篇文章。这在“递归计算机科学”中有很好的解释。 否则，您可以尝试实现不同的排序算法。众所周知的是和。 有许多排序算法

#包括
#include<stdio.h>

int * sort(int *p,int i,int j,int size)
{
     if(i<size)
     { 
         if(j<size-i-1)
         {
             if(p[j]>p[j+1])
             {
                int temp = p[j];
                p[j] = p[j+1];
                p[j+1] = temp;
             }


         }
         else
         {
             j=0;
             ++i;
         }

      p = sort(p,i,++j,size);
   }

int*排序（int*p，int i，int j，int size）
{
如果（i
#包括
int*排序（int*p，int i，int j，int size）
{
如果（i
//C++
void bubblesort（向量&arr，整数迭代）{
如果（迭代==0）
返回；
bubbleswap（arr，0，1，迭代）；
bubblesort（arr，迭代-1）；
}
void bubbleswap（向量和arr、整数i、整数j、整数n）{
如果（j>=n）
返回；
if（arr[i]//C++
void bubblesort（向量&arr，整数迭代）{
如果（迭代==0）
返回；
bubbleswap（arr，0，1，迭代）；
bubblesort（arr，迭代-1）；
}
void bubbleswap（向量和arr、整数i、整数j、整数n）{
如果（j>=n）
返回；
if（arr[i]算法头文件中定义的

#include <iostream>
#include <algorithm>
using namespace std;

int main() 
{
    int a[]={5,3,4,1,2};
    sort(a,a+5);
    for(int i=0;i<5;i++)
        cout<<a[i]<<" ";         // 1 2 3 4 5
    return 0;
}

#包括
#包括
使用名称空间std；
int main（）
{
int a[]={5,3,4,1,2}；
排序（a，a+5）；
对于（int i=0；i使用算法头文件中定义的

#include <iostream>
#include <algorithm>
using namespace std;

int main() 
{
    int a[]={5,3,4,1,2};
    sort(a,a+5);
    for(int i=0;i<5;i++)
        cout<<a[i]<<" ";         // 1 2 3 4 5
    return 0;
}

#包括
#包括
使用名称空间std；
int main（）
{
int a[]={5,3,4,1,2}；
排序（a，a+5）；
对于（int i=0；i嗯，我正在编写Python解释器，但还没有编写循环。我从某个网站获得了代码库，并通过某种递归重写了循环。它可以工作。：D

def quickSort(arr, low, high):
    def jLoop(low, high, pivot, i, j):
        if j >= high:
            temp = arr[high]
            arr[high] = arr[i+1]
            arr[i+1] = temp
            return (i+1)

        else:
            if arr[j] <= pivot:
                i = i+1
                temp = arr[i]
                arr[i] = arr[j]
                arr[j] = temp
            return jLoop(low, high, pivot, i, j+1)

    def partition(low, high):
        i = (low - 1)
        pivot = arr[high]
        return jLoop(low, high, pivot, i, low)

    def quick(low, high):
        if low < high:
            pi = partition(low, high)
            quick(low, pi-1)
            quick(pi+1, high)

    quick(low, high)

    return arr

my_list = [0, 6, 3, 1, 2, 4, 7, 5]
length = 8
print quickSort(my_list, 0, 7)

my_list = [9, 0, 8, 1, 7, 2, 6, 3, 5, 4]
length = 10
print quickSort(my_list, 0, 9)

def快速排序（arr、低、高）：
def jLoop（低、高、枢轴、i、j）：
如果j>=高：
温度=arr[高]
arr[high]=arr[i+1]
arr[i+1]=温度
返回（i+1）
其他：
如果arr[j]那么，我正在编写Python解释器，但还没有编写循环。我从某个网站获得了代码库，并通过某种递归重写了循环。它可以工作。：D

def quickSort(arr, low, high):
    def jLoop(low, high, pivot, i, j):
        if j >= high:
            temp = arr[high]
            arr[high] = arr[i+1]
            arr[i+1] = temp
            return (i+1)

        else:
            if arr[j] <= pivot:
                i = i+1
                temp = arr[i]
                arr[i] = arr[j]
                arr[j] = temp
            return jLoop(low, high, pivot, i, j+1)

    def partition(low, high):
        i = (low - 1)
        pivot = arr[high]
        return jLoop(low, high, pivot, i, low)

    def quick(low, high):
        if low < high:
            pi = partition(low, high)
            quick(low, pi-1)
            quick(pi+1, high)

    quick(low, high)

    return arr

my_list = [0, 6, 3, 1, 2, 4, 7, 5]
length = 8
print quickSort(my_list, 0, 7)

my_list = [9, 0, 8, 1, 7, 2, 6, 3, 5, 4]
length = 10
print quickSort(my_list, 0, 9)

def快速排序（arr、低、高）：
def jLoop（低、高、枢轴、i、j）：
如果j>=高：
温度=arr[高]
arr[high]=arr[i+1]
arr[i+1]=温度
返回（i+1）
其他：
如果arr[j]递归选择排序

#include <iostream>
#include <vector>
using namespace std;

//----------------------------------------------------------
int recursive_min(vector<int>& a, size_t first) {
   //base case
   if (first + 1 >= a.size()) {
      return first;
   }
   else {
      size_t min_index {first};
      int temp_index {recursive_min(a, first + 1)};
      if (a[min_index] > a[temp_index]) {
         min_index = temp_index;
      }
      return min_index;
   }
}

//----------------------------------------------------------
void selectionSort(vector<int>& a, size_t step = 0) {
   //base case
   if (step + 1 >= a.size()) {
      return;
   }
   else {
      int temp_index {recursive_min(a, step + 1)};
      if (a[step] > a[temp_index]) {
         swap(a[step], a[temp_index]);
      }
      selectionSort(a, step + 1);
   }
}

//---------------------------------------------------------
int main() {
   vector<int> vec {11, 23, 2, 50, 3, 8, 1, 4, 5};
   selectionSort(vec);
   for (int i : vec) {
      cout << i << " ";
   }
}

#include <iostream>
#include <vector>
using namespace std;

int recursive_insert(vector<int>& a, int key, int i) {
   //base case
   if (i <= -1 || a[i] <= key) {
      return i;
   }
   else {
      a[i + 1] = a[i];
      return recursive_insert(a, key, i - 1);
   }
}

//-----------------------------------------------------------------------------
void insertion_sort(vector<int>& a, size_t j = 1) {
   //base case
   if (j >= a.size()) {
      return;
   }
   else {
      int key = a[j];
      int i = recursive_insert(a, a[j], j - 1);
      a[i + 1] = key;
      insertion_sort(a, j + 1);
   }
}

//-----------------------------------------------------------------------------
int main() {
   vector<int> vec {11, 23, 2, 50, 3, 8, 1, 4, 5};
   insertion_sort(vec);
   for (int i : vec) {
      cout << i << " ";
   }
}

#包括
#包括
使用名称空间std；
//----------------------------------------------------------
int递归最小值（向量&a，大小优先）{
//基本情况
如果（第一个+1>=a.size（））{
先返回；
}
否则{
大小最小索引{first}；
int temp_index{recursive_min（a，first+1）}；
如果（a[min\u索引]>a[temp\u索引]）{
最小指数=临时指数；
}
返回最小指数；
}
}
//----------------------------------------------------------
无效选择排序（向量&a，大小\u t步长=0）{
//基本情况
如果（步骤+1>=a.size（））{
返回；
}
否则{
int temp_index{recursive_min（a，step+1）}；
如果（a[步骤]>a[临时索引]）{
交换（一个[步骤]，一个[临时指数]；
}
选择排序（a，步骤+1）；
}
}
//---------------------------------------------------------
int main（）{
向量向量{11,23,2,50,3,8,1,4,5}；
选择排序（vec）；
用于（int i:vec）{
cout递归选择排序

#include <iostream>
#include <vector>
using namespace std;

//----------------------------------------------------------
int recursive_min(vector<int>& a, size_t first) {
   //base case
   if (first + 1 >= a.size()) {
      return first;
   }
   else {
      size_t min_index {first};
      int temp_index {recursive_min(a, first + 1)};
      if (a[min_index] > a[temp_index]) {
         min_index = temp_index;
      }
      return min_index;
   }
}

//----------------------------------------------------------
void selectionSort(vector<int>& a, size_t step = 0) {
   //base case
   if (step + 1 >= a.size()) {
      return;
   }
   else {
      int temp_index {recursive_min(a, step + 1)};
      if (a[step] > a[temp_index]) {
         swap(a[step], a[temp_index]);
      }
      selectionSort(a, step + 1);
   }
}

//---------------------------------------------------------
int main() {
   vector<int> vec {11, 23, 2, 50, 3, 8, 1, 4, 5};
   selectionSort(vec);
   for (int i : vec) {
      cout << i << " ";
   }
}

#include <iostream>
#include <vector>
using namespace std;

int recursive_insert(vector<int>& a, int key, int i) {
   //base case
   if (i <= -1 || a[i] <= key) {
      return i;
   }
   else {
      a[i + 1] = a[i];
      return recursive_insert(a, key, i - 1);
   }
}

//-----------------------------------------------------------------------------
void insertion_sort(vector<int>& a, size_t j = 1) {
   //base case
   if (j >= a.size()) {
      return;
   }
   else {
      int key = a[j];
      int i = recursive_insert(a, a[j], j - 1);
      a[i + 1] = key;
      insertion_sort(a, j + 1);
   }
}

//-----------------------------------------------------------------------------
int main() {
   vector<int> vec {11, 23, 2, 50, 3, 8, 1, 4, 5};
   insertion_sort(vec);
   for (int i : vec) {
      cout << i << " ";
   }
}

#包括
#包括
使用名称空间std；
//----------------------------------------------------------
int递归最小值（向量&a，大小优先）{
//基本情况
如果（第一个+1>=a.size（））{
先返回；
}
否则{
大小最小索引{first}；
int temp_index{recursive_min（a，first+1）}；
如果（a[min\u索引]>a[temp\u索引]）{
最小指数=临时指数；
}
返回最小指数；
}
}
//----------------------------------------------------------
无效选择排序（向量&a，大小\u t步长=0）{
//基本情况
如果（步骤+1>=a.size（））{
返回；
}
否则{
int temp_index{recursive_min（a，step+1）}；
如果（a[步骤]>a[临时索引]）{
交换（一个[步骤]，一个[临时指数]；
}
选择排序（a，步骤+1）；
}
}
//---------------------------------------------------------
int main（）{
向量向量{11,23,2,50,3,8,1,4,5}；
选择排序（vec）；
用于（int i:vec）{
你能描述一下你为什么要这样做，以及到目前为止你尝试了什么吗？你是说“没有任何循环”，还是“没有一个巨大的循环作为主要逻辑？”你对排序算法做了哪些研究？请提供更多关于你的问题的描述，包括你的研究成果。Mergesort是一种非常有名的分而治之的递归算法。Wikipedia和StackOverflow将能够提供你需要的所有信息。如果你不了解递归，我将从这里开始哦，排序的声音…好吧，但是如何在没有循环的情况下实现它-只使用递归？我或多或少了解递归，但我想获取代码并对其进行分析。这将是一个很好的教训。你能描述一下你为什么要这样做以及你迄今为止尝试了什么吗？你的意思是“没有任何循环”，还是“如果主逻辑不是一个巨大的循环？”您对排序算法做了哪些研究？请提供更多信息