Hướng dẫn how fast is sort () in python? - sort () trong python nhanh như thế nào?

Thời gian mã của bạn

Khi so sánh hai thuật toán sắp xếp trong Python, nó luôn luôn có nhiều thông tin để xem mỗi người mất bao lâu để chạy. Thời gian cụ thể, mỗi thuật toán sẽ được xác định một phần bởi phần cứng của bạn, nhưng bạn vẫn có thể sử dụng thời gian tỷ lệ giữa các lần thực hiện để giúp bạn quyết định triển khai nào hiệu quả hơn về thời gian.

Trong phần này, bạn sẽ tập trung vào một cách thực tế để đo thời gian thực tế để chạy đến các thuật toán sắp xếp của bạn bằng mô -đun

21ARRAY_LENGTH = 10000
22
23if __name__ == "__main__":
24    # Generate an array of `ARRAY_LENGTH` items consisting
25    # of random integer values between 0 and 999
26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
27
28    # Call the function using the name of the sorting algorithm
29    # and the array you just created
30    run_sorting_algorithm(algorithm="sorted", array=array)

Ở đây, một chức năng bạn có thể sử dụng để thời gian thuật toán của mình:

 1from random import randint
 2from timeit import repeat
 3
 4def run_sorting_algorithm(algorithm, array):
 5    # Set up the context and prepare the call to the specified
 6    # algorithm using the supplied array. Only import the
 7    # algorithm function if it's not the built-in `sorted()`.
 8    setup_code = f"from __main__ import {algorithm}" \
 9        if algorithm != "sorted" else ""
10
11    stmt = f"{algorithm}({array})"
12
13    # Execute the code ten different times and return the time
14    # in seconds that each execution took
15    times = repeat(setup=setup_code, stmt=stmt, repeat=3, number=10)
16
17    # Finally, display the name of the algorithm and the
18    # minimum time it took to run
19    print(f"Algorithm: {algorithm}. Minimum execution time: {min(times)}")

Trong ví dụ này,

21ARRAY_LENGTH = 10000
22
23if __name__ == "__main__":
24    # Generate an array of `ARRAY_LENGTH` items consisting
25    # of random integer values between 0 and 999
26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
27
28    # Call the function using the name of the sorting algorithm
29    # and the array you just created
30    run_sorting_algorithm(algorithm="sorted", array=array)

• Dòng 8 nhập tên của thuật toán bằng cách sử dụng phép thuật của Python từ F-String. Điều này là để

  $ python sorting.py
  Algorithm: sorted. Minimum execution time: 0.010945824000000007
  

  0 biết nơi gọi thuật toán từ đâu. Lưu ý rằng điều này chỉ cần thiết cho các triển khai tùy chỉnh được sử dụng trong hướng dẫn này. Nếu thuật toán được chỉ định là

  21ARRAY_LENGTH = 10000
  22
  23if __name__ == "__main__":
  24    # Generate an array of `ARRAY_LENGTH` items consisting
  25    # of random integer values between 0 and 999
  26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
  27
  28    # Call the function using the name of the sorting algorithm
  29    # and the array you just created
  30    run_sorting_algorithm(algorithm="sorted", array=array)
  

  5 tích hợp, thì sẽ không có gì được nhập. imports the name of the algorithm using the magic of Python’s f-strings. This is so that

  $ python sorting.py
  Algorithm: sorted. Minimum execution time: 0.010945824000000007
  

  0 knows where to call the algorithm from. Note that this is only necessary for the custom implementations used in this tutorial. If the algorithm specified is the built-in

  21ARRAY_LENGTH = 10000
  22
  23if __name__ == "__main__":
  24    # Generate an array of `ARRAY_LENGTH` items consisting
  25    # of random integer values between 0 and 999
  26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
  27
  28    # Call the function using the name of the sorting algorithm
  29    # and the array you just created
  30    run_sorting_algorithm(algorithm="sorted", array=array)
  

  5, then nothing will be imported.

• Dòng 11 chuẩn bị cuộc gọi đến thuật toán với mảng được cung cấp. Đây là tuyên bố sẽ được thực thi và hẹn giờ. prepares the call to the algorithm with the supplied array. This is the statement that will be executed and timed.

• Dòng 15 gọi

  $ python sorting.py
  Algorithm: sorted. Minimum execution time: 0.010945824000000007
  

  0 với mã thiết lập và câu lệnh. Điều này sẽ gọi thuật toán sắp xếp được chỉ định mười lần, trả về số giây mỗi lần thực hiện. calls

  $ python sorting.py
  Algorithm: sorted. Minimum execution time: 0.010945824000000007
  

  0 with the setup code and the statement. This will call the specified sorting algorithm ten times, returning the number of seconds each one of these executions took.

• Dòng 19 xác định thời gian ngắn nhất được trả lại và in nó cùng với tên của thuật toán. identifies the shortest time returned and prints it along with the name of the algorithm.

Ở đây, một ví dụ về cách sử dụng

21ARRAY_LENGTH = 10000
22
23if __name__ == "__main__":
24    # Generate an array of `ARRAY_LENGTH` items consisting
25    # of random integer values between 0 and 999
26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
27
28    # Call the function using the name of the sorting algorithm
29    # and the array you just created
30    run_sorting_algorithm(algorithm="sorted", array=array)

21ARRAY_LENGTH = 10000
22
23if __name__ == "__main__":
24    # Generate an array of `ARRAY_LENGTH` items consisting
25    # of random integer values between 0 and 999
26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
27
28    # Call the function using the name of the sorting algorithm
29    # and the array you just created
30    run_sorting_algorithm(algorithm="sorted", array=array)

21ARRAY_LENGTH = 10000
22
23if __name__ == "__main__":
24    # Generate an array of `ARRAY_LENGTH` items consisting
25    # of random integer values between 0 and 999
26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
27
28    # Call the function using the name of the sorting algorithm
29    # and the array you just created
30    run_sorting_algorithm(algorithm="sorted", array=array)

Nếu bạn lưu mã trên trong tệp

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

