ĐỀ 001

CÂU 1:
a)Trình bài tư tưởng của giải thuật tìm kím nhị phân
Tính chất chính của giải thuật tìm kiếm nhị phân là khả năng loại bỏ một nửa danh sách ở
mỗi bước, do đó, thời gian thực hiện giảm một cách đáng kể so với tìm kiếm tuyến tính.
1.Sắp xếp: Trước hết, danh sách phải được sắp xếp. Điều này là quan trọng để có thể áp dụng
phương pháp chia để trị trong giải thuật nhị phân.
2.Phần tử trung tâm: Chọn phần tử giữa của danh sách làm điểm trung tâm. Điều này thường
làm bằng cách chia độ dài của danh sách cho 2.
3.So sánh: So sánh phần tử trung tâm với phần tử cần tìm kiếm:
Nếu bằng, ta đã tìm thấy.
Nếu nhỏ hơn, ta tìm kiếm ở nửa bên phải của danh sách trung tâm.
Nếu lớn hơn, ta tìm kiếm ở nửa bên trái của danh sách trung tâm.
4.Lặp lại: Lặp lại quá trình trên cho nửa danh sách được chọn cho đến khi tìm thấy phần tử
hoặc danh sách thu hẹp đến mức không thể nữa.
5.Hiệu suất: Thời gian thực hiện giảm độc đáo theo logarit cơ số 2 của số lượng phần tử trong
danh sách, làm cho giải thuật này hiệu quả, đặc biệt là với danh sách lớn.
6.Độ phức tạp: Độ phức tạp thời gian của giải thuật tìm kiếm nhị phân là O(log n), trong đó n
là số lượng phần tử trong danh sách.
Thông qua quá trình này, giải thuật tìm kiếm nhị phân giúp nhanh chóng xác định xem một
phần tử có tồn tại trong danh sách hay không.
b)
1) Thuật toán tìm kiếm nhị phân x=57, x=22
9 13 29 48 57 57 66 81
0 1 2 3 4 5 6 7
 X=57

Lần Đầu Cuối Điều kiện Giữa Kết quả trả về vị trí X
lặp (left) (right) Đầu<= cuối
thứ
1 0 7 True 0+(7-0)/2=3
2 4 7 True 4+(7-4)/2=5 5
Kết luận: tìm thấy x=57 tại vị trí 5 của mảng A, thuật toán dừng.
X=22

Lần Đầu Cuối Điều kiện Giữa Kết quả trả về vị trí X
lặp (left) (right) Đầu<= cuối
thứ
1 0 7 True 0+(7-0)/2=3
2 0 2 True 0+(2-0)/2=1
3 2 2 True 2+(2-2)/2=2
4 2 1 False Kết thúc vòng lặp -1
Kết luận: không tìm thấy x=22 trong mảng A, thuật toán dừng.

CÂU 2:
a) Viết khai báo cấu trúc ngăn xếp (stack) và các thao tác (hàm) cơ bản của ngăn xếp (Stack)
bằng ngôn ngữ java
public class Stack {
private int maxSize;
private int top;
private int[] stackArray;

// Constructor
public Stack(int size) {
 maxSize = size;
stackArray = new int[maxSize];
top = -1; // Ngăn xếp rỗng khi top = -1
}

// Phương thức đẩy phần tử vào ngăn xếp

public void push(int value) {
if (top < maxSize - 1) {
stackArray[++top] = value;
System.out.println("Đã đẩy " + value + " vào ngăn xếp");
} else {
System.out.println("Ngăn xếp đầy. Không thể đẩy thêm phần tử.");
}
}

// Phương thức lấy phần tử từ đỉnh ngăn xếp

public int pop() {
if (top >= 0) {
int value = stackArray[top--];
System.out.println("Đã lấy " + value + " từ ngăn xếp");
return value;
} else {
System.out.println("Ngăn xếp trống. Không thể lấy phần tử.");
return -1; // Giá trị đặc biệt để chỉ ra ngăn xếp trống
}
}

// Phương thức kiểm tra xem ngăn xếp có rỗng hay không
public boolean isEmpty() {
return top == -1;
}

// Phương thức kiểm tra xem ngăn xếp có đầy hay không
public boolean isFull() {
return top == maxSize - 1;
}

// Phương thức lấy giá trị ở đỉnh ngăn xếp mà không loại bỏ nó
public int peek() {
if (top >= 0) {
return stackArray[top];
} else {
System.out.println("Ngăn xếp trống. Không có giá trị để xem.");
return -1; // Giá trị đặc biệt để chỉ ra ngăn xếp trống
}
}

public static void main(String[] args) {

// Ví dụ sử dụng ngăn xếp
Stack stack = new Stack(5);

stack.push(10);
stack.push(20);
stack.push(30);

System.out.println("Đỉnh ngăn xếp: " + stack.peek());

stack.pop();
stack.pop();
 System.out.println("Ngăn xếp rỗng: " + stack.isEmpty());
System.out.println("Ngăn xếp đầy: " + stack.isFull());
}
}

Trong ví dụ trên, chúng ta có cấu trúc Stack với các thao tác cơ bản như push, pop, isEmpty,
isFull, và peek. Hàm main thực hiện một số thao tác cơ bản để minh họa cách sử dụng ngăn
xếp.
b) Viết phương thức cho nhập số n nguyên dương, tách số n rồi lưu các chữ của n vào stack
và tính tổng các chữ số lẻ rồi xuất tổng ra màn hình bằng ngôn ngữ java
import java.util.Scanner;
import java.util.Stack;

public class DigitSumExample {

// Phương thức để nhập số nguyên dương và tính tổng các chữ số lẻ

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Nhập số nguyên dương n: ");

int n = scanner.nextInt();

// Tạo một ngăn xếp để lưu các chữ số của n

Stack<Integer> digitStack = new Stack<>();

// Tách và lưu các chữ số của n vào ngăn xếp

while (n > 0) {
int digit = n % 10;
digitStack.push(digit);
n /= 10;
}
 // Tính tổng các chữ số lẻ từ ngăn xếp
int oddDigitSum = 0;
while (!digitStack.isEmpty()) {
int digit = digitStack.pop();
if (digit % 2 != 0) {
oddDigitSum += digit;
}
}

// Xuất tổng các chữ số lẻ ra màn hình

System.out.println("Tổng các chữ số lẻ là: " + oddDigitSum);
}
}

Trong ví dụ này, chúng ta sử dụng một Stack<Integer> để lưu trữ các chữ số của số nguyên
dương n. Sau đó, chúng ta duyệt qua ngăn xếp để tính tổng các chữ số lẻ và xuất kết quả ra
màn hình.
CÂU 3: