CODEWITHSUNDEEP
c++sortingloops
user3067773
user3067773

Reputation: 17

How to sort without using loop

How do I sort an array without using a loop in C++? I think it might use recursion, but I do not know how to implement it.

Upvotes: 0

Views: 12758

Answers (7)

Monis Majeed
Monis Majeed

Reputation: 1378

#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=-1;
             ++i;
         }

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

Below is how to use it

int  main()
{
    int array[] ={1,5,2,7,3};
    int len = sizeof(array)/sizeof(int);
    int *a = sort(array,0,0,len);
    for(int i=0;i<len;i++)
    {
       printf("\n array[%d]->%d",i,a[i]);   
    }
}

Upvotes: 1

Hani Shams
Hani Shams

Reputation: 361

Recursive Selection Sort

#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 << " ";
   }
}

Recursive Insertion Sort

#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 << " ";
   }
}

Upvotes: 1

user3279073
user3279073

Reputation: 1

Well, I'm writing a Python interpreter and didn't write loop yet. I got the codebase from some website and rewrite the loop by some recursion. It works. :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)

Upvotes: 0

Ishpreet
Ishpreet

Reputation: 5880

Use std::sort defined in algorithm header file

#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;
}

Upvotes: 2

P Li
P Li

Reputation: 5232

//C++
void bubblesort(vector<int> &arr, int iteration) {
    if(iteration == 0)
        return;

    bubbleswap(arr, 0, 1, iteration);
    bubblesort(arr, iteration-1);
}


void bubbleswap(vector<int> &arr, int i, int j, int n) {

    if(j>=n)
        return ;

    if(arr[i] < arr[j]){
        swap(arr[i], arr[j]);
    }

    bubbleswap(arr, i+1, j+1, n);
}


void sort(vector<int> &arr) {

    int n = arr.size();

    if(n<=1)
        return ;


    bubblesort(arr, n);

}

Upvotes: 1

hr0m
hr0m

Reputation: 2825

There are more ways to sort an array.

If you are trying to implement a loop recursively, you can check out a wikipedia article. It is well explained under "Recursion computer science". Otherwise you can try to implement different sorting algorithms. The well known are Quicksort and Mergesort. There are many sorting algorithms

Upvotes: 0

rhmiller_ic
rhmiller_ic

Reputation: 110

I think you are looking for the Quicksort Algorithm

Upvotes: 0

Related Questions