Hãy nhớ rằng thời gian tính bằng giây của mỗi thử nghiệm phụ thuộc một phần vào phần cứng bạn sử dụng, do đó, bạn có thể sẽ thấy kết quả hơi khác nhau khi chạy mã.

Đo lường hiệu quả với ký hiệu O lớn

Thời gian cụ thể mà một thuật toán cần để chạy isn không đủ thông tin để có được bức tranh đầy đủ về độ phức tạp của thời gian của nó. Để giải quyết vấn đề này, bạn có thể sử dụng ký hiệu Big O (phát âm là OH OH). Big O thường được sử dụng để so sánh các triển khai khác nhau và quyết định xem cái nào là hiệu quả nhất, bỏ qua các chi tiết không cần thiết và tập trung vào những gì quan trọng nhất trong thời gian chạy của thuật toán.time complexity. To solve this problem, you can use Big O (pronounced “big oh”) notation. Big O is often used to compare different implementations and decide which one is the most efficient, skipping unnecessary details and focusing on what’s most important in the runtime of an algorithm.

Thời gian tính bằng giây cần thiết để chạy các thuật toán khác nhau có thể bị ảnh hưởng bởi một số yếu tố không liên quan, bao gồm tốc độ bộ xử lý hoặc bộ nhớ có sẵn. Big O, mặt khác, cung cấp một nền tảng để thể hiện độ phức tạp thời gian chạy về mặt bất khả tri phần cứng. Với Big O, bạn thể hiện sự phức tạp về mức độ thời gian chạy của thuật toán của bạn phát triển nhanh như thế nào so với kích thước của đầu vào, đặc biệt là khi đầu vào phát triển tùy ý lớn.

Giả sử rằng N là kích thước của đầu vào cho một thuật toán, ký hiệu O lớn đại diện cho mối quan hệ giữa N và số bước mà thuật toán thực hiện để tìm giải pháp. Big O sử dụng một chữ cái viết hoa, sau đó là mối quan hệ này bên trong ngoặc đơn. Ví dụ: O (n) đại diện cho các thuật toán thực hiện một số bước tỷ lệ thuận với kích thước của đầu vào của chúng.O(n) represents algorithms that execute a number of steps proportional to the size of their input.

Mặc dù hướng dẫn này sẽ không đi sâu vào các chi tiết về ký hiệu Big O, nhưng đây là năm ví dụ về độ phức tạp thời gian chạy của các thuật toán khác nhau:

Hướng dẫn này bao gồm độ phức tạp thời gian chạy O của từng thuật toán sắp xếp được thảo luận. Nó cũng bao gồm một lời giải thích ngắn gọn về cách xác định thời gian chạy trên từng trường hợp cụ thể. Điều này sẽ cho bạn hiểu rõ hơn về cách bắt đầu sử dụng Big O để phân loại các thuật toán khác.

Thực hiện phân loại bong bóng trong Python

Ở đây, một việc thực hiện thuật toán sắp xếp bong bóng trong Python:

 1def bubble_sort(array):
 2    n = len(array)
 3
 4    for i in range(n):
 5        # Create a flag that will allow the function to
 6        # terminate early if there's nothing left to sort
 7        already_sorted = True
 8
 9        # Start looking at each item of the list one by one,
10        # comparing it with its adjacent value. With each
11        # iteration, the portion of the array that you look at
12        # shrinks because the remaining items have already been
13        # sorted.
14        for j in range(n - i - 1):
15            if array[j] > array[j + 1]:
16                # If the item you're looking at is greater than its
17                # adjacent value, then swap them
18                array[j], array[j + 1] = array[j + 1], array[j]
19
20                # Since you had to swap two elements,
21                # set the `already_sorted` flag to `False` so the
22                # algorithm doesn't finish prematurely
23                already_sorted = False
24
25        # If there were no swaps during the last iteration,
26        # the array is already sorted, and you can terminate
27        if already_sorted:
28            break
29
30    return array

Vì việc triển khai này sắp xếp mảng theo thứ tự tăng dần, mỗi bước bong bóng, thành phần lớn nhất đến cuối mảng. Điều này có nghĩa là mỗi lần lặp có ít các bước hơn so với lần lặp trước vì một phần lớn hơn của mảng được sắp xếp.

Các vòng lặp trong dòng 4 và 10 xác định cách thuật toán chạy qua danh sách. Lưu ý cách

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

Khi các vòng lặp tiến triển, dòng 15 so sánh từng phần tử với giá trị liền kề của nó và dòng 18 hoán đổi chúng nếu chúng theo thứ tự không chính xác. Điều này đảm bảo một danh sách được sắp xếp ở cuối hàm.line 15 compares each element with its adjacent value, and line 18 swaps them if they are in the incorrect order. This ensures a sorted list at the end of the function.

Để phân tích chính xác cách thức hoạt động của thuật toán, hãy xem xét một danh sách với các giá trị

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

Bây giờ hãy xem xét từng bước về những gì mà xảy ra với mảng khi thuật toán tiến triển:

1. Mã bắt đầu bằng cách so sánh phần tử đầu tiên,

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   0, với phần tử liền kề của nó,

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   1. Kể từ

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   2, các giá trị được hoán đổi, dẫn đến thứ tự sau:

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   3.

2. Thuật toán sau đó so sánh phần tử thứ hai,

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   0, với phần tử liền kề của nó,

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   5. Kể từ

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   6, các giá trị được hoán đổi, dẫn đến thứ tự sau:

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   7.

3. Tiếp theo, thuật toán so sánh phần tử thứ ba,

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   0, với phần tử liền kề của nó,

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   9. Vì

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array you just created
    8    run_sorting_algorithm(algorithm="bubble_sort", array=array)
   

   0, nó cũng hoán đổi các giá trị, dẫn đến thứ tự sau:

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array you just created
    8    run_sorting_algorithm(algorithm="bubble_sort", array=array)
   

   1.

