KHÓA 1: TỔNG QUAN

-----------------------------------------------------------
*** B1: Xây dựng tư duy lập trình

- Monkey Coding
+ Không có kỹ năng tư duy: nhìn thì code theo được nhưng tự code ko nổi
+ Không phân tích nghiệp vụ
+ Code máy móc: không sáng tạo đc vì ko biết cấu trúc dl, giải thuật
+ Chỉ biết ngôn ngữ lập trình

- Phân tích, chia nhỏ vấn đề, mô hình ba khối

+ Phân tích, chia nhỏ vấn đề - divide and conquer: chia bài toán ra
thành những bài toán nhỏ => tổng hợp các bài toán nhỏ -> thành các bài
toán lớn
+ Mô hình 3 khối: Đầu vào, đầu ra, cách giải thuật

- Các kiến thức nền tảng

+ Biến (Variables)
+ Kiểu dữ liệu (Data types)
+ Lệnh gán (Assignment)

+ Lệnh điều kiện (Conditions): if, if...else.., switch...case

+ Vòng lặp (Loop): for, while, do...while

+ Hàm (Function)

+ Collections:
Mảng (Arrays)
Danh sách (List)

- Cấu trúc dữ liệu: lưu trữ, tổ chức dữ liệu sao cho hiệu quả
Một số cấu trúc dữ liệu phổ biến:
+ Mảng (Array, ArrayList)
+ Danh sách liên kết (LinkedList)
+ Hàng đợi (Queue)
+ Ngăn xếp (Stack)
+ Bảng băm (Hastable)
+ Cây (Tree)

- Thuật toán/ Thuật giải nền tảng và chuyên sâu

-- Thuật toán/ thuật giải nền tảng:
+ Kỹ thuật tích lũy tổng, tích
+ Kỹ thuật cờ hiệu
+ Kỹ thuật tìm lớn nhất, nhỏ nhất
+ Kỹ thuật đếm
+ Xử lý mảng, mảng con
+ Kỹ thuật lính canh
+ Xử lý chuỗi
-- Thuật toán/ thuật giải nâng cao:
+ Các thuật toán sắp xếp
+ Các thuật toán tìm kiếm
+ Thuật toán trên cây
+ Thuật toán trên bảng băm

- Suy nghĩ như một tester, test case

- Code và practice, patience, curious
- Gỡ lỗi (Debugger)
 - Đọc sách/blog/code của người khác(kinh nghiệm, kỹ thuật tổ chức, code)

-----------------------------------------------------------
*** B2: IDE

- IDE là gì?
+ Dùng để code
+ Giúp biên dịch (build $ compile) và thực thi (run) code
+ Giúp debug
+ Hỗ trợ auto complete: đề xuất từ khóa, câu lệnh điều khiển, hàm, lớp...
+ Syntax Highlighter: tô màu tên hàm, lớp,...
- Một số IDE thông dụng
- Các chức năng chính trên IDE
- Phím tắt của IDE: hotkeys
- Chế độ code tự động (Intelligent code completion)

-----------------------------------------------------------
*** B3: Tư duy máy tính, thuật toán, thuật giải

- Tư duy máy tính

+ Chia nhỏ các bước thực hiện, rồi thực hiện tuần tự step by step

- Mã giả/ Thuật giải/ Thuật toán

+ Thuật toán: Là tập hợp số bước hữu hạn, cố định và chỉ có đúng cách này
để có kết quả
+ Thuật giải: Số bước có thể thay đổi, có thể cách này hoặc cách khác để
có kết quả
+ Mã giả/ PseudoCode:
. Là bản phác thảo code, minh họa các bước thực hiện của thuật toán,
chương trình
. Sử dụng từ ngữ tự nhiên kết hợp ngôn ngữ lập trình
=> Giúp tổng quát được các bước cần làm, 1 cách chi tiết rõ ràng
=> Khi nhận nghiệp vụ, nên vẽ ra các bước cần làm, dùng thuật toán nào
hàm nào => Đó là pseudocode - mã giả

- Cách mã nguồn hoạt động

B1: Xây dựng các bước cần thực hiện - psedocode
B2: Chuyển pseudocode sang ngôn ngữ lập trình
B3: Compile code và chạy code để thấy kết quả

-----------------------------------------------------------
*** B4: Chương trình HelloWorld Java

- Lập trình là gì?

