Độ phức tạp của thuật toán bubble sort năm 2024

Question

Độ phức tạp thời gian của Bubble Sort là O(n^2), trong đó “n” là số lượng phần tử trong danh sách. Điều này có nghĩa là thời gian thực thi của thuật toán tăng theo bình phương của số lượng phần tử trong danh sách. Vì vậy, Bubble Sort thường không được ưa chuộng trong các trường hợp có số lượng phần tử lớn.

Nội dung chính Show

Ưu điểm
Nhược điểm
Kết luận
Tài liệu tham khảo
2. Code ví dụ trên nhiều ngôn ngữ lập trình
3. Độ phức tạp
Độ phức tạp thời gian của thuật toán Bubble Sort là bao nhiêu?
Bubble Sort Python là gì?
Thuật toán sắp xếp nơi bớt cho đỡ phức tạp là bao nhiêu?
Thuật toán sắp xếp nổi bọt còn gọi là gì?

Ưu điểm

Sắp xếp bong bóng rất dễ hiểu và dễ thực hiện.
Nó không yêu cầu bất kỳ không gian bộ nhớ bổ sung.
Đây là một thuật toán sắp xếp ổn định, nghĩa là các phần tử có cùng giá trị khóa sẽ duy trì thứ tự tương đối của chúng trong kết quả được sắp xếp.

Nhược điểm

Sắp xếp nổi bọt có độ phức tạp về thời gian là O(N 2 ) khiến cho việc xử lý các tập dữ liệu lớn trở nên rất chậm.
Sắp xếp nổi bọt là một thuật toán sắp xếp dựa trên so sánh, có nghĩa là nó yêu cầu toán tử so sánh để xác định thứ tự tương đối của các phần tử trong tập dữ liệu đầu vào. Nó có thể hạn chế hiệu quả của thuật toán trong một số trường hợp nhất định.

Kết luận

Mặc dù Bubble Sort không phải là thuật toán sắp xếp hiệu quả nhất, nhưng việc hiểu và nắm vững cách hoạt động của nó có thể giúp ta hiểu sâu hơn về các thuật toán sắp xếp khác và làm nền tảng cho việc học các thuật toán phức tạp hơn trong lĩnh vực khoa học máy tính.

Tài liệu tham khảo

Các bạn có thể tham khảo các ví dụ khác về Bubbke Sort này ví dụ như: Sắp xếp chuỗi bằng Bubble Sort, Sắp xếp bong bóng đệ quy ….

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

Nội dung chính

Bubble Sort là thuật toán sắp xếp đơn giản 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 đầu tiên:

(5 1 4 2 8) -> (1 5 4 2 8), Ở đây, thuật toán so sánh hai phần tử đầu tiên và hoán đổi vì 5> 1.

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

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

