# Selection Sort

## Selection Sort, Ascending Order, Using Minimum

```c
#include<stdio.h>
#define TOTAL_SIZE 10
void print_array(int *array, int current_size);
void selection_asc_min(int *array, int current_size);

int main(){
    int a[TOTAL_SIZE] = {4, 6, 1, 8, 5, 2, 0, 3, 9, 7}, current_size = 10;
    
    print_array(a, current_size);
    selection_asc_min(a, current_size);
    print_array(a, current_size);

    return 0;
}

void selection_asc_min(int *array, int current_size){
    int i, j, min_index, temp;
    for(i = 0; i < current_size; i++){
        min_index = i;
        for(j = i+1; j < current_size; j++){
            if(array[j] < array[min_index]){
                min_index = j;
            }
        }
        temp = array[i];
        array[i] = array[min_index];
        array[min_index] = temp;
    }
}

void print_array(int *array, int current_size){
    int i;
    if(current_size==0){
        printf("Array is Empty\n");
    }
    else{
        printf("Array Elements are: ");
        for(i=0; i<current_size; i++){
            printf("%d ", array[i]);
        }
        printf("\n");
    }
}
```

## Selection Sort, Ascending Order, Using Maximum

```c
#include<stdio.h>
#define TOTAL_SIZE 10
void print_array(int *array, int current_size);
void selection_asc_max(int *array, int current_size);
void selection_asc_max2(int *array, int current_size);

int main(){
    int a[TOTAL_SIZE] = {4, 6, 1, 8, 5, 2, 0, 3, 9, 7}, current_size = 10;
    
    print_array(a, current_size);
    selection_asc_max(a, current_size);
    //selection_asc_max2(a, current_size);
    print_array(a, current_size);

    return 0;
}

void selection_asc_max(int *array, int current_size){
    int i, j, max_index, temp;
    for(i = current_size-1; i > 0 ; i--){
        max_index = i;
        for(j = 0; j < i; j++){
            if(array[j] > array[max_index]){
                max_index = j;
            }
        }
        temp = array[i];
        array[i] = array[max_index];
        array[max_index] = temp;
    }
}

void selection_asc_max2(int *array, int current_size){
    int i, j, max_index, temp;
    for(i = 0; i < current_size ; i++){
        max_index = 0;
        for(j = 0; j < current_size-i; j++){
            if(array[j] > array[max_index]){
                max_index = j;
            }
        }
        temp = array[current_size-i-1];
        array[current_size-i-1] = array[max_index];
        array[max_index] = temp;
    }
}

void print_array(int *array, int current_size){
    int i;
    if(current_size==0){
        printf("Array is Empty\n");
    }
    else{
        printf("Array Elements are: ");
        for(i=0; i<current_size; i++){
            printf("%d ", array[i]);
        }
        printf("\n");
    }
}
```

## Selection Sort, Descending Order, Using Minimum

```c
#include<stdio.h>
#define TOTAL_SIZE 10
void print_array(int *array, int current_size);
void selection_desc_min(int *array, int current_size);
void selection_desc_min2(int *array, int current_size);

int main(){
    int a[TOTAL_SIZE] = {4, 6, 1, 8, 5, 2, 0, 3, 9, 7}, current_size = 10;
    
    print_array(a, current_size);
    selection_desc_min(a, current_size);
    //selection_desc_min2(a, current_size);
    print_array(a, current_size);

    return 0;
}

void selection_desc_min(int *array, int current_size){
    int i, j, min_index, temp;
    for(i = current_size-1; i >= 0 ; i--){
        min_index = i;
        for(j = 0; j < i; j++){
            if(array[j] < array[min_index]){
                min_index = j;
            }
        }
        temp = array[i];
        array[i] = array[min_index];
        array[min_index] = temp;
    }
}

void selection_desc_min2(int *array, int current_size){
    int i, j, min_index, temp;
    for(i = 0; i < current_size ; i++){
        min_index = 0;
        for(j = 0; j < current_size-i; j++){
            if(array[j] < array[min_index]){
                min_index = j;
            }
        }
        temp = array[current_size-i-1];
        array[current_size-i-1] = array[min_index];
        array[min_index] = temp;
    }
}

void print_array(int *array, int current_size){
    int i;
    if(current_size==0){
        printf("Array is Empty\n");
    }
    else{
        printf("Array Elements are: ");
        for(i=0; i<current_size; i++){
            printf("%d ", array[i]);
        }
        printf("\n");
    }
}
```