Là biến những hệ thống, nghiệp vụ thực tế thành những hệ thống, ứng dụng
cntt

- Hàm main?
+ Là entry point, điểm đầu vào của chương trình. Khi một ch tr khởi chạy,
nó sẽ tìm đến hàm main và xử lý các lệnh ở bên trong hàm đó. Nếu không có
hàm main, ch tr sẽ ko chạy được.

- Cấu trúc của 1 chương trình:

+ Đầu vào: các biến, hàm
+ Xử lý: code nghiệp vụ
+ Đầu ra: in ra console, trả về dữ liệu,...

- Một số ký tự in ra console:
+ \t: khoảng tab
 + \n: xuống dòng
+ \": in dấu "
+ \': in dấu '
+ \\: backslash, in dấu \

-------------------------------------------------------------------------------
*** KHÓA 2: MẢNG - CHUỖI

* Giới thiệu mảng

Tại sao lại có mảng?
Khi tạo 1,2 biến thì ok, nhưng khi số lượng lên đến hàng chục, trăm...
-> ko lẽ lại khai báo mấy chục mấy trăm biến => mảng
Khởi tạo và cấp phát vùng nhớ cho mảng:
int[] arrName = new arrName[5];
=> khởi tạo 1 mảng có tên arrName và cấp phát 5 vùng nhớ tương đương
với 5 giá trị của mảng
Có vài cách khởi tạo mảng:
int[] arrName = new int[quantity];
int[] arrName = {values...};
int[] arrName = new int[] {
values...
};

Tên mảng là địa chỉ ô nhớ của phần tử đầu tiên của mảng, cũng là địa chỉ
của mảng

* Mảng 1 chiều
Xuất mảng 1 chiều dùng for...each:
for (kieu_du_lieu tenBien : tenMang) {
// code
};

* Mảng 2 chiều

* Hàm và mảng

-------------------------------------------------------------------------------
*** KHÓA 4: NỀN TẢNG LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG

-----------------------------------------------------------
B1: Giới thiệu OOP
- Class là tập hợp các đối tượng có chung các thuộc tính và phương thức
- UML - Unified Modeling Language - Sơ đồ lớp: mô hình hóa các lớp đối tượng
cần có, bao gồm các thuộc tính nào, phương thức nào từ nghiệp vụ nhận được.

-----------------------------------------------------------
B2: Instance
- Là thể hiện của lớp đối tượng, hay là một đối tượng cụ thể của 1 lớp
- VD:
NhanVien nhanVien1 = new NhanVien ();
Trong đó:
NhanVien: class
nhanVien1: tên instance(đối tượng)
new: từ khóa tạo mới đối tượng, cấp phát vùng nhớ cho đối tượng đó
NhanVien(): hàm khởi tạo của class NhanVien

-----------------------------------------------------------
B3,4: next
-----------------------------------------------------------
B5: Tính đóng gói - Encapsulation
- Kiểm soát được việc cho bên ngoài thấy hay không thấy (không truy cập, sửa
đổi được)
- Tạo ra cơ chế ngăn ngừa việc gọi phương thức của lớp này tác động hay truy
xuất dữ liệu của lớp khác
- Không quan tâm bên trong code gì, chỉ cho bên ngoài dùng cái cần thiết
- Thay đổi code bên trong lớp đó mà ko ảnh hưởng đến lớp khác
- Bảo trì và nâng cấp mà không đụng đến các lớp khác
- Ngăn ngừa việc gán các giá trị KHÔNG HỢP LỆ vào các thuộc tính của đối tg

-> Có thể control điều này qua accessor modifier: public, private, protected,
internal,
và accessor method: get, set
-> muốn cho bên ngoài dùng thì get
-> muốn cho bên ngoài sửa thì dùng set

-----------------------------------------------------------
B6: ArrayList & LinkedList (thuộc Collections)
- Tại sao lại phải dùng những kiểu này mà ko dùng array?
=> array sau khi khởi tạo -> không thay đổi được kích thước, nghĩa là không
thêm hay xóa được phần tử trong arr.
=> Phải dùng thêm ArrayList & LinkedList

* ArrayList: là list, dựa trên nền tảng của array

* LinkedList: là list, nhưng dựa trên nền tảng của liên kết đôi?

Một số phương thức thường dùng trong ArrayList và LinkedList (java):

