7 in A

A.has(7)

A.contains(7)

A.search(7)

append()

insert()

extend()

pop()

Một chuỗi các phần tử cùng kiểu dữ liệu

Một danh sách chứa các danh sách con

Một bảng với dữ liệu không có cấu trúc

Một danh sách các giá trị ngẫu nhiên

A[1][2]

A[2][3]

A[3][2]

A[0][1]

Một lệnh for đơn

Hai lệnh for lồng nhau

Hàm map()

Lệnh while

sum()

max()

min()

avg()

8

9

10

Lỗi

Dictionary chứa danh sách

List chứa list

Tuple chứa set

Set chứa tuple

list.remove(index)

list.delete(index)

list.clear(index)

list.pop(index)

Sử dụng hàm input() để nhập từng điểm một.

Sử dụng hàm input() để nhập một chuỗi

Sử dụng hàm input() để nhập từng điểm một.

Sử dụng hàm input() để nhập một chuỗi chứa các điểm, sau đó tách chuỗi này thành danh sách.

Sử dụng vòng lặp for để lần lượt nhập từng điểm.

Nhập điểm thông qua một file bên ngoài và đọc dữ liệu từ file.

Sử dụng sum(marks)

Sử dụng vòng lặp for để duyệt qua các phần tử của marks và cộng dồn chúng.

Sử dụng hàm reduce từ thư viện functools.

Sử dụng sum(marks), dùng for để duyệt qua các phần tử của marks và cộng dồn

Sử dụng các hàm min() và max().

Duyệt qua danh sách và so sánh từng điểm với điểm nhỏ nhất và lớn nhất đã biết.

Sắp xếp danh sách và lấy phần tử đầu tiên và cuối cùng.

Dùng thuật toán tìm kiếm nhị phân để tìm điểm thấp nhất và cao nhất.

Mảng một chiều

Mảng hai chiều

Bộ từ điển

Chuỗi

Sử dụng hàm mean() từ thư viện statistics.

Tính tổng các điểm của học sinh đó rồi chia cho số đầu điểm.

Sử dụng vòng lặp để cộng dồn các điểm và chia cho tổng số đầu điểm.

Tính tổng các điểm của học sinh đó rồi chia cho số đầu điểm, Sử dụng vòng lặp để cộng dồn các điểm và chia cho tổng số đầu điểm.

Dùng hàm max() để so sánh điểm trung bình của tất cả học sinh.

Duyệt qua danh sách điểm trung bình và lưu lại

Dùng hàm max() để so sánh điểm trung bình của tất cả học sinh.

Duyệt qua danh sách điểm trung bình và lưu lại chỉ số của học sinh có điểm cao nhất.

Sắp xếp danh sách điểm trung bình theo thứ tự giảm dần.

Tìm học sinh có tên xuất hiện cuối cùng trong danh sách.

Duyệt qua tất cả học sinh để tìm đúng học sinh có số thứ tự đó.

Dùng mảng hai chiều để tìm điểm kiểm tra của học sinh bằng cách truy cập trực tiếp phần tử thứ n trong hàng tương ứng.

In ra tất cả điểm của học sinh đó.

Cả A và B đều đúng.

Dùng hàm marks[n] để truy cập điểm.

Kiểm tra giá trị n có hợp lệ không trước khi truy cập phần tử.

Duyệt toàn bộ mảng để tìm phần tử thứ n.

Tra cứu điểm đầu tiên và cuối cùng để so sánh với n.

Hiển thị thông báo lỗi và yêu cầu nhập lại n.

Lấy phần tử đầu tiên.

Lấy phần tử cuối cùng.

Thêm một đầu điểm mới vào mảng.

Duyệt qua tất cả học sinh để tìm đúng học sinh có số thứ tự đó.

Dùng mảng hai chiều để tìm điểm kiểm tra của học sinh bằng cách truy cập trực tiếp phần tử thứ n trong hàng tương ứng.

In ra tất cả điểm của học sinh đó.

Duyệt qua tất cả học sinh để tìm đúng học sinh có số thứ tự đó, dùng mảng hai chiều để tìm điểm kiểm tra của học sinh bằng cách truy cập trực tiếp phần tử.

4

6

8

7

Khi phần tử cần tìm ở giữa danh sách

Khi phần tử cần tìm ở cuối danh sách

Khi phần tử cần tìm không có trong danh sách

Khi phần tử cần tìm là phần tử đầu tiên

Khi phần tử cần tìm ở giữa danh sách

Khi phần tử cần tìm là phần tử cuối cùng

Khi phần tử cần tìm không có trong danh sách

Khi phần tử cần tìm là phần tử đầu tiên

Tăng dần

Giảm dần

Không cần sắp xếp

Sắp xếp theo bất kỳ thứ tự nào

2

3

4

5

6

10

12

11

Đơn giản hơn trong lập trình

