Hãy nhập câu hỏi của bạn vào đây, nếu là tài khoản VIP, bạn sẽ được ưu tiên trả lời.
*Thuật toán sắp xếp chèn (Insertion Sort):
import time
def insertion_sort(arr):
n = len(arr)
for i in range(1, n):
key = arr[i]
j = i - 1
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
# Dãy số nguyên đầu vào
A = [3, 1, 0, 10, 13, 16, 9, 7, 5, 1]
# In dãy số nguyên trước khi sắp xếp
print("Dãy số nguyên trước khi sắp xếp:", A)
# Bắt đầu đo thời gian thực hiện thuật toán
start_time = time.time()
# Gọi hàm sắp xếp chèn
insertion_sort(A)
# Kết thúc đo thời gian thực hiện thuật toán
end_time = time.time()
# In dãy số nguyên sau khi sắp xếp
print("Dãy số nguyên sau khi sắp xếp:", A)
# In thời gian thực hiện thuật toán
print("Thời gian thực hiện thuật toán: {:.6f} giây".format(end_time - start_time))
Thời gian thực hiện là 0 giây
*Thuật toán sắp xếp chọn:
import time
def selection_sort(arr):
n = len(arr)
for i in range(n):
min_idx = i
for j in range(i + 1, n):
if arr[j] < arr[min_idx]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
# Dãy số nguyên đầu vào
A = [3, 1, 0, 10, 13, 16, 9, 7, 5, 1]
# In dãy số nguyên trước khi sắp xếp
print("Dãy số nguyên trước khi sắp xếp:", A)
# Bắt đầu đo thời gian thực hiện thuật toán
start_time = time.time()
# Gọi hàm sắp xếp chọn
selection_sort(A)
# Kết thúc đo thời gian thực hiện thuật toán
end_time = time.time()
# In dãy số nguyên sau khi sắp xếp
print("Dãy số nguyên sau khi sắp xếp:", A)
# In thời gian thực hiện thuật toán
print("Thời gian thực hiện thuật toán: {:.6f} giây".format(end_time - start_time))
Thời gian thực hiện là: 0 giây
*Thuật toán sắp xếp nổi bọt:
import time
def bubble_sort(arr):
n = len(arr)
for i in range(n - 1):
for j in range(n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
# Dãy số nguyên đầu vào
A = [3, 1, 0, 10, 13, 16, 9, 7, 5, 1]
# In dãy số nguyên trước khi sắp xếp
print("Dãy số nguyên trước khi sắp xếp:", A)
# Bắt đầu đo thời gian thực hiện thuật toán
start_time = time.time()
# Gọi hàm sắp xếp nổi bọt
bubble_sort(A)
# Kết thúc đo thời gian thực hiện thuật toán
end_time = time.time()
# In dãy số nguyên sau khi sắp xếp
print("Dãy số nguyên sau khi sắp xếp:", A)
# In thời gian thực hiện thuật toán
print("Thời gian thực hiện thuật toán: {:.6f} giây".format(end_time - start_time))
Thời gian thực hiện là: 0 giây
THAM KHẢO!
1.Thuật toán sắp xếp chèn (Insertion Sort):
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr
A = [5, 8, 1, 0, 10, 4, 3]
sorted_A = insertion_sort(A)
print("Dãy A sau khi sắp xếp chèn:", sorted_A)
2. Thuật toán sắp xếp chọn (Selection Sort):
def selection_sort(arr):
for i in range(len(arr)):
min_idx = i
for j in range(i + 1, len(arr)):
if arr[j] < arr[min_idx]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
return arr
A = [5, 8, 1, 0, 10, 4, 3]
sorted_A = selection_sort(A)
print("Dãy A sau khi sắp xếp chọn:", sorted_A)
3.Thuật toán sắp xếp nổi bọt (Bubble Sort):
def bubble_sort(arr):
n = len(arr)
for i in range(n - 1):
for j in range(n - 1 - i):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
A = [5, 8, 1, 0, 10, 4, 3]
sorted_A = bubble_sort(A)
print("Dãy A sau khi sắp xếp nổi bọt:", sorted_A)
Thuật toán sắp xếp nổi bọt hoạt động bằng cách so sánh các phần tử kế tiếp trong danh sách và hoán đổi chúng nếu chúng không được sắp xếp theo thứ tự. Quá trình lặp sẽ tiếp tục cho đến khi tất cả các phần tử đều được sắp xếp. Vì vậy khi màu của tất cả các mũi tên đều đỏ trong sơ đồ mô phỏng thì có nghĩa là không còn phần tử nào được sắp xếp theo thứ tự tăng dần hoặc giảm dần và không cần thực hiện bất kỳ hoán đổi nào nữa.
- Bắt đầu từ vị trí đầu tiên của danh sách (bên trái), so sánh các cặp số với nhau, nếu không đúng thứ tự nhỏ-lớn thì đảo vị trí.
- Sau khi chạy tới cuối danh sách, tiếp tục chạy lại từ vị trí đầu danh sách cho đến khi hoàn thành so sánh và đảo vị trí.
- Bước 1: i = 0;
- Bước 2: Tìm phần tử a[min] nhỏ nhất trong dãy hiện hành từ a[i] đến a[n-1].
- Bước 3: Đổi chỗ a[min] và a[i].
- Bước 4: Nếu i < n-1 thì gán i = i+1; rồi lặp lại bước 2, ngược lại -> Dừng.
Cả hai thuật toán sắp xếp nổi bọt và sắp xếp chèn đều đơn giản và dễ cài đặt. Tuy nhiên, thuật toán sắp xếp chèn có thể được coi là đơn giản hơn vì nó sử dụng ít phép so sánh hơn so với thuật toán sắp xếp nổi bọt.
Thuật toán sắp xếp chèn thực hiện việc chèn một phần tử vào một mảng đã được sắp xếp trước đó. Với mỗi phần tử trong mảng, nó sẽ so sánh nó với các phần tử đã được sắp xếp trước đó, và chèn phần tử đó vào vị trí thích hợp trong mảng. Điều này đòi hỏi ít phép so sánh hơn so với thuật toán sắp xếp nổi bọt, do đó thuật toán sắp xếp chèn có hiệu suất tốt hơn khi sắp xếp một mảng lớn.
Trong khi đó, thuật toán sắp xếp nổi bọt cần thực hiện nhiều phép so sánh hơn và có thể không hiệu quả khi sắp xếp mảng lớn. Nó hoạt động bằng cách so sánh các cặp phần tử liên tiếp trong mảng và đổi chỗ chúng nếu chúng không được sắp xếp đúng thứ tự. Vì vậy, trong nhiều trường hợp, thuật toán sắp xếp chèn được ưa chuộng hơn do hiệu quả và tính đơn giản của nó.
a)
import time
def linear_search(arr, x):
"""
Tìm kiếm tuyến tính trong dãy arr để tìm giá trị x.
Trả về vị trí của x trong dãy nếu x được tìm thấy, -1 nếu không tìm thấy.
"""
n = len(arr)
for i in range(n):
if arr[i] == x:
return i
return -1
# Dãy số A
A = [3, 1, 0, 10, 13, 16, 9, 7, 5, 11]
# Phần tử cần tìm kiếm
C = 9
# Bắt đầu đo thời gian
start_time = time.perf_counter()
# Tìm kiếm phần tử C trong dãy A
result = linear_search(A, C)
# Kết thúc đo thời gian
end_time = time.perf_counter()
if result != -1:
print(f"Phần tử {C} được tìm thấy tại vị trí {result} trong dãy A.")
else:
print(f"Phần tử {C} không có trong dãy A.")
print(f"Thời gian thực hiện thuật toán: {end_time - start_time} giây.")
b)
import time
def binary_search(arr, x):
"""
Tìm kiếm nhị phân trong dãy arr để tìm giá trị x.
Trả về vị trí của x trong dãy nếu x được tìm thấy, -1 nếu không tìm thấy.
"""
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == x:
return mid
elif arr[mid] < x:
left = mid + 1
else:
right = mid - 1
return -1
# Dãy số A đã được sắp xếp
A = [0, 1, 3, 5, 7, 9, 10, 11, 13, 16]
# Phần tử cần tìm kiếm
C = 9
# Bắt đầu đo thời gian
start_time = time.perf_counter()
# Tìm kiếm phần tử C trong dãy A bằng thuật toán tìm kiếm nhị phân
result = binary_search(A, C)
# Kết thúc đo thời gian
end_time = time.perf_counter()
if result != -1:
print(f"Phần tử {C} được tìm thấy tại vị trí {result} trong dãy A.")
else:
print(f"Phần tử {C} không có trong dãy A.")
print(f"Thời gian thực hiện thuật toán: {end_time - start_time} giây.")
-Thời gian thực hiện ở câu a là 8.99999,thời gian thực hiện ở câu b là 6,49999 giây.
- Các thuật toán và chương trình mà em đã biết đều là các thuật toán cơ bản trong lập trình và giải quyết các vấn đề thông thường. Các điểm chung của chúng bao gồm: Tính đơn giản, độ phức tạp thấp.
- Theo em, để thiết kế một thuật toán đúng giải một bái toàn cho trước cần trải qua các bước:
1. Xác định bài toán
2. Tìm cấu trúc dữ liệu biểu diễn thuật toán.
3. Tìm Thuật Toán.
4. Lập Trình (Programming)
5. Kiểm thử chương trình (Testing program)
6. Tối ưu chương trình (optimization program)
THAM KHẢO!
def bubble_sort(arr):
n = len(arr)
for i in range(n - 1):
for j in range(0, n - i - 1):
if arr[j] < arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
# Đọc dữ liệu từ file diem.inp
with open('diem.inp', 'r') as file:
lines = file.readlines()
scores = [float(line.strip()) for line in lines]
# Sắp xếp danh sách điểm trung bình giảm dần
bubble_sort(scores)
# In danh sách điểm trung bình đã được sắp xếp ra màn hình
print("Danh sách điểm trung bình giảm dần:")
for score in scores:
print(score)
Thuật toán sắp xếp nổi bọt (Bubble Sort) theo chiều giảm dần: Bộ số ban đầu: 2, -3, 9, 2, 8, 6, 10, -3 1. Lần 1: - So sánh 2 và -3 => đổi chỗ: -3, 2, 9, 2, 8, 6, 10, -3 - So sánh 2 và 9 => giữ nguyên: -3, 2, 9, 2, 8, 6, 10, -3 - So sánh 9 và 2 => đổi chỗ: -3, 2, 2, 9, 8, 6, 10, -3 - So sánh 9 và 8 => đổi chỗ: -3, 2, 2, 8, 9, 6, 10, -3 - So sánh 9 và 6 => đổi chỗ: -3, 2, 2, 8, 6, 9, 10, -3 - So sánh 10 và -3 => đổi chỗ: -3, 2, 2, 8, 6, 9, -3, 10 2. Lần 2: - So sánh -3 và 2 => giữ nguyên: -3, 2, 2, 8, 6, 9, -3, 10 - So sánh 2 và 2 => giữ nguyên: -3, 2, 2, 8, 6, 9, -3, 10 - So sánh 2 và 8 => giữ nguyên: -3, 2, 2, 8, 6, 9, -3, 10 - So sánh 8 và 6 => đổi chỗ: -3, 2, 2, 6, 8, 9, -3, 10 - So sánh 8 và 9 => giữ nguyên: -3, 2, 2, 6, 8, 9, -3, 10 - So sánh 9 và -3 => đổi chỗ: -3, 2, 2, 6, 8, -3, 9, 10 3. Lần 3: - So sánh -3 và 2 => giữ nguyên: -3, 2, 2, 6, 8, -3, 9, 10 - So sánh 2 và 2 => giữ nguyên: -3, 2, 2, 6, 8, -3, 9, 10 - So sánh 2 và 6 => giữ nguyên: -3, 2, 2, 6, 8, -3, 9, 10 - So sánh 6 và 8 => giữ nguyên: -3, 2, 2, 6, 8, -3, 9, 10 - So sánh 8 và -3 => đổi chỗ: -3, 2, 2, 6, -3, 8, 9, 10 4. Lần 4: - So sánh -3 và 2 => giữ nguyên: -3, 2, 2, 6, -3, 8, 9, 10 - So sánh 2 và 2 => giữ nguyên: -3, 2, 2, 6, -3, 8, 9, 10 - So sánh 2 và 6 => giữ nguyên: -3, 2, 2, 6, -3, 8, 9, 10 - So sánh 6 và -3 => đổi chỗ: -3, 2, 2, -3, 6, 8, 9, 10 5. Lần 5: - So sánh -3 và 2 => giữ nguyên: -3, 2, 2, -3, 6, 8, 9, 10 - So sánh 2 và 2 => giữ nguyên: -3, 2, 2, -3, 6, 8, 9, 10 - So sánh 2 và -3 => đổi chỗ: -3, -3, 2, 2, 6, 8, 9, 10 Kết quả cuối cùng: 10, 9, 8, 6, 2, 2, -3, -3 😊
Dãy ban đầu: 2, -3, 9, 2, 8, 6, 10, -3 🔹 Lần 1: 2, 9, 2, 8, 6, 10, -3, -3 🔹 Lần 2 9, 2, 8, 6, 10, 2, -3, -3 🔹 Lần 3 9, 8, 6, 10, 2, 2, -3, -3 🔹 Lần 4 9, 8, 10, 6, 2, 2, -3, -3 🔹 Lần 5 9, 10, 8, 6, 2, 2, -3, -3 🔹 Lần 6: 10, 9, 8, 6, 2, 2, -3, -3 Kết quả giãy giảm dần là 10, 9, 8, 6, 2, 2, -3, -3
Lần 1:
(2, -3, 9, 2, 8, 6, 10, -3)
→ (2, 9, -3, 2, 8, 6, 10, -3)
→ (2, 9, 2, -3, 8, 6, 10, -3)
→ (2, 9, 2, 8, -3, 6, 10, -3)
→ (2, 9, 2, 8, 6, -3, 10, -3)
→ (2, 9, 2, 8, 6, 10, -3, -3)
→ (2, 9, 2, 8, 6, 10, -3, -3)
Lần 2:
→ (9, 2, 2, 8, 6, 10, -3, -3)
→ (9, 2, 8, 2, 6, 10, -3, -3)
→ (9, 2, 8, 6, 2, 10, -3, -3)
→ (9, 2, 8, 6, 10, 2, -3, -3)
Lần 3:
→ (9, 8, 2, 6, 10, 2, -3, -3)
→ (9, 8, 6, 2, 10, 2, -3, -3)
→ (9, 8, 6, 10, 2, 2, -3, -3)
Lần 4:
→ (9, 8, 10, 6, 2, 2, -3, -3)
Lần 5:
→ (9, 10, 8, 6, 2, 2, -3, -3)
Lần 6:
→ (10, 9, 8, 6, 2, 2, -3, -3)
Kết quả:(10, 9, 8, 6, 2, 2, -3, -3)
- So sánh 2 và -3: 2 > −3 (Đúng, giữ nguyên). Dãy: 2, -3, 9, 2, 8, 6, 10, -3
- So sánh -3 và 9: −3 <9 (Đổi chỗ). Dãy: 2, 9, -3, 2, 8, 6, 10, -3
- So sánh -3 và 2: −3 <2 (Đổi chỗ). Dãy: 2, 9, 2, -3, 8, 6, 10, -3
- So sánh -3 và 8: −3 <8 (Đổi chỗ). Dãy: 2, 9, 2, 8, -3, 6, 10, -3
- So sánh -3 và 6: −3 <6 (Đổi chỗ). Dãy: 2, 9, 2, 8, 6, -3, 10, -3
- So sánh -3 và 10: −3 <10 (Đổi chỗ). Dãy: 2, 9, 2, 8, 6, 10, -3, -3
- So sánh -3 và -3: (Bằng nhau, giữ nguyên).
Lượt 2:Kết thúc lượt 1: Số -3 nhỏ nhất đã nằm ở cuối.
Dãy hiện tại: 2, 9, 2, 8, 6, 10, -3, -3
- (2, 9) →→ Đổi: 9, 2, 2, 8, 6, 10, -3, -3
- (2, 2) →→ Không đổi.
- (2, 8) →→ Đổi: 9, 2, 8, 2, 6, 10, -3, -3
- (2, 6) →→ Đổi: 9, 2, 8, 6, 2, 10, -3, -3
- (2, 10) →→ Đổi: 9, 2, 8, 6, 10, 2, -3, -3
Lượt 3:Dãy hiện tại: 9, 2, 8, 6, 10, 2, -3, -3
- (9, 2) →→ Không đổi.
- (2, 8) →→ Đổi: 9, 8, 2, 6, 10, 2, -3, -3
- (2, 6) →→ Đổi: 9, 8, 6, 2, 10, 2, -3, -3
- (2, 10) →→ Đổi: 9, 8, 6, 10, 2, 2, -3, -3
Lượt 4:Dãy hiện tại: 9, 8, 6, 10, 2, 2, -3, -3
- (9, 8), (8, 6) →→ Không đổi.
- (6, 10) →→ Đổi: 9, 8, 10, 6, 2, 2, -3, -3
Lượt 5:Dãy hiện tại: 9, 8, 10, 6, 2, 2, -3, -3
- (9, 8) →→ Không đổi.
- (8, 10) →→ Đổi: 9, 10, 8, 6, 2, 2, -3, -3
Lượt 6:Dãy hiện tại: 9, 10, 8, 6, 2, 2, -3, -3
- (9, 10) →→ Đổi: 10, 9, 8, 6, 2, 2, -3, -3
Lượt 7:Dãy hiện tại: 10, 9, 8, 6, 2, 2, -3, -3
- Kiểm tra toàn bộ dãy, không còn cặp nào cần đổi chỗ.
Kết quả cuối cùng: Dãy số sau khi sắp xếp giảm dần là:10, 9, 8, 6, 2, 2, -3, -3
10, 9, 8, 6, 2, 2, -3, -3
Mô phỏng Bubble Sort (giảm dần) trên dãy: [2, -3, 9, 2, 8, 6, 10, -3]
Quy tắc: duyệt từ đầu đến cuối, nếu a < a[i+1] thì đổi chỗ (đưa số lớn hơn “nổi” lên trước). Lặp cho tới khi không còn đổi chỗ.
Kết quả sau từng vòng (pass):
- Ban đầu: [2, -3, 9, 2, 8, 6, 10, -3]
- Sau pass 1: [2, 9, 2, 8, 6, 10, -3, -3]
- Sau pass 2: [9, 2, 8, 6, 10, 2, -3, -3]
- Sau pass 3: [9, 8, 6, 10, 2, 2, -3, -3]
- Sau pass 4: [9, 8, 10, 6, 2, 2, -3, -3]
- Sau pass 5: [9, 10, 8, 6, 2, 2, -3, -3]
- Sau pass 6: [10, 9, 8, 6, 2, 2, -3, -3]
- Pass 7: không đổi → dừng.
Kết quả cuối (giảm dần): *[10, 9, 8, 6, 2, 2, -3, -3]*
10,9,8,6,2,2,-3,-3
10,9,8,6,2,2,-3,-3
Sắp xếp nổi bọt (bubble sort) theo giảm dần → số lớn đứng trước. Dãy ban đầu: 2, -3, 9, 2, 8, 6, 10, -3 Sau khi sắp xếp giảm dần: 10, 9, 8, 6, 2, 2, -3, -3
10, 9 , 8 , 6, 2 , 2 , -3 ,-3
Dãy ban đầu:
2, -3, 9, 2, 8, 6, 10, -3
Nguyên tắc
So sánh từng cặp phần tử kề nhau
Nếu phần tử trước < phần tử sau → hoán đổi (để đạt giảm dần)
Lần 1:
So sánh từng cặp:
(2, -3) → đúng thứ tự → giữ
(-3, 9) → đổi → 2, 9, -3, 2, 8, 6, 10, -3
(-3, 2) → đổi → 2, 9, 2, -3, 8, 6, 10, -3
(-3, 8) → đổi → 2, 9, 2, 8, -3, 6, 10, -3
(-3, 6) → đổi → 2, 9, 2, 8, 6, -3, 10, -3
(-3, 10) → đổi → 2, 9, 2, 8, 6, 10, -3, -3
(-3, -3) → giữ
👉 Kết quả lần 1:
2, 9, 2, 8, 6, 10, -3, -3
Lần 2:
(2, 9) → đổi → 9, 2, 2, 8, 6, 10, -3, -3
(2, 2) → giữ
(2, 8) → đổi → 9, 2, 8, 2, 6, 10, -3, -3
(2, 6) → đổi → 9, 2, 8, 6, 2, 10, -3, -3
(2, 10) → đổi → 9, 2, 8, 6, 10, 2, -3, -3
(2, -3) → giữ
👉 Kết quả lần 2:
9, 2, 8, 6, 10, 2, -3, -3
Lần 3:
(9, 2) → giữ
(2, 8) → đổi → 9, 8, 2, 6, 10, 2, -3, -3
(2, 6) → đổi → 9, 8, 6, 2, 10, 2, -3, -3
(2, 10) → đổi → 9, 8, 6, 10, 2, 2, -3, -3
(2, 2) → giữ
👉 Kết quả lần 3:
9, 8, 6, 10, 2, 2, -3, -3
Lần 4:
(9, 8) → giữ
(8, 6) → giữ
(6, 10) → đổi → 9, 8, 10, 6, 2, 2, -3, -3
(6, 2) → giữ
👉 Kết quả lần 4:
9, 8, 10, 6, 2, 2, -3, -3
Lần 5:
(9, 8) → giữ
(8, 10) → đổi → 9, 10, 8, 6, 2, 2, -3, -3
(8, 6) → giữ
👉 Kết quả lần 5:
9, 10, 8, 6, 2, 2, -3, -3
Lần 6:
(9, 10) → đổi → 10, 9, 8, 6, 2, 2, -3, -3
👉 Kết quả lần 6:
10, 9, 8, 6, 2, 2, -3, -3
Lần 7:
Không còn hoán đổi → dừng
Kết quả cuối cùng (giảm dần):
10, 9, 8, 6, 2, 2, -3, -3
Dãy ban đầu: 2, -3, 9, 2, 8, 6, 10, -3 Nguyên tắc: So sánh các cặp kề nhau, nếu sai thứ tự giảm dần thì đổi chỗ. *Lượt 1: (2, -3) → không đổi (-3, 9) → đổi → 2, 9, -3, 2, 8, 6, 10, -3 (-3, 2) → đổi → 2, 9, 2, -3, 8, 6, 10, -3 (-3, 8)→ đổi → 2, 9, 2, 8, -3, 6, 10, -3 (-3, 6) → đổi → 2, 9, 2, 8, 6, -3, 10, -3 (-3, 10) → đổi → 2, 9, 2, 8, 6, 10, -3, -3 - Cuối lượt 1: 2, 9, 2, 8, 6, 10, -3, -3 *Lượt 2: (2, 9) → đổi → 9, 2, 2, 8, 6, 10, -3, -3 (2, 2) → không đổi (2;8) → đổi → 9, 2, 8, 2, 6, 10, -3, -3 (2, 6) → đổi → 9, 2, 8, 6, 2, 10, -3, -3 (2, 10) → đổi → 9, 2, 8, 6, 10, 2, -3, -3 - Cuối lượt 2: 9, 2, 8, 6, 10, 2, -3, -3 *Lượt 3: (9, 2) → không đổi (2;8) → đổi → 9, 8, 2, 6, 10, 2, -3, -3 (2, 6) → đổi → 9, 8, 6, 2, 10, 2, -3, -3 (2, 10) → đổi → 9, 8, 6, 10, 2, 2, -3, -3 - Cuối lượt 3: 9, 8, 6, 10, 2, 2, -3, -3 *Lượt 4: (9,8) → không đổi (8, 6) → không đổi (6, 10) → đổi → 9, 8, 10, 6, 2, 2, -3, -3 - Cuối lượt 4: 9, 8, 10, 6, 2, 2, -3, -3 *Lượt 5: (9,8) → không đổi (8, 10) → đổi → 9, 10, 8, 6, 2, 2, -3, -3 Cuối lượt 5: 9, 10, 8, 6, 2, 2, -3, -3 *Lượt 6: (9, 10) → đổi → 10, 9, 8, 6, 2, 2, -3, -3 - Cuối lượt 6: 10, 9, 8, 6, 2, 2, -3, -3 Kết luận: 10, 9, 8, 6, 2, 2, -3, -3
2, -3, 9, 2, 8, 6, 10, -3) → (2, 9, -3, 2, 8, 6, 10, -3) → (2, 9, 2, -3, 8, 6, 10, -3) → (2, 9, 2, 8, -3, 6, 10, -3) → (2, 9, 2, 8, 6, -3, 10, -3) → (2, 9, 2, 8, 6, 10, -3, -3) → (2, 9, 2, 8, 6, 10, -3, -3) Lần 2: → (9, 2, 2, 8, 6, 10, -3, -3) → (9, 2, 8, 2, 6, 10, -3, -3) → (9, 2, 8, 6, 2, 10, -3, -3) → (9, 2, 8, 6, 10, 2, -3, -3) Lần 3: → (9, 8, 2, 6, 10, 2, -3, -3) → (9, 8, 6, 2, 10, 2, -3, -3) → (9, 8, 6, 10, 2, 2, -3, -3) Lần 4: → (9, 8, 10, 6, 2, 2, -3, -3) Lần 5: → (9, 10, 8, 6, 2, 2, -3, -3) Lần 6: → (10, 9, 8, 6, 2, 2, -3, -3) Kết quả:(10, 9, 8, 6, 2, 2, -3, -3)
10, 9, 8, 6, 2, 2, -3, -3
10,9,8,6,2,-3,-3
arr = [2, -3, 9, 2, 8, 6, 10, -3]
n = len(arr)
for i in range(n):
for j in range(0, n - i - 1):
if arr[j] < arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
print(arr)
Lần1: [2, -3, 9, 2, 8, 6, 10, -3]
→ [2, 9, -3, 2, 8, 6, 10, -3]
→ [2, 9, 2, -3, 8, 6, 10, -3]
→ [2, 9, 2, 8, -3, 6, 10, -3]
→ [2, 9, 2, 8, 6, -3, 10, -3]
→ [2, 9, 2, 8, 6, 10, -3, -3]
→ [2, 9, 2, 8, 6, 10, -3, -3]
Lần2: [9, 2, 2, 8, 6, 10, -3, -3]
→ [9, 2, 8, 2, 6, 10, -3, -3]
→ [9, 2, 8, 6, 2, 10, -3, -3]
→ [9, 2, 8, 6, 10, 2, -3, -3]
→ [9, 2, 8, 6, 10, 2, -3, -3]
Lần3: [9, 8, 2, 6, 10, 2, -3, -3]
→ [9, 8, 6, 2, 10, 2, -3, -3]
→ [9, 8, 6, 10, 2, 2, -3, -3]
Lần4: [9, 8, 6, 10, 2, 2, -3, -3]
→ [9, 8, 10, 6, 2, 2, -3, -3]
Lần5: [9, 10, 8, 6, 2, 2, -3, -3]
→ [10, 9, 8, 6, 2, 2, -3, -3]
10, 9, 8, 6, 2, 2, -3, -3
10,9,8,6,2,2,-3,-3
Dãy ban đầu:
2, -3, 9, 2, 8, 6, 10, -3
L1: 2, 9, 2, 8, 6, 10, -3, -3
L2: 9, 2, 8, 6, 10, 2, -3, -3
L3: 9, 8, 6, 10, 2, 2, -3, -3
L4: 9, 8, 10, 6, 2, 2, -3, -3
L5: 9, 10, 8, 6, 2, 2, -3, -3
L6: 10, 9, 8, 6, 2, 2, -3, -3
Kết quả: 10, 9, 8, 6, 2, 2, -3, -3
A = [2, -3, 9, 2, 8, 6, 10, -3]
n = len(A)
for i in range(n-1):
for j in range(n-i-1):
if A[j] < A[j+1]:
A[j], A[j+1] = A[j+1], A[j]
print("Lần", i+1, ":", A)
print("Kết quả cuối:", A)