(1 4 2 5 8) -> (1 4 2 5 8), Bây giờ, vì các phần tử này đã có thứ tự (8> 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ì 4> 2

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

Bây giờ, mảng đã được sắp xếp, nhưng thuật toán của chúng tôi không biết liệu nó có hoàn thành hay không. Thuật toán cần một lần chuyển toàn bộ mà không có bất kỳ sự hoán đổi nào để biết nó được sắp xếp.

Vòng chạy thứ ba:

(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

C++

// C++ program for implementation of Bubble sort  

# include  
using namespace std; 
void swap(int *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++)  
        cout << arr[i] << " ";  
    cout << endl;  
}  
// Driver code  
int main()  
{  
    int arr[] = {64, 34, 25, 12, 22, 11, 90};  
    int n = sizeof(arr)/sizeof(arr[0]);  
    bubbleSort(arr, n);  
    cout<<"Sorted array: \n";  
    printArray(arr, n);  
    return 0;  
}

C


// C program for implementation of Bubble sort 

# include  
void swap(int *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[] = {64, 34, 25, 12, 22, 11, 90}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    bubbleSort(arr, n); 
    printf("Sorted array: \n"); 
    printArray(arr, n); 
    return 0; 
}

Java

// Java program for implementation of Bubble Sort 
class BubbleSort 
{ 
    void bubbleSort(int arr[]) 
    { 
        int n = arr.length; 
        for (int i = 0; i < n-1; i++) 
            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 n = arr.length; 
        for (int i=0; i

Python


# Python program for implementation of Bubble Sort 
def bubbleSort(arr): 
    n = len(arr) 
    # Traverse through all array elements 
    for i in range(n): 
        # Last i 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 test above 
arr = [64, 34, 25, 12, 22, 11, 90] 
bubbleSort(arr) 
print ("Sorted array is:") 
for i in range(len(arr)): 
    print ("%d" %arr[i]),

C#

// C# program for implementation  
// of Bubble Sort 
using System; 
class GFG 
{  
    static void bubbleSort(int []arr) 
    { 
        int n = arr.Length; 
        for (int i = 0; i < n - 1; i++) 
            for (int j = 0; j < n - i - 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 n = arr.Length; 
        for (int i = 0; i < n; ++i) 
            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


 $arr[$j+1]) 
            { 
                $t = $arr[$j]; 
                $arr[$j] = $arr[$j+1]; 
                $arr[$j+1] = $t; 
            } 
        } 
    } 
} 
// Driver code to test above 
$arr = array(64, 34, 25, 12, 22, 11, 90); 
$len = sizeof($arr); 
bubbleSort($arr); 
echo "Sorted array : \n"; 
for ($i = 0; $i < $len; $i++) 
    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.

 
Cách triển khai tối ưu hoá hơn:
Hàm trên luôn chạy O (n ^ 2) thời gian ngay cả khi mảng được sắp xếp. 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 C++

// Optimized implementation of Bubble sort 

# include  
void swap(int *xp, int *yp) 
{ 
    int temp = *xp; 
    *xp = *yp; 
    *yp = temp; 
} 
// An optimized version of Bubble Sort 
void bubbleSort(int arr[], int n) 
{ 
   int i, j; 
   bool swapped; 
   for (i = 0; i < n-1; i++) 
   { 
     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 i; 
    for (i=0; i < size; i++) 
        printf("%d ", arr[i]); 
    printf("n"); 
} 
// Driver program to test above functions 
int main() 
{ 
    int arr[] = {64, 34, 25, 12, 22, 11, 90}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    bubbleSort(arr, n); 
    printf("Sorted array: \n"); 
    printArray(arr, n); 
    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 n) 
    { 
        int i, j, temp; 
        boolean swapped; 
        for (i = 0; i < n - 1; i++)  
        { 
            swapped = false; 
            for (j = 0; j < n - i - 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 i; 
        for (i = 0; i < size; i++) 
            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 n = arr.length; 
        bubbleSort(arr, n); 
        System.out.println("Sorted array: "); 
        printArray(arr, n); 
    } 
} 
Trên Python3
# Python3 Optimized implementation 
# of Bubble sort 
# An optimized version of Bubble Sort 
def bubbleSort(arr): 
    n = len(arr) 
    # Traverse through all array elements 
    for i in range(n): 
        swapped = False
        # Last i 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 test above 
arr = [64, 34, 25, 12, 22, 11, 90] 
bubbleSort(arr) 
print ("Sorted array :") 
for i in range(len(arr)): 
    print ("%d" %arr[i],end=" ") 
Trên C#

// C program for implementation of Bubble sort 

# include  
void swap(int *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[] = {64, 34, 25, 12, 22, 11, 90}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    bubbleSort(arr, n); 
    printf("Sorted array: \n"); 
    printArray(arr, n); 
    return 0; 
} 
0
Trên PHP

// C program for implementation of Bubble sort 

# include  
void swap(int *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[] = {64, 34, 25, 12, 22, 11, 90}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    bubbleSort(arr, n); 
    printf("Sorted array: \n"); 
    printArray(arr, n); 
    return 0; 
} 
1
Kết quả:
Sorted array:
11 12 22 25 34 64 90



3. Độ phức tạp
Độ phức tạp thời gian của trường hợp xấu nhất và trung bình: O (n * n). Trường hợp xấu nhất xảy ra khi mảng được sắp xếp ngược lại.
Độ phức tạp về thời gian của trường hợp tốt nhất: O (n). Trường hợp tốt nhất xảy ra khi mảng đã được sắp xếp.
Không gian phụ trợ: O (1)
Trường hợp ranh giới: Sắp xếp bong bóng mất thời gian tối thiểu (Thứ tự của n) khi các phần tử đã được sắp xếp.
Sắp xếp tại chỗ: Có
Ổn định: Có
Nguồn và Tài liệu tiếng anh tham khảo:
w3schools
Geeksforgeeks
codechef
dev.to
Tài liệu từ cafedev:
Full series tự học Cấu trúc dữ liệu và giải thuật từ cơ bản tới nâng cao tại đây nha.
Ebook về Cấu trúc dữ liệu và giải thuật tại đây.
Các series tự học lập trình khác
Nếu bạn thấy hay và hữu ích, bạn có thể tham gia các kênh sau của cafedev để nhận được nhiều hơn nữa:
Độ phức tạp thời gian của thuật toán Bubble Sort là bao nhiêu?
Do cách hoạt động dựa trên nhiều lần so sánh và hoán đổi các phần tử liền kề, thời gian thực thi của thuật toán này chậm hơn so với các thuật toán sắp xếp khác. Độ phức tạp thời gian cao: Độ phức tạp thời gian của Bubble Sort trong trường hợp trung bình hay xấu nhất là O(n^2), nơi n là số lượng phần tử trong danh sách.nullTìm hiểu chi tiết Bubble Sort: Thuật toán sắp xếp nổi bọt - FPT Shopfptshop.com.vn › Tin tức › Đánh giá - Tư vấnnull
Bubble Sort Python là gì?
Sắp xếp nổi bọt (tiếng Anh: bubble sort) là một thuật toán sắp xếp đơn giản, với thao tác cơ bản là so sánh hai phần tử kề nhau, nếu chúng chưa đứng đúng thứ tự thì đổi chỗ (swap). Có thể tiến hành từ trên xuống (bên trái sang) hoặc từ dưới lên (bên phải sang).nullSắp xếp nổi bọt – Wikipedia tiếng Việtvi.wikipedia.org › wiki › Sắp_xếp_nổi_bọtnull
Thuật toán sắp xếp nơi bớt cho đỡ phức tạp là bao nhiêu?
Sắp xếp nổi bọt là một trong những thuật toán sắp xếp đơn giản nhất. Có hai vòng lặp được thực hiện trong thuật toán. Mỗi vòng lặp ngoài sẽ thực hiện các thao tác lặp giảm dần trong vòng lặp bên trong. Độ phức tạp của trường hợp xấu nhất: O(n2) O ( n 2 ) .nullThuật toán sắp xếp nổi bọt (Bubble Sort) - Tek4tek4.vn › khoa-hoc › thuat-toan-sap-xep-noi-bot-bubble-sortnull
Thuật toán sắp xếp nổi bọt còn gọi là gì?
Sắp xếp nổi bọt (bubble sort) là phương pháp sắp xếp đơn giản, dễ hiểu thường được dạy trong khoa học máy tính. Giải thuật bắt đầu từ đầu của tập dữ liệu. Nó so sánh hai phần tử đầu, nếu phần tử đứng trước lớn hơn phần tử đứng sau thì đổi chỗ chúng cho nhau.nullThuật toán sắp xếp – Wikipedia tiếng Việtvi.wikipedia.org › wiki › Thuật_toán_sắp_xếpnull

mẹo hay

Độ phức tạp của thuật toán bubble sort năm 2024

Ưu điểm

Nhược điểm

Kết luận

Tài liệu tham khảo

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

3. Độ phức tạp

Độ phức tạp thời gian của thuật toán Bubble Sort là bao nhiêu?

Bubble Sort Python là gì?

Thuật toán sắp xếp nơi bớt cho đỡ phức tạp là bao nhiêu?

Thuật toán sắp xếp nổi bọt còn gọi là gì?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội