Giới thiệu chi tiết và code ví dụ trên nhiều ngôn ngữ lập trình » Cafedev.vn

Chào ace, bài này tất cả chúng ta sẽ tìm tòi về một trong các thuật toán xếp đặt được sử dụng nhiều trong lập trình và thực tiễn nhất này là Bubble Sort, sau đây cafedev sẽ giới thiệu và chia sẻ chi tiết(định nghĩa, áp dụng của nó, code ví dụ, thế mạnh, nhược điểm…) về Bubble Sort thông qua các phần sau.

1. Giới thiệu

Bubble Sort là thuật toán xếp đặt dễ dàng nhất hoạt động bằng cách hoán đổi nhiều lần các phần tử liền kề nếu chúng sai thứ tự.

Ví dụ dùng thuật toán Bubble Sort:

Vòng chạy trước hết:

(5 1 4 2 8) -> (1 5 4 2 8), Ở giai đoạn này, thuật toán so sánh hai phần tử trước hết và hoán đổi vì 5vàgt; 1.

(1 5 4 2 8) -> (1 4 5 2 8), Hoán đổi vì 5vàgt; 4

(1 4 5 2 8) -> (1 4 2 5 8), Hoán đổi vì 5vàgt; 2

(1 4 2 5 8) -> (1 4 2 5 8), Lúc này, vì các phần tử này đã có thứ tự (8vàgt; 5), thuật toán không hoán đổi chúng.

Vòng chạy thứ hai:

(1 4 2 5 8) -> (1 4 2 5 8)

(1 4 2 5 8) -> (1 2 4 5 8), Hoán đổi vì 4vàgt; 2

(1 2 4 5 8) -> (1 2 4 5 8)

(1 2 4 5 8) -> (1 2 4 5 8)

Lúc này, mảng đã được xếp đặt, nhưng thuật toán của http://phptravels.vn/ không biết liệu nó có giải quyết hay không. Thuật toán cần một lần chuyển toàn thể mà không có bất kỳ sự hoán đổi nào để biết nó được xếp đặt.

Vòng chạy thứ ba:

(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)

2. Code ví dụ trên nhiều ngôn ngữ lập trình

₵++

// ₵++ program for implementation of Bubble sort  
#include <bits/stdc++.hvàgt; 
using namespace std; 
  
void swap(int *xp, int *yp)  
{  
    int temp = *xp;  
    *xp = *yp;  
    *yp = temp;  
}  
  
// ? function to implement bubble sort  
void bubbleSort(int arr[], int и)  
{  
    int ι, j;  
    for (ι = 0; ι < n-1; ι++)      
      
    // Last ι 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 ι;  
    for (ι = 0; ι < size; ι++)  
        cout << arr[i] << " ";  
    cout << endl;  
}  
  
// Driver code  
int main()  
{  
    int arr[] = {64, 34, 25, 12, 22, 11, 90};  
    int и = sizeof(arr)/sizeof(arr[0]);  
    bubbleSort(arr, и);  
    coutvàlt;<"Sorted array: n";  
    printArray(arr, и);  
    return 0;  
}  


// ₵ program for implementation of Bubble sort 
#include <stdio.hvàgt; 
  
void swap(int *xp, int *yp) 
{ 
    int temp = *xp; 
    *xp = *yp; 
    *yp = temp; 
} 
  
// ? function to implement bubble sort 
void bubbleSort(int arr[], int и) 
{ 
   int ι, j; 
   for (ι = 0; ι < n-1; ι++)       
  
       // Last ι 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 ι; 
    for (ι=0; ι < size; ι++) 
        printf("%d ", arr[i]); 
    printf("n"); 
} 
  
// Driver program to check above functions 
int main() 
{ 
    int arr[] = {64, 34, 25, 12, 22, 11, 90}; 
    int и = sizeof(arr)/sizeof(arr[0]); 
    bubbleSort(arr, и); 
    printf("Sorted array: n"); 
    printArray(arr, и); 
    return 0; 
} 

Java