4. Cuối cùng, thuật toán so sánh phần tử thứ tư,

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   0, với phần tử liền kề của nó,

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array you just created
    8    run_sorting_algorithm(algorithm="bubble_sort", array=array)
   

   3 và cũng hoán đổi chúng, dẫn đến

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array you just created
    8    run_sorting_algorithm(algorithm="bubble_sort", array=array)
   

   4. Tại thời điểm này, thuật toán đã hoàn thành thẻ đầu tiên thông qua danh sách (

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array you just created
    8    run_sorting_algorithm(algorithm="bubble_sort", array=array)
   

   5). Lưu ý cách giá trị

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   0 sủi bọt từ vị trí ban đầu của nó đến vị trí chính xác của nó ở cuối danh sách.

5. Đường chuyền thứ hai (

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array you just created
    8    run_sorting_algorithm(algorithm="bubble_sort", array=array)
   

   7) tính đến phần tử cuối cùng của danh sách đã được định vị và tập trung vào bốn yếu tố còn lại,

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array you just created
    8    run_sorting_algorithm(algorithm="bubble_sort", array=array)
   

   8. Vào cuối vượt qua này, giá trị

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   5 tìm thấy vị trí chính xác của nó. Lần thứ ba vượt qua danh sách vị trí giá trị

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array you just created
    8    run_sorting_algorithm(algorithm="bubble_sort", array=array)
   

   3, v.v. cho đến khi danh sách được sắp xếp.

Đo lường độ phức tạp thời gian chạy của Bubble sắp xếp

Việc thực hiện phân loại bong bóng của bạn bao gồm hai vòng

$ python sorting.py
Algorithm: bubble_sort. Minimum execution time: 73.21720498399998

Bạn đã học được trước đó rằng Big O tập trung vào cách thời gian chạy phát triển so với kích thước của đầu vào. Điều đó có nghĩa là, để biến phương trình trên thành độ phức tạp o lớn của thuật toán, bạn cần loại bỏ các hằng số vì chúng không thay đổi với kích thước đầu vào.

Làm như vậy đơn giản hóa ký hiệu thành N2 - n. Vì N2 phát triển nhanh hơn nhiều so với N, nên thuật ngữ cuối cùng này cũng có thể được giảm, để lại sự sắp xếp bong bóng với độ phức tạp trung bình và trường hợp xấu nhất của O (N2).O(n2).

Trong trường hợp thuật toán nhận được một mảng đã được sắp xếp và giả sử việc triển khai bao gồm tối ưu hóa cờ ____72 được giải thích trước khi độ phức tạp thời gian chạy sẽ giảm xuống (n) tốt hơn nhiều vì thuật toán sẽ không cần truy cập vào bất kỳ phần tử nào hơn là nhiều hơn Một lần.

O (n), sau đó, là độ phức tạp thời gian chạy trong trường hợp tốt nhất của loại bong bóng. Nhưng hãy nhớ rằng các trường hợp tốt nhất là một ngoại lệ và bạn nên tập trung vào trường hợp trung bình khi so sánh các thuật toán khác nhau.

Thời gian thực hiện sắp xếp bong bóng của bạn

Sử dụng

21ARRAY_LENGTH = 10000
22
23if __name__ == "__main__":
24    # Generate an array of `ARRAY_LENGTH` items consisting
25    # of random integer values between 0 and 999
26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
27
28    # Call the function using the name of the sorting algorithm
29    # and the array you just created
30    run_sorting_algorithm(algorithm="sorted", array=array)

 1if __name__ == "__main__":
 2    # Generate an array of `ARRAY_LENGTH` items consisting
 3    # of random integer values between 0 and 999
 4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
 5
 6    # Call the function using the name of the sorting algorithm
 7    # and the array you just created
 8    run_sorting_algorithm(algorithm="bubble_sort", array=array)

Bây giờ bạn có thể chạy tập lệnh để có thời gian thực hiện là

$ python sorting.py
Algorithm: bubble_sort. Minimum execution time: 73.21720498399998

$ python sorting.py
Algorithm: bubble_sort. Minimum execution time: 73.21720498399998

Phải mất

$ python sorting.py
Algorithm: bubble_sort. Minimum execution time: 73.21720498399998

21ARRAY_LENGTH = 10000
22
23if __name__ == "__main__":
24    # Generate an array of `ARRAY_LENGTH` items consisting
25    # of random integer values between 0 and 999
26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
27
28    # Call the function using the name of the sorting algorithm
29    # and the array you just created
30    run_sorting_algorithm(algorithm="sorted", array=array)

Phân tích điểm mạnh và điểm yếu của loại bong bóng

Ưu điểm chính của thuật toán sắp xếp bong bóng là sự đơn giản của nó. Nó là đơn giản để cả thực hiện và hiểu. Đây có lẽ là lý do chính tại sao hầu hết các khóa học khoa học máy tính giới thiệu chủ đề sắp xếp bằng cách sử dụng loại bong bóng.simplicity. It is straightforward to both implement and understand. This is probably the main reason why most computer science courses introduce the topic of sorting using bubble sort.

Như bạn đã thấy trước đây, nhược điểm của loại bong bóng là nó chậm, với độ phức tạp thời gian chạy của O (N2). Thật không may, điều này quy định nó như một ứng cử viên thực tế để sắp xếp các mảng lớn.slow, with a runtime complexity of O(n2). Unfortunately, this rules it out as a practical candidate for sorting large arrays.

Thực hiện sắp xếp chèn trong Python

Thuật toán sắp xếp chèn hoạt động chính xác giống như ví dụ với bộ bài của thẻ. Ở đây, việc thực hiện trong Python:

 1def insertion_sort(array):
 2    # Loop from the second element of the array until
 3    # the last element
 4    for i in range(1, len(array)):
 5        # This is the element we want to position in its
 6        # correct place
 7        key_item = array[i]
 8
 9        # Initialize the variable that will be used to
10        # find the correct position of the element referenced
11        # by `key_item`
12        j = i - 1
13
14        # Run through the list of items (the left
15        # portion of the array) and find the correct position
16        # of the element referenced by `key_item`. Do this only
17        # if `key_item` is smaller than its adjacent values.
18        while j >= 0 and array[j] > key_item:
19            # Shift the value one position to the left
20            # and reposition j to point to the next element
21            # (from right to left)
22            array[j + 1] = array[j]
23            j -= 1
24
25        # When you finish shifting the elements, you can position
26        # `key_item` in its correct location
27        array[j + 1] = key_item
28
29    return array