## Selection Sort, Descending Order, Using Maximum

```c
#include<stdio.h>
#define TOTAL_SIZE 10
void print_array(int *array, int current_size);
void selection_desc_max(int *array, int current_size);

int main(){
    int a[TOTAL_SIZE] = {4, 6, 1, 8, 5, 2, 0, 3, 9, 7}, current_size = 10;
    
    print_array(a, current_size);
    selection_desc_max(a, current_size);
    print_array(a, current_size);

    return 0;
}

void selection_desc_max(int *array, int current_size){
    int i, j, max_index, temp;
    for(i = 0; i < current_size; i++){
        max_index = i;
        for(j = i+1; j < current_size; j++){
            if(array[j] > array[max_index]){
                max_index = j;
            }
        }
        temp = array[i];
        array[i] = array[max_index];
        array[max_index] = temp;
    }
}

void print_array(int *array, int current_size){
    int i;
    if(current_size==0){
        printf("Array is Empty\n");
    }
    else{
        printf("Array Elements are: ");
        for(i=0; i<current_size; i++){
            printf("%d ", array[i]);
        }
        printf("\n");
    }
}
```

```
#include<stdio.h>

void print_array(int a[], int size);
void selection_sort_descending(int a[], int size);
void selection_sort_descending2(int a[], int size);
void selection_sort_ascending(int a[], int size);
void selection_sort_ascending2(int a[], int size);
void selection_sort_ascending_recursion(int a[], int start, int size);
void selection_sort_descending_recursion(int a[], int size);
int main(){
    int a[10] = {1, 4, 3, 5, 6, 7, 2, 8, 9, 0}, size = 10;
    int i, j, max_pos, temp;

    print_array(a, size);
    //selection_sort_ascending(a, size);
    //selection_sort_ascending2(a, size);
    //selection_sort_ascending_recursion(a, 0, size);
    selection_sort_descending_recursion2(a, size);
    //selection_sort_descending(a, size);
    //selection_sort_descending2(a, size);
    print_array(a, size);

    return 0;
}
void selection_sort_descending_recursion(int a[], int size){
    int i, j, min_pos, temp;
    if(size==0){
        return;
    }
    min_pos = 0;
    for(j=0; j<size; j++){
        if(a[j]<a[min_pos]){
            min_pos = j;
        }
    }
    temp = a[size-1];
    a[size-1] = a[min_pos];
    a[min_pos] = temp;
    selection_sort_descending_recursion(a, size-1);
}
void selection_sort_descending_recursion2(int a[], int size){
    if(size){
        int i, j, min_pos, temp;
        min_pos = 0;
        for(j=0; j<size; j++){
            if(a[j]<a[min_pos]){
                min_pos = j;
            }
        }
        temp = a[size-1];
        a[size-1] = a[min_pos];
        a[min_pos] = temp;
        selection_sort_descending_recursion(a, size-1);
    }
}
void selection_sort_ascending_recursion(int a[], int start, int size){
    int i, j, min_pos, temp;
    if(start == size){
        return;
    }
    min_pos = start;
    for(j=start+1; j<size; j++){
        if(a[j]<a[min_pos]){
            min_pos = j;
        }
    }
    temp = a[start];
    a[start] = a[min_pos];
    a[min_pos] = temp;
    selection_sort_ascending_recursion(a, start+1, size);
}

/*
{1, 4, 3, 5, 6, 7, 2, 8, 9, 0}  {0, 4, 3, 5, 6, 7, 2, 8, 9, 1}
{4, 3, 5, 6, 7, 2, 8, 9, 1}     {1, 3, 5, 6, 7, 2, 8, 9, 4}
{3, 5, 6, 7, 2, 8, 9, 4}        {2, 5, 6, 7, 3, 8, 9, 4}
{5, 6, 7, 3, 8, 9, 4}           {3, 6, 7, 5, 8, 9, 4}
{6, 7, 5, 8, 9, 4}              {4, 7, 5, 8, 9, 6}
{7, 5, 8, 9, 6}                 {5, 7, 8, 9, 6}
{7, 8, 9, 6}                    {6, 8, 9, 7}
{8, 9, 7}                       {7, 9, 8}
{9, 8}                          {8, 9}
{9}                             {9}
{}
*/


```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mun.gitbook.io/c/c/ch7/basic-array-operation/sorting/selection-sort.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.