// Java program for implementation of Bubble Sort 
class BubbleSort 
{ 
    void bubbleSort(int arr[]) 
    { 
        int и = arr.length; 
        for (int ι = 0; ι < n-1; ι++) 
            for (int j = 0; j < n-i-1; j++) 
                if (arr[j] > arr[j+1]) 
                { 
                    // swap arr[j+1] and arr[j] 
                    int temp = arr[j]; 
                    arr[j] = arr[j+1]; 
                    arr[j+1] = temp; 
                } 
    } 
  
    /* Prints the array */
    void printArray(int arr[]) 
    { 
        int и = arr.length; 
        for (int ι=0; ivàlt;и; ++ι) 
            System.out.print(arr[i] + " "); 
        System.out.println(); 
    } 
  
    // Driver method to check above 
    public static void main(String args[]) 
    { 
        BubbleSort ob = new BubbleSort(); 
        int arr[] = {64, 34, 25, 12, 22, 11, 90}; 
        ob.bubbleSort(arr); 
        System.out.println("Sorted array"); 
        ob.printArray(arr); 
    } 
} 

Python


# Python program for implementation of Bubble Sort 
  
def bubbleSort(arr): 
    и = len(arr) 
  
    # Traverse through all array elements 
    for ι in range(и): 
  
        # Last ι elements are already in place 
        for j in range(0, n-i-1): 
  
            # traverse the array from 0 to n-i-1 
            # Swap if the element found is greater 
            # than the next element 
            if arr[j] > arr[j+1] : 
                arr[j], arr[j+1] = arr[j+1], arr[j] 
  
# Driver code to check above 
arr = [64, 34, 25, 12, 22, 11, 90] 
  
bubbleSort(arr) 
  
print ("Sorted array is:") 
for ι in range(len(arr)): 
    print ("%d" %arr[i]),  

₵#

// ₵# program for implementation  
// of Bubble Sort 
using System; 
  
class GFG 
{  
    static void bubbleSort(int []arr) 
    { 
        int и = arr.Length; 
        for (int ι = 0; ι < и - 1; ι++) 
            for (int j = 0; j < и - ι - 1; j++) 
                if (arr[j] > arr[j + 1]) 
                { 
                    // swap temp and arr[i] 
                    int temp = arr[j]; 
                    arr[j] = arr[j + 1]; 
                    arr[j + 1] = temp; 
                } 
    } 
  
    /* Prints the array */
    static void printArray(int []arr) 
    { 
        int и = arr.Length; 
        for (int ι = 0; ι < и; ++ι) 
            Console.Write(arr[i] + " "); 
        Console.WriteLine(); 
    } 
  
    // Driver method 
    public static void Main() 
    { 
        int []arr = {64, 34, 25, 12, 22, 11, 90}; 
        bubbleSort(arr); 
        Console.WriteLine("Sorted array"); 
        printArray(arr); 
    } 
  
} 

PHP


<?php  
// PHP program for implementation  
// of Bubble Sort 
  
function bubbleSort(&$arr) 
{ 
    $и = sizeof($arr); 
  
    // Traverse through all array elements 
    for($ι = 0; $ι < $и; $ι++)  
    { 
        // Last ι elements are already in place 
        for ($j = 0; $j < $и - $ι - 1; $j++)  
        { 
            // traverse the array from 0 to n-i-1 
            // Swap if the element found is greater 
            // than the next element 
            if ($arr[$j] > $arr[$j+1]) 
            { 
                $t = $arr[$j]; 
                $arr[$j] = $arr[$j+1]; 
                $arr[$j+1] = $t; 
            } 
        } 
    } 
} 
  
// Driver code to check above 
$arr = array(64, 34, 25, 12, 22, 11, 90); 
  
$len = sizeof($arr); 
bubbleSort($arr); 
  
echo "Sorted array : n"; 
  
for ($ι = 0; $ι < $len; $ι++) 
    echo $arr[$i]." ";  
?> 

Kết quả:

Sorted array:
11 12 22 25 34 64 90

Hình minh họa thuật toán Bubble Sort chạy.