Không giống như sắp xếp bong bóng, việc triển khai loại chèn này xây dựng danh sách được sắp xếp bằng cách đẩy các mục nhỏ hơn sang trái. Hãy cùng phá vỡ dòng

$ python sorting.py
Algorithm: bubble_sort. Minimum execution time: 73.21720498399998

• Dòng 4 thiết lập vòng lặp xác định

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8 rằng hàm sẽ định vị trong mỗi lần lặp. Lưu ý rằng vòng lặp bắt đầu với mục thứ hai trong danh sách và đi đến mục cuối cùng. sets up the loop that determines the

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8 that the function will position during each iteration. Notice that the loop starts with the second item on the list and goes all the way to the last item.

• Dòng 7 Khởi tạo

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8 với mục mà chức năng đang cố gắng đặt. initializes

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8 with the item that the function is trying to place.

• Dòng 12 Khởi tạo một biến sẽ chỉ liên tiếp đến từng phần tử ở bên trái của

   1def insertion_sort(array):
   2    # Loop from the second element of the array until
   3    # the last element
   4    for i in range(1, len(array)):
   5        # This is the element we want to position in its
   6        # correct place
   7        key_item = array[i]
   8
   9        # Initialize the variable that will be used to
  10        # find the correct position of the element referenced
  11        # by `key_item`
  12        j = i - 1
  13
  14        # Run through the list of items (the left
  15        # portion of the array) and find the correct position
  16        # of the element referenced by `key_item`. Do this only
  17        # if `key_item` is smaller than its adjacent values.
  18        while j >= 0 and array[j] > key_item:
  19            # Shift the value one position to the left
  20            # and reposition j to point to the next element
  21            # (from right to left)
  22            array[j + 1] = array[j]
  23            j -= 1
  24
  25        # When you finish shifting the elements, you can position
  26        # `key_item` in its correct location
  27        array[j + 1] = key_item
  28
  29    return array
  

  0. Đây là những yếu tố sẽ được liên tiếp so với

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8. initializes a variable that will consecutively point to each element to the left of

   1def insertion_sort(array):
   2    # Loop from the second element of the array until
   3    # the last element
   4    for i in range(1, len(array)):
   5        # This is the element we want to position in its
   6        # correct place
   7        key_item = array[i]
   8
   9        # Initialize the variable that will be used to
  10        # find the correct position of the element referenced
  11        # by `key_item`
  12        j = i - 1
  13
  14        # Run through the list of items (the left
  15        # portion of the array) and find the correct position
  16        # of the element referenced by `key_item`. Do this only
  17        # if `key_item` is smaller than its adjacent values.
  18        while j >= 0 and array[j] > key_item:
  19            # Shift the value one position to the left
  20            # and reposition j to point to the next element
  21            # (from right to left)
  22            array[j + 1] = array[j]
  23            j -= 1
  24
  25        # When you finish shifting the elements, you can position
  26        # `key_item` in its correct location
  27        array[j + 1] = key_item
  28
  29    return array
  

  0. These are the elements that will be consecutively compared with

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8.

• Dòng 18 so sánh

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8 với mỗi giá trị bên trái bằng cách sử dụng vòng lặp

   1def insertion_sort(array):
   2    # Loop from the second element of the array until
   3    # the last element
   4    for i in range(1, len(array)):
   5        # This is the element we want to position in its
   6        # correct place
   7        key_item = array[i]
   8
   9        # Initialize the variable that will be used to
  10        # find the correct position of the element referenced
  11        # by `key_item`
  12        j = i - 1
  13
  14        # Run through the list of items (the left
  15        # portion of the array) and find the correct position
  16        # of the element referenced by `key_item`. Do this only
  17        # if `key_item` is smaller than its adjacent values.
  18        while j >= 0 and array[j] > key_item:
  19            # Shift the value one position to the left
  20            # and reposition j to point to the next element
  21            # (from right to left)
  22            array[j + 1] = array[j]
  23            j -= 1
  24
  25        # When you finish shifting the elements, you can position
  26        # `key_item` in its correct location
  27        array[j + 1] = key_item
  28
  29    return array
  

  3, thay đổi các yếu tố để nhường chỗ cho việc đặt

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8. compares

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8 with each value to its left using a

   1def insertion_sort(array):
   2    # Loop from the second element of the array until
   3    # the last element
   4    for i in range(1, len(array)):
   5        # This is the element we want to position in its
   6        # correct place
   7        key_item = array[i]
   8
   9        # Initialize the variable that will be used to
  10        # find the correct position of the element referenced
  11        # by `key_item`
  12        j = i - 1
  13
  14        # Run through the list of items (the left
  15        # portion of the array) and find the correct position
  16        # of the element referenced by `key_item`. Do this only
  17        # if `key_item` is smaller than its adjacent values.
  18        while j >= 0 and array[j] > key_item:
  19            # Shift the value one position to the left
  20            # and reposition j to point to the next element
  21            # (from right to left)
  22            array[j + 1] = array[j]
  23            j -= 1
  24
  25        # When you finish shifting the elements, you can position
  26        # `key_item` in its correct location
  27        array[j + 1] = key_item
  28
  29    return array
  

  3 loop, shifting the elements to make room to place

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8.

• Dòng 27 Vị trí

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8 ở vị trí chính xác của nó sau khi thuật toán chuyển tất cả các giá trị lớn hơn sang phải. positions

  $ python sorting.py
  Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
  

  8 in its correct place after the algorithm shifts all the larger values to the right.

Dưới đây, một con số minh họa các lần lặp khác nhau của thuật toán khi sắp xếp mảng

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

Bây giờ ở đây, một bản tóm tắt các bước của thuật toán khi sắp xếp mảng:

1. Thuật toán bắt đầu với

    1def insertion_sort(array):
    2    # Loop from the second element of the array until
    3    # the last element
    4    for i in range(1, len(array)):
    5        # This is the element we want to position in its
    6        # correct place
    7        key_item = array[i]
    8
    9        # Initialize the variable that will be used to
   10        # find the correct position of the element referenced
   11        # by `key_item`
   12        j = i - 1
   13
   14        # Run through the list of items (the left
   15        # portion of the array) and find the correct position
   16        # of the element referenced by `key_item`. Do this only
   17        # if `key_item` is smaller than its adjacent values.
   18        while j >= 0 and array[j] > key_item:
   19            # Shift the value one position to the left
   20            # and reposition j to point to the next element
   21            # (from right to left)
   22            array[j + 1] = array[j]
   23            j -= 1
   24
   25        # When you finish shifting the elements, you can position
   26        # `key_item` in its correct location
   27        array[j + 1] = key_item
   28
   29    return array
   

   7 và đi qua Subarray sang trái để tìm vị trí chính xác cho nó. Trong trường hợp này, Subarray là

    1def insertion_sort(array):
    2    # Loop from the second element of the array until
    3    # the last element
    4    for i in range(1, len(array)):
    5        # This is the element we want to position in its
    6        # correct place
    7        key_item = array[i]
    8
    9        # Initialize the variable that will be used to
   10        # find the correct position of the element referenced
   11        # by `key_item`
   12        j = i - 1
   13
   14        # Run through the list of items (the left
   15        # portion of the array) and find the correct position
   16        # of the element referenced by `key_item`. Do this only
   17        # if `key_item` is smaller than its adjacent values.
   18        while j >= 0 and array[j] > key_item:
   19            # Shift the value one position to the left
   20            # and reposition j to point to the next element
   21            # (from right to left)
   22            array[j + 1] = array[j]
   23            j -= 1
   24
   25        # When you finish shifting the elements, you can position
   26        # `key_item` in its correct location
   27        array[j + 1] = key_item
   28
   29    return array
   

   8.

2. Kể từ

    1def insertion_sort(array):
    2    # Loop from the second element of the array until
    3    # the last element
    4    for i in range(1, len(array)):
    5        # This is the element we want to position in its
    6        # correct place
    7        key_item = array[i]
    8
    9        # Initialize the variable that will be used to
   10        # find the correct position of the element referenced
   11        # by `key_item`
   12        j = i - 1
   13
   14        # Run through the list of items (the left
   15        # portion of the array) and find the correct position
   16        # of the element referenced by `key_item`. Do this only
   17        # if `key_item` is smaller than its adjacent values.
   18        while j >= 0 and array[j] > key_item:
   19            # Shift the value one position to the left
   20            # and reposition j to point to the next element
   21            # (from right to left)
   22            array[j + 1] = array[j]
   23            j -= 1
   24
   25        # When you finish shifting the elements, you can position
   26        # `key_item` in its correct location
   27        array[j + 1] = key_item
   28
   29    return array
   

   9, thuật toán chuyển phần tử

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   0 một vị trí sang phải. Mảng kết quả tại thời điểm này là

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array we just created
    8    run_sorting_algorithm(algorithm="insertion_sort", array=array)
   

   1.

3. Vì không có thêm các yếu tố nào trong Subarray,

   $ python sorting.py
   Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
   

   8 hiện được đặt ở vị trí mới và mảng cuối cùng là

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   3.

4. Đường chuyền thứ hai bắt đầu với

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array we just created
    8    run_sorting_algorithm(algorithm="insertion_sort", array=array)
   

   4 và đi qua Subarray nằm bên trái, trong trường hợp này là

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array we just created
    8    run_sorting_algorithm(algorithm="insertion_sort", array=array)
   

   5.

5. Kể từ

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array we just created
    8    run_sorting_algorithm(algorithm="insertion_sort", array=array)
   

   6, thuật toán chuyển 8 sang phải. Mảng kết quả tại thời điểm này là

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array we just created
    8    run_sorting_algorithm(algorithm="insertion_sort", array=array)
   

   7.

6. Kể từ

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array we just created
    8    run_sorting_algorithm(algorithm="insertion_sort", array=array)
   

   8, thuật toán không cần phải tiếp tục đi qua Subarray, vì vậy nó định vị

   $ python sorting.py
   Algorithm: bubble_sort. Minimum execution time: 73.21720498399998
   

   8 và kết thúc đường chuyền thứ hai. Tại thời điểm này, mảng kết quả là

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   7.

7. Lần thứ ba thông qua danh sách đặt phần tử

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   9 ở vị trí chính xác của nó và phần tử thứ tư Pass đặt phần tử

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array you just created
    8    run_sorting_algorithm(algorithm="bubble_sort", array=array)
   

   3 ở đúng vị trí, để lại mảng được sắp xếp.

Đo lường chèn sắp xếp độ phức tạp thời gian chạy o lớn

Tương tự như triển khai Sắp xếp bong bóng của bạn, thuật toán sắp xếp chèn có một vài vòng lặp lồng nhau đi qua danh sách. Vòng bên trong khá hiệu quả vì nó chỉ đi qua danh sách cho đến khi nó tìm thấy vị trí chính xác của một phần tử. Điều đó nói rằng, thuật toán vẫn có độ phức tạp thời gian chạy O (N2) trên trường hợp trung bình.O(n2) runtime complexity on the average case.

Trường hợp xấu nhất xảy ra khi mảng được cung cấp được sắp xếp theo thứ tự ngược lại. Trong trường hợp này, vòng lặp bên trong phải thực hiện mọi so sánh để đặt mọi yếu tố vào vị trí chính xác của nó. Điều này vẫn cung cấp cho bạn độ phức tạp thời gian chạy O (N2).

Trường hợp tốt nhất xảy ra khi mảng được cung cấp đã được sắp xếp. Ở đây, vòng lặp bên trong không bao giờ được thực hiện, dẫn đến độ phức tạp thời gian chạy O (n), giống như trường hợp tốt nhất của loại bong bóng.