Có thể áp dụng cho mọi danh sách

Tốc độ nhanh hơn khi danh sách đã sắp xếp

Không cần phải sắp xếp danh sách trước khi tìm

3

4

5

6

3

4

5

6

Dữ liệu đã được sắp xếp

Dữ liệu chưa được sắp xếp

Chỉ cho các dãy số

Chỉ cho các dãy chữ cái

Thuật toán vẫn hoạt động bình thường

Phải thay đổi thuật toán để so sánh ngược lại

Không thể áp dụng tìm kiếm nhị phân

Chỉ áp dụng cho dãy số ngắn

Tìm phần tử nhỏ nhất và chuyển nó vào vị trí đầu tiên.

So sánh từng cặp phần tử liền kề và hoán đổi nếu chúng không đúng thứ tự.

Chèn từng phần tử vào đúng vị trí trong một mảng con đã sắp xếp.

Chia mảng thành hai phần và sắp xếp từng phần đệ quy.

0

n-1

n(n−1)/2

n - 2

O(n)

O(n log n)

O(n^2)

O(1)

Phần tử lớn nhất được chuyển về cuối mảng.

Phần tử nhỏ nhất được đưa vào đúng vị trí.

Mỗi phần tử được chèn vào đúng vị trí của nó.

Các phần tử liền kề được hoán đổi để sắp xếp.

O(n)

O(n^2)

O(n log n)

O(1)

Sắp xếp chèn

Sắp xếp chọn

Sắp xếp đếm

Sắp xếp nổi b

O(n)

O(n^2)

O(n \log n)

O(1)

Sắp xếp chèn

Sắp xếp chọn

Sắp xếp đếm

Sắp xếp nổi bọt

Tìm phần tử lớn nhất và đưa nó về đúng vị trí.

Tìm phần tử nhỏ nhất và đưa nó về đúng vị trí.

So sánh và hoán đổi các phần tử liền kề nếu chúng không đúng thứ tự.

Chia mảng thành các phần nhỏ hơn để sắp xếp.

Mảng được sắp xếp ngược lại.

Mảng đã được sắp xếp.

Mảng chứa tất cả các phần tử giống nhau.

Mảng chỉ có hai phần tử.

Nó là thuật toán ổn định, có nghĩa là nó giữ nguyên thứ tự của các phần tử bằng nhau.

Nó là thuật toán tại chỗ, tức là nó sử dụng bộ nhớ phụ không đáng kể.

Nó luôn thực hiện số lượng so sánh giống nhau, bất kể thứ tự của đầu vào.

Độ phức tạp thời gian xấu nhất của nó là O(n^2).

Bằng cách tìm phần tử ở giữa và chèn vào đó.

Bằng cách dịch chuyển các phần tử lớn hơn phần tử hiện tại sang bên phải.

Bằng cách hoán đổi các phần tử liền kề cho đến khi phần tử hiện tại ở đúng vị trí.

Bằng cách chia mảng ra đệ quy.

Thuật toán nổi bọt

Thuật toán sắp xếp chọn

Thuật toán sắp xếp chèn

Thuật toán sắp xếp nhan

Để tìm vị trí chính xác của phần tử mới

Để giảm số lần so sánh

Để giảm số lần trao đổi

Để tìm vị trí chính xác của phần tử mới

Để giảm số lần so sánh

Để giảm số lần trao đổi

Để tăng tốc độ sắp x

Thuật toán sắp xếp chèn

Thuật toán sắp xếp chọn

Thuật toán nổi bọt

Thuật toán sắp xếp nhan

soluong_ds.append(int(line))

soluong_ds = [int(line)]

soluong_ds.insert(line)

soluong_ds.remove(line)

Lưu giá trị nhỏ nhất của dãy

Lưu chỉ số của phần tử có giá trị lớn nhất trong dãy

Lưu chỉ số của phần tử có giá trị nhỏ nhất trong dãy

Xác định chỉ số cuối của dãy

Thực hiện sắp xếp nổi bọt danh sách

Sắp xếp danh sách theo thứ tự tăng dần

Sắp xếp danh sách theo thứ tự giảm dần

Đọc dữ liệu từ tệp và in danh sác

Khi số lượng phần tử trong danh sách rất lớn

Khi cần sắp xếp một danh sách ngẫu nhiên có số lượng nhỏ hoặc trung bình

Khi không yêu cầu hiệu suất cao

Khi danh sách đã được sắp xếp hoàn toàn

Tìm phần tử nhỏ nhất và đưa về đầu danh sách

Tìm phần tử lớn nhất và đưa về cuối danh sách

Tìm phần tử lớn nhất và đưa về đầu danh sách

Không cần thực hiện sắp xếp

print('Danh sách điểm theo thứ tự tăng dần là:')

print('Danh sách điểm theo thứ tự giảm dần là:')

print('Danh sách điểm trung bình là:')