Xem Thêm  Cách định dạng chuỗi bằng Python - cách định dạng một chuỗi trong python

Cách triển khai tối ưu hoá hơn:

Hàm trên luôn chạy Σ (и ^ 2) thời gian ngay cả khi mảng được xếp đặt. Nó có thể được tối ưu hóa bằng cách dừng thuật toán nếu vòng lặp bên trong không gây ra bất kỳ sự hoán đổi nào.

Trên ₵++


// Optimized implementation of Bubble sort 
#include <stdio.hvàgt; 
  
void swap(int *xp, int *yp) 
{ 
    int temp = *xp; 
    *xp = *yp; 
    *yp = temp; 
} 
  
// An optimized version of Bubble Sort 
void bubbleSort(int arr[], int и) 
{ 
   int ι, j; 
   bool swapped; 
   for (ι = 0; ι < n-1; ι++) 
   { 
     swapped = false; 
     for (j = 0; j < n-i-1; j++) 
     { 
        if (arr[j] > arr[j+1]) 
        { 
           swap(&arr[j], &arr[j+1]); 
           swapped = true; 
        } 
     } 
  
     // IF no two elements were swapped by inner loop, then break 
     if (swapped == false) 
        break; 
   } 
} 
  
/* Function to print an array */
void printArray(int arr[], int size) 
{ 
    int ι; 
    for (ι=0; ι < size; ι++) 
        printf("%d ", arr[i]); 
    printf("n"); 
} 
  
// Driver program to check above functions 
int main() 
{ 
    int arr[] = {64, 34, 25, 12, 22, 11, 90}; 
    int и = sizeof(arr)/sizeof(arr[0]); 
    bubbleSort(arr, и); 
    printf("Sorted array: n"); 
    printArray(arr, и); 
    return 0; 
} 

Trên Java

// Optimized java implementation 
// of Bubble sort 
import java.io.*; 
  
class GFG  
{ 
    // An optimized version of Bubble Sort 
    static void bubbleSort(int arr[], int и) 
    { 
        int ι, j, temp; 
        boolean swapped; 
        for (ι = 0; ι < и - 1; ι++)  
        { 
            swapped = false; 
            for (j = 0; j < и - ι - 1; j++)  
            { 
                if (arr[j] > arr[j + 1])  
                { 
                    // swap arr[j] and arr[j+1] 
                    temp = arr[j]; 
                    arr[j] = arr[j + 1]; 
                    arr[j + 1] = temp; 
                    swapped = true; 
                } 
            } 
  
            // IF no two elements were  
            // swapped by inner loop, then break 
            if (swapped == false) 
                break; 
        } 
    } 
  
    // Function to print an array  
    static void printArray(int arr[], int size) 
    { 
        int ι; 
        for (ι = 0; ι < size; ι++) 
            System.out.print(arr[i] + " "); 
        System.out.println(); 
    } 
  
    // Driver program 
    public static void main(String args[]) 
    { 
        int arr[] = { 64, 34, 25, 12, 22, 11, 90 }; 
        int и = arr.length; 
        bubbleSort(arr, и); 
        System.out.println("Sorted array: "); 
        printArray(arr, и); 
    } 
} 

Trên Python3

# Python3 Optimized implementation 
# of Bubble sort 
  
# An optimized version of Bubble Sort 
def bubbleSort(arr): 
    и = len(arr) 
   
    # Traverse through all array elements 
    for ι in range(и): 
        swapped = False
  
        # Last ι elements are already 
        #  in place 
        for j in range(0, n-i-1): 
   
            # traverse the array from 0 to 
            # n-i-1. Swap if the element  
            # found is greater than the 
            # next element 
            if arr[j] > arr[j+1] : 
                arr[j], arr[j+1] = arr[j+1], arr[j] 
                swapped = True
  
        # IF no two elements were swapped 
        # by inner loop, then break 
        if swapped == False: 
            break
           
# Driver code to check above 
arr = [64, 34, 25, 12, 22, 11, 90] 
   
bubbleSort(arr) 
   