Mặc dù sắp xếp bong bóng và sắp xếp chèn có cùng độ phức tạp thời gian chạy O lớn, nhưng trong thực tế, loại chèn có hiệu quả hơn đáng kể so với sắp xếp bong bóng. Nếu bạn nhìn vào việc triển khai cả hai thuật toán, thì bạn có thể thấy cách sắp xếp chèn phải thực hiện ít so sánh hơn để sắp xếp danh sách.

Thời gian thực hiện sắp xếp chèn của bạn

Để chứng minh khẳng định rằng loại chèn hiệu quả hơn so với sắp xếp bong bóng, bạn có thể theo thời gian thuật toán loại chèn và so sánh nó với kết quả sắp xếp bong bóng. Để làm điều này, bạn chỉ cần thay thế cuộc gọi đến

21ARRAY_LENGTH = 10000
22
23if __name__ == "__main__":
24    # Generate an array of `ARRAY_LENGTH` items consisting
25    # of random integer values between 0 and 999
26    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
27
28    # Call the function using the name of the sorting algorithm
29    # and the array you just created
30    run_sorting_algorithm(algorithm="sorted", array=array)

 1if __name__ == "__main__":
 2    # Generate an array of `ARRAY_LENGTH` items consisting
 3    # of random integer values between 0 and 999
 4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
 5
 6    # Call the function using the name of the sorting algorithm
 7    # and the array we just created
 8    run_sorting_algorithm(algorithm="insertion_sort", array=array)

Bạn có thể thực thi tập lệnh như trước:

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

Lưu ý cách triển khai sắp xếp chèn mất khoảng

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

Phân tích điểm mạnh và điểm yếu của sự sắp xếp chèn

Giống như sắp xếp bong bóng, thuật toán loại chèn rất không phức tạp để thực hiện. Mặc dù sắp xếp chèn là thuật toán O (N2), nhưng nó cũng hiệu quả hơn nhiều trong thực tế so với các triển khai bậc hai khác như sắp xếp bong bóng.

Có nhiều thuật toán mạnh mẽ hơn, bao gồm cả Merge sắp xếp và Quicksort, nhưng các triển khai này là đệ quy và thường không đánh bại sắp xếp chèn khi làm việc trên các danh sách nhỏ. Một số triển khai QuickSort thậm chí sử dụng chèn sắp xếp nội bộ nếu danh sách đủ nhỏ để cung cấp triển khai tổng thể nhanh hơn. TimSort cũng sử dụng chèn sắp xếp bên trong để sắp xếp các phần nhỏ của mảng đầu vào.Timsort also uses insertion sort internally to sort small portions of the input array.

Điều đó nói rằng, loại chèn là không thực tế cho các mảng lớn, mở ra cánh cửa cho các thuật toán có thể mở rộng theo những cách hiệu quả hơn.

Thực hiện Sắp xếp hợp nhất trong Python

Việc thực hiện thuật toán sắp xếp hợp nhất cần hai phần khác nhau:

1. Một chức năng chia nhỏ đầu vào một nửa
2. Một chức năng hợp nhất cả hai nửa, tạo ra một mảng được sắp xếp

Tại đây, mã để hợp nhất hai mảng khác nhau:

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

• Dòng 4 và 9 Kiểm tra xem một trong hai mảng có trống không. Nếu một trong số họ là, thì không có gì để hợp nhất, vì vậy chức năng trả về mảng khác. check whether either of the arrays is empty. If one of them is, then there’s nothing to merge, so the function returns the other array.

• Dòng 17 bắt đầu một vòng

   1def insertion_sort(array):
   2    # Loop from the second element of the array until
   3    # the last element
   4    for i in range(1, len(array)):
   5        # This is the element we want to position in its
   6        # correct place
   7        key_item = array[i]
   8
   9        # Initialize the variable that will be used to
  10        # find the correct position of the element referenced
  11        # by `key_item`
  12        j = i - 1
  13
  14        # Run through the list of items (the left
  15        # portion of the array) and find the correct position
  16        # of the element referenced by `key_item`. Do this only
  17        # if `key_item` is smaller than its adjacent values.
  18        while j >= 0 and array[j] > key_item:
  19            # Shift the value one position to the left
  20            # and reposition j to point to the next element
  21            # (from right to left)
  22            array[j + 1] = array[j]
  23            j -= 1
  24
  25        # When you finish shifting the elements, you can position
  26        # `key_item` in its correct location
  27        array[j + 1] = key_item
  28
  29    return array
  

  3 kết thúc bất cứ khi nào kết quả chứa tất cả các phần tử từ cả hai mảng được cung cấp. Mục tiêu là xem xét cả hai mảng và kết hợp các mục của họ để tạo ra một danh sách được sắp xếp. starts a

   1def insertion_sort(array):
   2    # Loop from the second element of the array until
   3    # the last element
   4    for i in range(1, len(array)):
   5        # This is the element we want to position in its
   6        # correct place
   7        key_item = array[i]
   8
   9        # Initialize the variable that will be used to
  10        # find the correct position of the element referenced
  11        # by `key_item`
  12        j = i - 1
  13
  14        # Run through the list of items (the left
  15        # portion of the array) and find the correct position
  16        # of the element referenced by `key_item`. Do this only
  17        # if `key_item` is smaller than its adjacent values.
  18        while j >= 0 and array[j] > key_item:
  19            # Shift the value one position to the left
  20            # and reposition j to point to the next element
  21            # (from right to left)
  22            array[j + 1] = array[j]
  23            j -= 1
  24
  25        # When you finish shifting the elements, you can position
  26        # `key_item` in its correct location
  27        array[j + 1] = key_item
  28
  29    return array
  

  3 loop that ends whenever the result contains all the elements from both of the supplied arrays. The goal is to look into both arrays and combine their items to produce a sorted list.

• Dòng 21 so sánh các phần tử ở đầu của cả hai mảng, chọn giá trị nhỏ hơn và nối nó vào cuối mảng kết quả. compares the elements at the head of both arrays, selects the smaller value, and appends it to the end of the resultant array.

• Các dòng 31 và 35 nối bất kỳ mục còn lại vào kết quả nếu tất cả các phần tử từ một trong hai mảng đã được sử dụng. append any remaining items to the result if all the elements from either of the arrays were already used.