print('Danh sách điểm đã sắp xếp:')

Luôn tìm phần tử lớn nhất và đưa về đầu danh sách

Thực hiện dịch chuyển phần tử lớn hơn sang phải để tạo khoảng trống cho phần tử chèn vào

Thực hiện hoán đổi phần tử ở vị trí đầu và cuối

Thực hiện sắp xếp dãy theo thứ tự ngẫu nhiên

Phương pháp làm giảm số lượng mã lệnh trong chương trình

Phương pháp chi tiết hóa các bước từ ý tưởng tổng quan đến từng hành động cụ thể

Phương pháp kiểm tra lỗi sau khi viết xong chương trình

Phương pháp tổ chức dữ liệu theo thứ tự tăng dần

Xác định đầu vào và đầu ra của bài toán

Viết toàn bộ chương trình

Kiểm tra lỗi

Thực hiện từng thao tác cụ thể

Tạo biến mới để lưu giá trị cần chèn

Duyệt từ phần tử thứ hai đến phần tử cuối của dãy

Sắp xếp các phần tử theo thứ tự giảm dần

Tạo danh sách mới từ danh sách cũ

So sánh A[i] với tất cả phần tử trong dãy

So sánh A[i] với các phần tử bên phải của nó

Chuyển các phần tử lớn hơn A[i] sang phải

Chèn A[i] vào vị trí đầu tiên của dãy

Dãy đã hoàn toàn sắp xếp

Các phần tử từ A[0] đến A[i] đã được sắp xếp

Các phần tử từ A[i] đến A[n-1] đã được sắp xếp

Chỉ phần tử A[i] được sắp xếp

A[i] < A[j]

i > j

A[i] > A[j] và i < j

A[i] = A[j]

value = A[i]

value = A[j+1]

A[i] = value

A[j+1] = value

Tăng tốc độ chạy chương trình

Giảm dung lượng bộ nhớ chương trình

Làm rõ từng bước của chương trình, dễ dàng chuyển ý tưởng thành câu lệnh

Tự động phát hiện lỗi cú pháp

Để tiết kiệm thời gian và tránh lặp lại các cặp đã kiểm tra

Vì chỉ số j phải lớn hơn chỉ số i

Để kiểm tra mọi phần tử trong dãy

Vì cặp (i, j) không quan trọng

Một chương trình hoàn chỉnh với các bước chi tiết

Một thuật toán tổng quan mà không có mã lệnh cụ thể

Chỉ là một ý tưởng thiết kế ban đầu

Một báo cáo về quá trình thiết kế

a = [4,5,6] và b = [4,5,6]

a = [4,5,6] và b = [1,2,3]

a = [1,2,3] và b = [4,5,6]

a = [1,2,3] và b = [1,2,3]

a = [4,5,6] và b = [4,5,6]

a = [4,5,6] và b = [1,2,3]

a = [1,2,3] và b = [4,5,6]

a = [1,2,3] và b = [1,2,3]

b = [3,4,6,2,7]

b = [3]

b = [3,4]

b = []

b = [6]

b = [6,2]

b = [2]

b = []

b = [3,4,6,2,7]

b = [3]

b = [7]

b = []

a[i] được chèn vào trước a[0].

a[i] được chèn vào chính giữa dãy con a[0]...a[i-1].

a[i] được chèn vào ngay sau a[j] với a[j] vừa nhỏ hơn hoặc bằng a[i].

a[i] được chèn vào vị trí bất kì trong dãy con a[0]...a[i]

if a[j] > a[j+1]: a[j],a[j+1] = a[j+1],a[j]

if a[j] < a[j+1]: a[j] = a[j+1]

if a[j] > a[j+1]: a[j],a[j-1] = a[j-1],a[j]

if a[j] < a[j+1]: a[j],a[j-1] = a[j-1],a[j]

a= [1,4,6,3,2,9,7,5]

a = [1,2,6,3,4,9,7,5]

a= [1,3,4,6,2,9,7,5]

a = [1,2,2,3,6,9,7,5]

a = [1,4,6,3,2,9,7,5]

a = [1,2,3,6,4,9,7,5]

a= [1,2,3,4,6,9,7,5]

a = [1,2,3,4,5,6,7,9]

a = [1,2,3,4,5,6,7,9]

a = [1,2,3,4,5,7,6,9]

a = [1,2,3,4,6,9,7,5]

a = [1,4,3,2,6,7,5,9]

1

2

3

4

1

2

3

4

1

2

3

4

Mảng a có ít phần tử.

Mảng a có thứ tự tăng dần (không giảm).

Mảng a có thứ tự giảm dần (không tăng).

Mảng a có thứ tự bất kì.

Mảng a có nhiều phần tử.

Mảng a có thứ tự tăng dần (không giảm).

Mảng a có thứ tự giảm dần (không tăng).

Mảng a có thứ tự bất kì.