Mi a legkönnyebben megvalósítható rendezési algoritmus?


Legjobb válasz

Buborék-rendezés

A Bubble Sort a legegyszerűbb rendezési algoritmus, amely a szomszédos elemek ismételt cseréjével működik, ha rossz sorrendben vannak.

Példa: Első átadás: ( 5 1 4 2 8) -> ( 1 5 4 2 8), Itt az algoritmus összehasonlítja az első két elemet, és 5> 1 óta cserél. (1 5 4 2 8) -> (1 4 5 2 8), Csere 5 óta > 4 (1 4 5 2 8) -> (1 4 2 5 8), Csere 5> 2 óta (1 4 2 5 8 ) -> (1 4 2 5 8 ), Most, hogy ezek az elemek már rendben vannak (8> 5), az algoritmus nem cseréli fel őket.

Második passz: ( 1 4 2 5 8) -> ( 1 4 2 5 8) (1 4 2 5 8) -> (1 2 4 5 8), Csere 4> 2 óta (1 2 4 5 8) -> (1 2 4 5 8) (1 2 4 5 8 ) -> (1 2 4 5 8 ) Most a tömb már rendezve van, b ut algoritmusunk nem tudja, hogy elkészült-e. Az algoritmushoz egy egész átmenetre van szükség bármilyen csere nélkül, hogy tudják, hogy rendezve van.

Harmadik bérlet: ( 1 2 4 5 8) -> ( 1 2 4 5 8) (1 2 4 5 8) -> (1 2 4 5 8) (1 2 4 5 8) -> (1 2 4 5 8) (1 2 4 5 8 ) -> (1 2 4 5 8 )

Példa

// C program for implementation of Bubble sort

#include

void *xp, int *yp)

{

int temp = *xp;

*xp = *yp;

*yp = temp;

}

// A function to implement bubble sort

void bubbleSort(int arr[], int n)

{

int i, j;

for (i = 0; i < n-1; i++)

// Last i elements are already in place

for (j = 0; j < n-i-1; j++)

if (arr[j] > arr[j+1])

swap(&arr[j], &arr[j+1]);

}

/* Function to print an array */

void printArray(int arr[], int size)

{

int i;

for (i=0; i < size; i++)

printf("\%d ", arr[i]);

printf("n");

}

// Driver program to test above functions

int main()

{

int arr[] = {66, 4, 25, 1, 22, 81, 90};

int n = sizeof(arr)/sizeof(arr[0]);

bubbleSort(arr, n);

printf("Sorted array: \n");

printArray(arr, n);

return 0;

}

Köszönöm.

Válasz

Számomra a legkönnyebb rendezési algoritmus a válogatás rendezése, nagyon egyszerű és érthető.Amikor kiválasztási rendezési algoritmust futtat, összehasonlítani fogja az összes értéket az első elemmel, ha a megtalált érték alacsonyabb, mint az első elem, akkor megváltoztatja a legkisebb értékű elemet, és ez így folytatódik.

Hadd mondjak egy példát.

Array => [15,3,22,1,4,14]

min = 15.

  1. összehasonlítva 15-vel, min = 15
  2. összehasonlítva 3-mal, min = 3
  3. összehasonlítva 22-vel, min = 3
  4. összehasonlítás 1-vel, min = 1
  5. összehasonlítás 4-vel, min = 1
  6. hasonlítsa össze a 14, min = 1

Most megtalálta a min (first\_index) elemet. Ki kell cserélni az első elemet és a min elem helyeit, majd folytatni kell, amíg el nem éri az utolsó elemet.

Példa C kód:

#include

void printArray(int arr[], int n) {

//use this function to print array

for (int i = 0; i < n; i++)

printf("\%d, ", arr[i]);

}

void sortArray(int arr[], int n) {

int min\_index = 0;

int temp = 0;

for (int i = 0; i < n; i++) {

min\_index = i;

for (int j = i; j < n; j++) {

//compare min index"s element with new j"s element

//if you want descending sort you can change the binary

//operator > to < .

if (arr[min\_index] > arr[j]) min\_index = j;

}

//change min index"s element and i. element

temp = arr[min\_index];

arr[min\_index] = arr[i];

arr[i] = temp;

}

printArray(arr,n);

}

int arr[] = { 100,5,11,1,22,31,4,2,3 }; //initialize array

printArray(arr,9); //print unsorted array

sortArray(arr,9); //sort array then print it

return 0;

}

Vélemény, hozzászólás?

Az email címet nem tesszük közzé. A kötelező mezőket * karakterrel jelöltük