Với chức năng ở trên, phần còn thiếu duy nhất là một hàm chia nhỏ mảng đầu vào và sử dụng

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

Ở đây, một bản tóm tắt nhanh chóng về mã:

• Dòng 44 đóng vai trò là điều kiện dừng cho đệ quy. Nếu mảng đầu vào chứa ít hơn hai phần tử, thì hàm trả về mảng. Lưu ý rằng điều kiện này có thể được kích hoạt bằng cách nhận một mục hoặc một mảng trống. Trong cả hai trường hợp, không còn gì để sắp xếp, vì vậy chức năng sẽ trở lại. acts as the stopping condition for the recursion. If the input array contains fewer than two elements, then the function returns the array. Notice that this condition could be triggered by receiving either a single item or an empty array. In both cases, there’s nothing left to sort, so the function should return.

• Dòng 47 tính toán điểm giữa của mảng. computes the middle point of the array.

• Dòng 52 gọi

  >>> array = [8, 2, 6, 4, 5]
  >>> sorted(array)
  [2, 4, 5, 6, 8]
  

  05, vượt qua cả hai nửa được sắp xếp dưới dạng mảng. calls

  >>> array = [8, 2, 6, 4, 5]
  >>> sorted(array)
  [2, 4, 5, 6, 8]
  

  05, passing both sorted halves as the arrays.

Lưu ý cách chức năng này tự gọi mình là đệ quy, giảm một nửa mảng mỗi lần. Mỗi lần lặp lại liên quan đến một mảng không bao giờ thu hút cho đến khi vẫn còn ít hơn hai yếu tố, có nghĩa là không còn gì để sắp xếp. Tại thời điểm này,

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

Hãy xem một đại diện của các bước mà hợp nhất sắp xếp sẽ thực hiện để sắp xếp mảng

$ python sorting.py
Algorithm: sorted. Minimum execution time: 0.010945824000000007

Con số sử dụng mũi tên màu vàng để biểu diễn một nửa mảng ở mỗi cấp độ đệ quy. Các mũi tên màu xanh lá cây đại diện cho việc hợp nhất mỗi Subarray trở lại với nhau. Các bước có thể được tóm tắt như sau:

1. Cuộc gọi đầu tiên đến

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   11 với

   $ python sorting.py
   Algorithm: sorted. Minimum execution time: 0.010945824000000007
   

   8 định nghĩa

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   13 là

    1def bubble_sort(array):
    2    n = len(array)
    3
    4    for i in range(n):
    5        # Create a flag that will allow the function to
    6        # terminate early if there's nothing left to sort
    7        already_sorted = True
    8
    9        # Start looking at each item of the list one by one,
   10        # comparing it with its adjacent value. With each
   11        # iteration, the portion of the array that you look at
   12        # shrinks because the remaining items have already been
   13        # sorted.
   14        for j in range(n - i - 1):
   15            if array[j] > array[j + 1]:
   16                # If the item you're looking at is greater than its
   17                # adjacent value, then swap them
   18                array[j], array[j + 1] = array[j + 1], array[j]
   19
   20                # Since you had to swap two elements,
   21                # set the `already_sorted` flag to `False` so the
   22                # algorithm doesn't finish prematurely
   23                already_sorted = False
   24
   25        # If there were no swaps during the last iteration,
   26        # the array is already sorted, and you can terminate
   27        if already_sorted:
   28            break
   29
   30    return array
   

   1.

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   13 được sử dụng để giảm một nửa mảng đầu vào thành

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   16 và

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   17, tạo ra

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   18 và

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   19, tương ứng.

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   11 sau đó được gọi đệ quy cho mỗi nửa để sắp xếp chúng một cách riêng biệt.

2. Cuộc gọi đến

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   11 với

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   18 tạo ra

    1def insertion_sort(array):
    2    # Loop from the second element of the array until
    3    # the last element
    4    for i in range(1, len(array)):
    5        # This is the element we want to position in its
    6        # correct place
    7        key_item = array[i]
    8
    9        # Initialize the variable that will be used to
   10        # find the correct position of the element referenced
   11        # by `key_item`
   12        j = i - 1
   13
   14        # Run through the list of items (the left
   15        # portion of the array) and find the correct position
   16        # of the element referenced by `key_item`. Do this only
   17        # if `key_item` is smaller than its adjacent values.
   18        while j >= 0 and array[j] > key_item:
   19            # Shift the value one position to the left
   20            # and reposition j to point to the next element
   21            # (from right to left)
   22            array[j + 1] = array[j]
   23            j -= 1
   24
   25        # When you finish shifting the elements, you can position
   26        # `key_item` in its correct location
   27        array[j + 1] = key_item
   28
   29    return array
   

   8 và

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   24. Quá trình lặp lại cho mỗi nửa này.

3. Cuộc gọi đến

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   11 với

    1def insertion_sort(array):
    2    # Loop from the second element of the array until
    3    # the last element
    4    for i in range(1, len(array)):
    5        # This is the element we want to position in its
    6        # correct place
    7        key_item = array[i]
    8
    9        # Initialize the variable that will be used to
   10        # find the correct position of the element referenced
   11        # by `key_item`
   12        j = i - 1
   13
   14        # Run through the list of items (the left
   15        # portion of the array) and find the correct position
   16        # of the element referenced by `key_item`. Do this only
   17        # if `key_item` is smaller than its adjacent values.
   18        while j >= 0 and array[j] > key_item:
   19            # Shift the value one position to the left
   20            # and reposition j to point to the next element
   21            # (from right to left)
   22            array[j + 1] = array[j]
   23            j -= 1
   24
   25        # When you finish shifting the elements, you can position
   26        # `key_item` in its correct location
   27        array[j + 1] = key_item
   28
   29    return array
   

   8 trả về

    1def insertion_sort(array):
    2    # Loop from the second element of the array until
    3    # the last element
    4    for i in range(1, len(array)):
    5        # This is the element we want to position in its
    6        # correct place
    7        key_item = array[i]
    8
    9        # Initialize the variable that will be used to
   10        # find the correct position of the element referenced
   11        # by `key_item`
   12        j = i - 1
   13
   14        # Run through the list of items (the left
   15        # portion of the array) and find the correct position
   16        # of the element referenced by `key_item`. Do this only
   17        # if `key_item` is smaller than its adjacent values.
   18        while j >= 0 and array[j] > key_item:
   19            # Shift the value one position to the left
   20            # and reposition j to point to the next element
   21            # (from right to left)
   22            array[j + 1] = array[j]
   23            j -= 1
   24
   25        # When you finish shifting the elements, you can position
   26        # `key_item` in its correct location
   27        array[j + 1] = key_item
   28
   29    return array
   

   8 vì đó là yếu tố duy nhất. Điều tương tự cũng xảy ra với cuộc gọi đến

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   11 với

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   24.

