Bubblesort är en enkel och intuitiv sorteringsalgoritm. Den byter upprepade gånger intilliggande element om de är i fel ordning tills matrisen är sorterad. I den här algoritmen 'bubblar' det största elementet upp till slutet av arrayen i varje iteration. Bubblesortering är ineffektivt för stora datamängder, men det är användbart för utbildningsändamål och små datamängder. I den här artikeln kommer vi att implementera bubbelsorteringsalgoritmen i programmeringsspråket C.

Det första steget är att definiera bubbelsorteringsfunktionen. Denna funktion tar en heltalsmatris och storleken på matrisen som parametrar. Funktionen returnerar ingenting eftersom den modifierar den ursprungliga arrayen. Här är funktionsdefinition:

 void bubble_sort(int arr[], int n) { int i, j; for (i = 0; i <n - 1; i++) { for (j="0;" j <n i j++) if (arr[j]> arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } </n>

Funktionen har två slingor. Den yttre slingan löper från det första elementet till det näst sista elementet i arrayen. Den inre slingan löper från det första elementet till det näst sista elementet i den osorterade delen av arrayen. Villkoret för den inre slingan är n - i - 1 eftersom de sista i-elementen i arrayen redan är sorterade.

I varje iteration av den inre slingan jämför vi intilliggande element. Om det vänstra elementet är större än det högra elementet byter vi dem. Efter att den inre slingan är klar är det största elementet garanterat i slutet av den osorterade delen av arrayen.

Nu kan vi skriva huvudfunktionen för att testa vår bubbelsorteringsimplementering. Här är huvudfunktionen tillsammans med föregående del:

C-program:

 #include void bubble_sort(int arr[], int n) { int i, j; for (i = 0; i <n - 1; i++) { for (j="0;" j <n i j++) if (arr[j]> arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } int main() { int arr[] = {64, 34, 25, 12, 22, 11, 90}; int n = sizeof(arr) / sizeof(arr[0]); bubble_sort(arr, n); printf(&apos;Sorted array: &apos;); for (int i = 0; i <n; i++) { printf('%d ', arr[i]); } return 0; < pre> <p>The main function creates an integer array arr of size 7 and initializes it with random numbers. We then calculate the size of the array by dividing the size of the array by the size of an integer element. Next, we call the bubble_sort function to sort the array. Finally, we print the sorted array using a for loop.</p> <p> <strong>When we run the program, we should see the following output:</strong> </p> <pre> Sorted array: 11 12 22 25 34 64 90 </pre> <p>This output shows that our bubble sort implementation correctly sorted the array in ascending order.</p> <p>To run the program, we need to compile it using a C compiler. Here is an example <strong>compilation command for GCC:</strong> </p> <pre> gcc -o bubble_sort bubble_sort.c </pre> <p>This command compiles the bubble_sort.c file and produces an executable file named bubble_sort.</p> <p>In summary, the bubble sort algorithm repeatedly swaps adjacent elements until the array is sorted. The algorithm has a time complexity of O(n<sup>2</sup>), which makes it inefficient for large data sets. However, it is useful for educational purposes and small data sets. We implemented the bubble sort algorithm in C programming language and tested it using a simple example.</p> <h3>Characteristics:</h3> <ul> <li>Bubble sort is a simple sorting algorithm.</li> <li>It works by repeatedly swapping adjacent elements if they are in the wrong order.</li> <li>The algorithm sorts the array in ascending or descending order.</li> <li>It has a time complexity of O(n<sup>2</sup>) in the worst case, where n is the size of the array.</li> </ul> <h3>Usage:</h3> <ul> <li>Bubble sort is useful for educational purposes and small data sets.</li> <li>It is not suitable for large data sets because of its time complexity.</li> </ul> <h3>Advantages:</h3> <ul> <li>Bubble sort is easy to understand and implement.</li> <li>It requires minimal additional memory space to perform the sorting.</li> </ul> <h3>Disadvantages:</h3> <ul> <li>It is not efficient for large data sets because of its time complexity.</li> <li>It has poor performance compared to other sorting algorithms, such as quicksort and mergesort.</li> </ul> <h2>Conclusion:</h2> <p>Bubble sort is a simple and intuitive sorting algorithm that is useful for educational purposes and small data sets. However, its time complexity makes it inefficient for large data sets. Therefore, it is not commonly used in real-world applications. Other sorting algorithms, such as quicksort and mergesort, are more efficient for large data sets.</p> <hr></n;></n>

Denna utdata visar att vår bubblesorteringsimplementering korrekt sorterade arrayen i stigande ordning.

För att köra programmet måste vi kompilera det med en C-kompilator. Här är ett exempel kompileringskommando för GCC:

 gcc -o bubble_sort bubble_sort.c 

Detta kommando kompilerar filen bubble_sort.c och producerar en körbar fil med namnet bubble_sort.

Sammanfattningsvis byter bubbelsorteringsalgoritmen upprepade gånger intilliggande element tills matrisen är sorterad. Algoritmen har en tidskomplexitet på O(n²), vilket gör det ineffektivt för stora datamängder. Det är dock användbart för utbildningsändamål och små datamängder. Vi implementerade bubbelsorteringsalgoritmen i programmeringsspråket C och testade den med ett enkelt exempel.

Egenskaper:

• Bubblesortering är en enkel sorteringsalgoritm.
• Det fungerar genom att upprepade gånger byta intilliggande element om de är i fel ordning.
• Algoritmen sorterar matrisen i stigande eller fallande ordning.
• Den har en tidskomplexitet på O(n²) i värsta fall, där n är storleken på arrayen.

Användande:

• Bubblesort är användbart för utbildningsändamål och små datamängder.
• Det är inte lämpligt för stora datamängder på grund av dess tidskomplexitet.

Fördelar:

• Bubblesort är lätt att förstå och implementera.
• Det kräver minimalt extra minnesutrymme för att utföra sorteringen.

Nackdelar:

• Det är inte effektivt för stora datamängder på grund av dess tidskomplexitet.
• Den har dålig prestanda jämfört med andra sorteringsalgoritmer, såsom quicksort och mergesort.

Slutsats:

Bubblesort är en enkel och intuitiv sorteringsalgoritm som är användbar för utbildningsändamål och små datamängder. Men dess tidskomplexitet gör den ineffektiv för stora datamängder. Därför används det inte ofta i verkliga applikationer. Andra sorteringsalgoritmer, som quicksort och mergesort, är mer effektiva för stora datamängder.