+ add
+ remove
+ get
+ duyệt for: nếu list mà ko có phần tử(null)-> list.size()->throw exception
+ for each: nếu list mà ko có phần tử (null) -> bỏ qua ko chạy

-------------------------------------------------------------------------------
KHÓA 5: LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG CHUYÊN SÂU

-----------------------------------------------------------
*** Abstract Class
- Syntax:
abstract class tên_lớp {
các_thuộc_tính;
các_phương_thức;
}
- Khác lớp thường ở chỗ nào?
+ Lớp trừu tượng là trong lớp đó có ít nhất 1 phương thức trừu tượng
* Không thể tạo Instance (1 thể hiện) của lớp này (mà chỉ các class kế thừa
từ lớp abstract này tạo instance được)
* Phương thức trừu tượng:
+ Không có thân hàm
-> Các lớp kế thừa từ class có pt trừu tượng phải cài đặt cho phương
thức này.
- Tại sao lại có abstract class?
+ Phương thức (là pt abstract) chưa biết sẽ được cài đặt thế nào, chi tiết
cài đặt sẽ nằm ở lớp con (lớp kế thừa)
+ Nếu không có abstract -> lớp con không cài cũng ok ->Nếu người code lớp
cha và lớp con khác nhau -> dễ bị miss code
-> Có abstract sẽ giúp ko bỏ sót việc cài đặt các abstract method này vì
 IDE sẽ thông báo.

-----------------------------------------------------------
*** Interface
- Tại sao lại có Interface?
+ Java và C# KHÔNG có đa kế thừa class (đa kế thừa: 1 lớp có thể kế thừa từ
nhiều lớp khác nhau) mà chỉ có thể kế thừa từ 1 lớp -> phải tạo ra Interface
để 1 lớp có thể implement nhiều Interface (giống như đa kế thừa nhưng không
phải đa kế thừa)
- Định nghĩa về interface:
+ Interface KHÔNG phải class
+ Không có quan hệ cha con (cùng loại, vd class DongVat, class con là Cho
hoặc mèo) với class mà chỉ là quan hệ về chức năng (phương thức, hành động)
v class nghĩa là: interface là tập hợp các phương thức mà nhiều lớp có thể
implement và cài đặt
+ Một class có thể implement nhiều interface
+ Interface ko có thân hàm, việc cài đặt thân hàm là dành cho các lớp
implement interface đó.
+ Interface có thể có cả thuộc tính lẫn phương thức:
++ Các thuộc tính mặc định là static + public + final. Không cần ghi
khi
khai báo, truy xuất như biến static - nghĩa là truy xuất trực tiếp qua
tên Interface
++ Các phương thức mặc định access mod là public và có sẵn static

Note:
1 class cần khai báo các phần:
+ Attributes
+ Get/Set
+ Constructors
+ Input/Output
+ Business Methods

Khi nhận 1 nghiệp vụ/bài toán:

-> Phân tích sơ đồ lớp/class
-> Phân tích kế thừa/abstract class
-> Phân tích quan hệ chức năng/interface
-> Viết code xử lý cho nghiệp vụ đó -> Phân tích chia nhỏ bài
toán -> Step by step

-------------------------------------------------------------------------------
*** ALGORITHM

1. GIỚI THIỆU THUẬT TOÁN VÀ Ý NGHĨA THỰC TIỄN

B1: TỔNG QUAN

- Chương trình chạy nhanh, load mượt -> người dùng thích -> thuật toán phải tối
ưu: nhanh nhất, tối ưu nhất -> cần học thuật toán
- 1 thuật toán cần quan tâm nhưng điều gì?
+ Số lượng người dùng/đầu vào: nhiều, hay ít
+ Giải thuật: nhanh nhất, tốn ít bộ nhớ nhất

B2: Tính chất thuật toán

1. XÁC ĐỊNH
+ Có các bước rõ ràng
+ Có thể thực thi được
2. HỮU HẠN
+ Thuật toán phải kết thúc sau khi thực hiện 1 số hữu hạn các thao tác
 3. ĐÚNG ĐẮN
+ Khi thuật toán kết thúc phải nhận đc ouput cần tìm
4. ĐẦU VÀO - ĐẦU RA
input -> thuật toán -> output
5. TÍNH HIỆU QUẢ
+ Chạy được, đáp ứng yêu cầu
6. TÍNH TỔNG QUÁT
+ Giải quyết được nhiều yêu cầu đầu vào/các trường hợp khác nhau