4. Tại thời điểm này, chức năng bắt đầu hợp nhất các subarrays lại với nhau bằng cách sử dụng ____105, bắt đầu bằng

    1def insertion_sort(array):
    2    # Loop from the second element of the array until
    3    # the last element
    4    for i in range(1, len(array)):
    5        # This is the element we want to position in its
    6        # correct place
    7        key_item = array[i]
    8
    9        # Initialize the variable that will be used to
   10        # find the correct position of the element referenced
   11        # by `key_item`
   12        j = i - 1
   13
   14        # Run through the list of items (the left
   15        # portion of the array) and find the correct position
   16        # of the element referenced by `key_item`. Do this only
   17        # if `key_item` is smaller than its adjacent values.
   18        while j >= 0 and array[j] > key_item:
   19            # Shift the value one position to the left
   20            # and reposition j to point to the next element
   21            # (from right to left)
   22            array[j + 1] = array[j]
   23            j -= 1
   24
   25        # When you finish shifting the elements, you can position
   26        # `key_item` in its correct location
   27        array[j + 1] = key_item
   28
   29    return array
   

   8 và

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   24 làm mảng đầu vào, tạo ra

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array we just created
    8    run_sorting_algorithm(algorithm="insertion_sort", array=array)
   

   5 do kết quả.

5. Ở phía bên kia,

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   19 bị phá vỡ đệ quy và được hợp nhất bằng cách sử dụng cùng một quy trình, tạo ra

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   35 do kết quả.

6. Trong bước cuối cùng,

    1if __name__ == "__main__":
    2    # Generate an array of `ARRAY_LENGTH` items consisting
    3    # of random integer values between 0 and 999
    4    array = [randint(0, 1000) for i in range(ARRAY_LENGTH)]
    5
    6    # Call the function using the name of the sorting algorithm
    7    # and the array we just created
    8    run_sorting_algorithm(algorithm="insertion_sort", array=array)
   

   5 và

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   35 được hợp nhất lại với

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   05, tạo ra kết quả cuối cùng:

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   39.

Đo lường sự phức tạp của Merge sắp xếp o

Để phân tích sự phức tạp của Sắp xếp hợp nhất, bạn có thể nhìn vào hai bước của nó một cách riêng biệt:

1. >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   05 có thời gian chạy tuyến tính. Nó nhận được hai mảng có chiều dài kết hợp nhiều nhất là N (độ dài của mảng đầu vào ban đầu) và nó kết hợp cả hai mảng bằng cách nhìn vào từng phần tử nhiều nhất một lần. Điều này dẫn đến độ phức tạp thời gian chạy của O (N).

2. Bước thứ hai phân tách mảng đầu vào đệ quy và gọi

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   05 cho mỗi nửa. Vì mảng được giảm một nửa cho đến khi một phần tử duy nhất vẫn còn, tổng số hoạt động giảm một nửa được thực hiện bởi hàm này là log2n. Vì

   >>> array = [8, 2, 6, 4, 5]
   >>> sorted(array)
   [2, 4, 5, 6, 8]
   

   05 được gọi cho mỗi nửa, chúng tôi nhận được tổng thời gian chạy O (n log2N).O(n log2n).

Thật thú vị, O (n log2n) là thời gian chạy trong trường hợp xấu nhất có thể có thể đạt được bằng thuật toán sắp xếp.

Thời gian thực hiện sắp xếp hợp nhất của bạn

Để so sánh tốc độ hợp nhất sắp xếp với hai triển khai trước đó, bạn có thể sử dụng cùng một cơ chế như trước đây và thay thế tên của thuật toán trong dòng 8:line 8:

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

Bạn có thể thực thi tập lệnh để có thời gian thực hiện là

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

So với sắp xếp bong bóng và sắp xếp chèn, việc triển khai Merge sắp xếp cực kỳ nhanh, sắp xếp mảng mười nghìn phần tử trong chưa đầy một giây!

Phân tích điểm mạnh và điểm yếu của sự hợp nhất

Nhờ độ phức tạp thời gian chạy của O (n log2N), Merge Sort là một thuật toán rất hiệu quả, có tỷ lệ tốt như kích thước của mảng đầu vào phát triển. Nó cũng đơn giản để song song hóa vì nó chia mảng đầu vào thành các khối có thể được phân phối và xử lý song song nếu cần thiết.parallelize because it breaks the input array into chunks that can be distributed and processed in parallel if necessary.

Điều đó nói rằng, đối với các danh sách nhỏ, chi phí thời gian của đệ quy cho phép các thuật toán như sắp xếp bong bóng và sắp xếp chèn nhanh hơn. Ví dụ: chạy thử nghiệm với danh sách mười yếu tố dẫn đến các thời điểm sau:

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

Cả hai loại bong bóng và chèn sắp xếp Beat Merge sắp xếp khi sắp xếp một danh sách mười phần tử.

Một nhược điểm khác của Sắp xếp hợp nhất là nó tạo ra các bản sao của mảng khi tự gọi mình là đệ quy. Nó cũng tạo ra một danh sách mới bên trong

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

Do giới hạn này, bạn có thể không muốn sử dụng Merge sắp xếp để sắp xếp các danh sách lớn trong phần cứng bị hạn chế bộ nhớ.