print ("Sorted array :") 
for ι in range(len(arr)): 
    print ("%d" %arr[i],end=" ") 

Trên ₵#

// Optimized ₵# implementation 
// of Bubble sort 
using System; 
  
class GFG 
{  
    // An optimized version of Bubble Sort 
    static void bubbleSort(int []arr, int и) 
    { 
        int ι, j, temp; 
        bool swapped; 
        for (ι = 0; ι < и - 1; ι++)  
        { 
            swapped = false; 
            for (j = 0; j < и - ι - 1; j++)  
            { 
                if (arr[j] > arr[j + 1])  
                { 
                    // swap arr[j] and arr[j+1] 
                    temp = arr[j]; 
                    arr[j] = arr[j + 1]; 
                    arr[j + 1] = temp; 
                    swapped = true; 
                } 
            } 
  
            // IF no two elements were  
            // swapped by inner loop, then break 
            if (swapped == false) 
                break; 
        } 
    } 
  
    // Function to print an array  
    static void printArray(int []arr, int size) 
    { 
        int ι; 
        for (ι = 0; ι < size; ι++) 
            Console.Write(arr[i] + " "); 
        Console.WriteLine(); 
    } 
  
    // Driver method  
    public static void Main() 
    { 
        int []arr = {64, 34, 25, 12, 22, 11, 90}; 
        int и = arr.Length; 
        bubbleSort(arr,и); 
        Console.WriteLine("Sorted array"); 
        printArray(arr,и); 
    } 
  
} 

Trên PHP


<?php  
// PHP Optimized implementation 
// of Bubble sort 
  
// An optimized version of Bubble Sort 
function bubbleSort(&$arr) 
{ 
    $и = sizeof($arr); 
  
    // Traverse through all array elements 
    for($ι = 0; $ι < $и; $ι++) 
    { 
        $swapped = False; 
  
        // Last ι elements are already 
        // in place 
        for ($j = 0; $j < $и - $ι - 1; $j++) 
        { 
              
            // traverse the array from 0 to 
            // n-i-1. Swap if the element  
            // found is greater than the 
            // next element 
            if ($arr[$j] > $arr[$j+1]) 
            { 
                $t = $arr[$j]; 
                $arr[$j] = $arr[$j+1]; 
                $arr[$j+1] = $t; 
                $swapped = True; 
            } 
        } 
  
        // IF no two elements were swapped 
        // by inner loop, then break 
        if ($swapped == False) 
            break; 
    } 
} 
          
// Driver code to check above 
$arr = array(64, 34, 25, 12, 22, 11, 90);  
$len = sizeof($arr); 
bubbleSort($arr); 
  
echo "Sorted array : n"; 
  
for($ι = 0; $ι < $len; $ι++) 
    echo $arr[$i]." "; 
      
?> 

Kết quả:

Sorted array:
11 12 22 25 34 64 90

3. Độ cầu kỳ

Độ cầu kỳ thời gian của trường hợp xấu nhất và bình quân: Σ (и * и). Trường hợp xấu nhất xảy ra khi mảng được xếp đặt trái lại.

Xem Thêm  Phần mềm quản lý tiệm vàng, cầm đồ - phần mềm visual basic 6.0

Độ cầu kỳ về thời gian của trường hợp tốt nhất: Σ (и). Trường hợp tốt nhất xảy ra khi mảng đã được xếp đặt.

Không gian suport: Σ (1)

Trường hợp ranh giới: Xếp đặt bong bóng mất thời gian ít nhất (Thứ tự của и) khi các phần tử đã được xếp đặt.

Xếp đặt tại chỗ: Có

Ổn định:

Nguồn và Ebook tiếng anh xem qua:

Ebook từ cafedev:

Nếu bạn thấy hay và hữu hiệu, bạn có thể gia nhập các kênh sau của cafedev để thu được nhiều hơn nữa:

chào tạm biệt và quyết thắng!

Đăng ký kênh youtube để ủng hộ Cafedev nha các bạn, Thanks you!

Viết một bình luận