- CÁCH VIẾT THUẬT TOÁN:

bắt đầu -> step 1 -> step 2 -> step 3->... step n -> kết quả mong đợi

B3: PHƯƠNG PHÁP BIỂU DIỄN THUẬT TOÁN

- Sơ đồ khối
- Pseudo code: mã giả if else

B4: ĐỘ PHỨC TẠP THUẬT TOÁN - BIG O

=> MỤC TIÊU: tính được độ phức tạp thuật toán

- Để lựa chọn 1 thuật toán phù hợp cần phải cân nhắc 2 yếu tố quan trọng:

+ Tốc độ chạy -> tốc độ chạy thì phải phụ thuộc vào nhiều yếu tố:
. Kiến trúc máy tính: 32 bit - 64 bit
. Bộ xử lý: 1 core - đa core
. Cách thực thi, xử lý: tuần tự - song song
. SỐ LƯỢNG INPUT
.Thời gian truy xuất bộ nhớ: đọc - viết - ...

+ Bộ nhớ cần có để chạy được thuật toán đó

B5,6: SỐ PHÉP TOÁN THỰC HIỆN

- Độ phức tạp thuật toán được thể hiện bằng 1 hàm giữa số lượng đầu vào
n với số phép tính mà nó phải thực hiện
- VD:
int n = 1; -> 1 phép tính

// thực hiện 3 lần: i = 1, i = 2, i = 3

while(n <= 3) { -> 1 phép tính
System.out.println(n); -> 1 phép tính
n++; -> 1 phép tính
}
=> Biểu thức thể hiện độ phức tạp thuật toán:
T(n) = 1 + 3n

=> Độ phức tạp thuật toán được biểu diễn bằng 1 hàm thể hiện mối liên hệ
giữa số lượng input đầu vào (ký hiệu là n) với số phép tính mà thuật toán
đó phải thực hiện

B7: ĐỘ PHỨC TẠP THUẬT TOÁN BIG O NOTATION

- Big O loại bỏ các biến số đầu vào có ảnh hưởng nhỏ và giữ lại các biến số
có ảnh hưởng lớn KHI `số lượng đầu vào` tiến tới nhiều vô cùng

- Quy tắc tìm BIG O:

+ Quy tắc hằng: O ( C * f(n) ) = O (f(n)) -> bỏ hệ số
+ Quy tắc cộng: O ( f(n) + g(n) ) = O ( max (f(n), g(n) ) -> lấy độ
phức
tạp lớn hơn giữa f(n) và g(n)
+ Quy tắc nhân: O ( f(n) * g(n) ) = O ( f(n)) * O(g(n) )
 - Các loại độ phức tạp thuật toán:
O(1) -> Độ phức tạp hằng số
O(log(2)n) -> Độ phức tạp log
O(n) -> Độ phức tạp tuyến tính
O(nlog(2)n) -> Độ phức tạp nlog(2)n
O(n^a) -> Độ phức tạp đa thức
O(a^n), a>1 -> Độ phức tạp hàm mũ
O(n!) -> Độ phức tạp giai thừa

-----------------------------------------------------------
3. THUẬT TOÁN TÌM KIẾM
-> Mỗi khi tìm hiểu về thuật toán, phải hiểu cách hoạt động của nó
-> Bất chấp ngôn ngữ là gì, đều có thể tái hiện lại thuật toán đó

B8,9: Tìm kiếm tuyến tính (tuần tự)

-> Duyệt từng phần tử, so sánh với phần tử cần tìm -> kết quả

B10: Tìm kiếm nhị phân

Điều kiện tiên quyết: dãy đã phải được sắp xếp (asc hay desc đều đc)
-> Chia đôi dãy số -> được phần tử a[i] - i là index ở giữa
+ nếu bằng số ở giữa -> trả về luôn
+ nếu lớn hơn số ở giữa -> xét trong khoảng a[i+1] và a[n]
+ nếu nhỏ hơn số ở giữa -> xét trong khoảng a[0] và a[i - 1]

4. LUYỆN TẬP THUẬT TOÁN TÌM KIẾM

5. THUẬT TOÁN SẮP XẾP
6. LUYỆN TẬP THUẬT TOÁN SẮP XẾP