HƯỚNG DẪN LẬP TRÌNH C

Chia sẻ: Trần Quốc Tuấn Anh | Ngày: | Loại File: DOCX | Số trang:43

Thêm vào BST

Báo xấu

283
lượt xem 96
download

Download Vui lòng tải xuống để xem tài liệu đầy đủ

C++ dựa trên ngôn ngữ lập trình C. C được phát minh trước 1970 bởi Dennis Ritchie, là ngôn ngữ cài đặt hệ thống cho hệ điều hành Unix. C++ được phát minh bởi Bijarne Stroustroup, bắt đầu năm 1979. Các chuẩn ngôn ngữ C++ hiện tại được điều khiển bởi ANSI và ISO

Chủ đề:

Bình luận(0) Đăng nhập để gửi bình luận!

Lưu

Nội dung Text: HƯỚNG DẪN LẬP TRÌNH C

HƯỚNG DẪN LẬP TRÌNH C Mục Lục Trang CHƯƠNG 1: Cơ bản Lập Trình C 1. Lịch Sử Của C++.................................................................................................................................................................................................2 2. 1 chương trình C .................................................................................................................................................................................................2 3. Các kiểu dữ liệu...................................................................................................................................................................................................2 4. Khai báo Biến......................................................................................................................................................................................................2 5. BiỂU THỨC (EXPRESSION) ............................................................................................................................................................................3 6. Khai báo mảng của các kiểu dữ liệu ................................................................................................................................................................3 7. Nhập xuất cơ bản................................................................................................................................................................................................3 8. Hàm Con..............................................................................................................................................................................................................4 9. Lệnh điều kiện if .. else if .. else...................................................................................................................................................................4 10. Lệnh switch( )......................................................................................................................................................................................................5 11. Lệnh vòng lặp while(điều kiện lặp)....................................................................................................................................................................5 12. Lệnh vòng lặp do{} while()..................................................................................................................................................................................5 13. Lệnh vòng lặp for................................................................................................................................................................................................5 14. Xử lý Hàm.............................................................................................................................................................................................................6 CHƯƠNG 2: Mảng 1 chiều 1. Định nghĩa............................................................................................................................................................................................................7 2. Truyền mảng vào hàm........................................................................................................................................................................................7 3. Kĩ thuật tìm ..........................................................................................................................................................................................................7 4. Kỹ thuật đặt lính canh.........................................................................................................................................................................................7 5. Kĩ thuật liệt kê vị trí.............................................................................................................................................................................................8 6. Kĩ thuật tính tổng.................................................................................................................................................................................................8 7. Kĩ thuật đếm........................................................................................................................................................................................................8 8. Kĩ thuật thêm.......................................................................................................................................................................................................8 9. Kĩ thuật xoá..........................................................................................................................................................................................................8 10. Một số bài tập minh hoạ.....................................................................................................................................................................................9 CHƯƠNG 3: Ma trận – Con trỏ 1. Ma trận.................................................................................................................................................................................................................12 2. Con Trỏ................................................................................................................................................................................................................. 12 3. Một số bài tập minh hoạ.....................................................................................................................................................................................13 CHƯƠNG 4: Trừu tượng hoá dữ liệu 1. Định nghĩa............................................................................................................................................................................................................15 2. Nhập – Xuất.........................................................................................................................................................................................................15 3. Các bài tập minh hoạ..........................................................................................................................................................................................15 CHƯƠNG 5: Đệ Quy – Độ phức tạp của thuật toán (tham khảo) 1. Đệ quy..................................................................................................................................................................................................................18 2. Độ phức tạp thuật toán.......................................................................................................................................................................................19 CHƯƠNG 6: Tìm kíêm 1. Tìm kíêm tuyến tính............................................................................................................................................................................................20 2. Tìm kiếm nhị phân...............................................................................................................................................................................................20 CHƯƠNG 7: Sắp Xếp Mảng 1. Sắp xếp tuần tự (InterchangeSort)....................................................................................................................................................................21 2. Sắp xếp chèn (InsertionSort).............................................................................................................................................................................21 3. Sắp xếp chọn (SelectionSort)............................................................................................................................................................................21 4. Sắp xếp nổi bọt (BubbleSort).............................................................................................................................................................................22 5. Một số bài tập minh hoạ.....................................................................................................................................................................................22 6. Sắp xếp ma trận tăng dần..................................................................................................................................................................................23 CHƯƠNG 8: Danh sách Liên Kết 1. Danh sách liên kết đơn ......................................................................................................................................................................................24 2. Danh sách liên kết kép (tham khảo)................................................................................................................................................................25 3. Bài tập minh hoạ.................................................................................................................................................................................................26
CHƯƠNG 9: STACK & QUEUE (tham khảo) 1. STACK (Ngăn Xếp) ............................................................................................................................................................................................27 2. Queue (Hàng Đợi) ..............................................................................................................................................................................................27 CHƯƠNG 10: CÂY 1. Cấu trúc Cây........................................................................................................................................................................................................28 2. Cây nhị phân........................................................................................................................................................................................................28 3. Cây Nhị Phân Tìm Kiếm.....................................................................................................................................................................................30 CHƯƠNG 11: Chuyển qua lại các Dạng Cấu Trúc CHƯƠNG 1: Cơ bản Lập Trình C 1. Lịch Sử Của C++ • C++ dựa trên ngôn ngữ lập trình C. C được phát minh trước 1970 b ởi Dennis Ritchie, là n gôn ngữ cài đặt hệ thống cho hệ điều hành Unix. • C++ được phát minh bởi Bijarne Stroustroup, bắt đầu năm 1979. • Các chuẩn ngôn ngữ C++ hiện tại được điều khiển bởi ANSI và ISO 2. CHƯƠNG trình C gồm 3 phần chính: a) Khai báo thư viện, định nghĩa (define) các bíên ko đổi b) Khai báo các hàm con c) Khai báo void main() #include #include #define swap(a,b){ int t = a; a = b; b = t; } #define MAX 50 void nhap(int a[], int &n){ … } void xuat(int a[], int n){ … } void main(){ clrscr(); int a[MAX], n; getch(); } 3. Các kiểu dữ liệu: Có 2 loại: • Kiểu thông thường, sẵn có trg C: o int : số nguyên _ dung lượng 2byte _ VD: -7, -2, 0, 3, 5, 15, 200, … o long : số nguyên dài _ dung lượng 4byte _ VD: 0951020158, 1234567890 o float : số thực _ dung lượng 4byte _ VD: -5.6, -8.0, -1, 0, 15.3, … o char : kí tự _ dung lượng 1byte _ VD: a, b, c, +, -,…. o char* : chuỗi kí tự _ dung lượng n _ VD: dsdsds, Tran Anh Minh, … (n là độ dài chuỗi) o char[n] : chuỗi kí tự _ dung lượng n (nhưng ko thể thay đổi n, khác với char* có thể thay đ ổi ) • Kiểu mới, do ng` dùng định nghĩa (sử dụng struct): o sv : kiểu sinh viên _ gồm hoten(kiểu char[30] ), MaSV( kiểu long ), tb( kiểu float ) o nv : kiểu nhân viên _ gồm hoten(kiểu char[30] ), MaNV( kiểu long ), luong( kiểu float ) • Lưu ý : Các kiểu mới tuỳ theo đề bài sẽ có thay đổi (VD MaSV là kiểu char[5]), 2 kiểu trên là thường đc sử dụng. 4. Khai báo Biến: • Khai báo rồi mới khởi tạo biến. VD: int a; a = 5; • Vừa khai báo, vừa khởi tạo biến.VD: int a = 5; • Biến mặt nạ: &”tên biến” = “biến” : chỉ là 1 tên gọi khác của bi ến kia, t ức nếu có x ử lý trên bi ến m ặt n ạ thì bi ến kia cũng bị thay đổi y như vậy, do đó cũng chỉ là 1 tên khác VD: Khai báo như vậy có nghĩa: int a = 5; - ta khai báo 1 biến số nguyên a, gán cho a = 5. int &b = a; - Sau đó ta đặt 1 tên khác cho a, là b. a++; - khi lệnh a++ đc thực hiện thì a = b = 6. b++; - Và khi b++ đc thực hiện thì a = b = 7. printf(“%d”,a); - Khi printf a và b đều cho ra kết quả là 7 printf(“%d”,b); - Nếu xuất ra địa chỉ của a và b thì ta sẽ thấy chúng cùng địa ch ỉ, b ch ỉ là 1 tên khác
của a • Biến đồng cấp: “biến 1” = “bíên 2”: bíên 1 sẽ là 1 biến độc lập so với bi ến 2, khác địa ch ỉ c ủa bi ến 2, có giá trị giống biến 2. Những gì xảy ra cho “biến 1” ko ảnh hưởng gì “biến 2” VD: int a = 5; Khi xuất ra màn hình ta sẽ có: int b = a; a = 10 a = a + 5; b=7 b = b + 2; Nếu xem địa chỉ thì sẽ thấy địa chỉ 2 biến sẽ khác nhau printf(“a = %d\n”,a); printf(“b = %d”,b); 5. BiỂU THỨC (EXPRESSION) 6. Khai báo mảng của các kiểu dữ liệu (mảng là 1 tập hợp các ptử cùng kiểu dữ liệu): • MAX là do ng` dùng định nghĩa bằng cách : #define MAX 100 // có th ể là 100 ho ặc 1 s ố khác • Khai báo 1 mảng số nguyên: int a[MAX]; • Khai báo 1 mảng số nguyên dài: long a[MAX]; • Khai báo 1 mảng số thực: float a[MAX]; • Khai báo 1 mảng kí tự: char a[MAX]; => Mảng kí tự chính là 1 chuỗi cố định • Khai báo 1 mảng sv: sv a[MAX]; 7. Nhập xuất cơ bản: • Nhập: scanf(“ … ”, &… ); và gets(…); o int : scanf(“%d”, &a); o long : scanf(“%ld”, &a); o float : scanf(“%f”, &a); o char : scanf(“%c”, &a); o char* : gets(a); // Lưu ý: trước dòng gets(a); phải có flushall(); o char[n] : gets(a); // Lưu ý: trước dòng gets(a); phải có flushall(); • Xuất : printf(“ %.. ”, … ); hoặc printf(“ 1 câu văn ”); ho ặc printf(“ 1 câu văn %.. ”, …); o int : printf(“%d”, a); o long : printf(“%ld”, a); o float : printf(“%f”, a); o char : printf(“%c”, a); o char* : printf(“%s”, a); o char[n] : printf(“%s”, a); #include #include void main(){ clrsrcr(); int n; char* s; printf(“ Moi nhap so nguyen n “); scanf(“%d”,&n); printf(“Moi nhap 1 chuoi”); flushall(); gets(s); printf(“So nguyen vua nhap la : %d,” n);
printf(“Chuoi vua nhap la : %s”,s); getch(); }
8. Hàm Con: có thể chuyển VD trên thành 1 CT có 2 hàm con, đó là hàm nhập & xuất Dòng #include #include Khi ta sửa đổi 1 biến (nhập, tăng thêm, gi ảm đi, xoá …) thì void nhap(int &n, char* &s){ khi truyền vào hàm con, ta phải thêm & 1 printf(“ Moi nhap so nguyen n “); scanf(“%d”,&n); Khi xuất ra hay ko thay đổi ảnh hưởng tới biến thì ko cần & printf(“Moi nhap 1 chuoi”); flushall(); Lưu ý: thay đổi trên mảng thì ko cần & 2 gets(s); VD: } void nhap(int a[], int &n) { void xuat(int n, char *s){ … printf(“So nguyen vua nhap la : %d,” n); } 3 printf(“Chuoi vua nhap la : %s”,s); } Tham số truyền vào hàm trong void main() ko nh ất thíet ph ải void main(){ trùng tên với trong hàm con (dòng 3 và dòng 18), VD hàm clrscr(); nhập ta có thể sửa lại như sau và vẫn đúg: 4 int n; void nhap(int &a, char* &b){ char* s; printf(“ Moi nhap so nguyen n “); nhap(n,s); scanf(“%d”,&a); 5 xuat(n,s); printf(“Moi nhap 1 chuoi”); getch(); flushall(); } gets(b); } 6 7 8 9 10 11 12 13 14 15 16
17 18 19 20 9. Lệnh điều kiện if .. else if .. else: Chỉ 1 điều kiện Chỉ 2 điều kiện Hơn 2 đk Cấu trúc if( điều kiện ) if( điều kiện ) if( điều kiện ) ; ; ; else else if( điều kiện ) ; ; ……………….. else if( điều kiện ) ; else ; VD if( a > b) if( dem == 0 ) if( tb > 9) printf(“%d”,a); printf(“Ko co ptu ”); printf(“Xuat sac”); else else if( tb > 8 ) printf(“Co ptu”); printf(“Gioi”); ……………….. else if( tb > 7 ) printf(“Kha”); else printf(“loại”); Nhận xét Dùng cho các điều kiện chỉ Câu lệnh sẽ xét từ trên xuống, nếu đúg đk trog if có 2 giả thuyết. VD: thì xử lý và thoát ra, nếu ko sẻ đi tới cuối và x ử lý đúng/sai, khác hoặc bằng, của else cuối sẽ đc thực hiện >= hoặc < , tồn tại hay ko VD: tb = 8 thì sẽ bỏ qua 2 if đầu và xuất ra “Khá” tồn tại… VD: tb = 2 thì sẽ bỏ qua 3 if đầu và xuất ra “Loại”. • Nếu có nhiều hơn 2 xử lý thì các xử lý nằm trong {…}. VD: if( a > b) { printf(“ %d ”, b); return; } • Nếu ko có {…} thì lệnh xử lý gần if nhất là của if, các lệnh còn l ại thì ko ph ải. VD: if( a > b) printf(“ %d ”, b); printf(“%d”,a); • Nếu có nhiều hơn 2 giả thuyết (phần nằm trong if ) thì các gi ả thuyết liên k ết b ởi “&&” ho ặc “||” tuỳ TH. VD: if( a > b && b > 0 ) Chỉ thực hiện “xử lý” xuất ra a khi a dương và lớn hơn b printf(“%d”,a); ( do a > b > 0 ) if( x == 1 || x == 2 ) Chỉ thực hiện “xử lý” xuất ra “Thoả” khi x = 1 hoặc x = 2 printf(“Thoả ”); 10. Lệnh switch( ) : • Cấu trúc: switch(“biến”) { • “biến” có thể trong 3 kiểu dữ liệu: int / long / char case “giá trị” : “xử lý”; • Hàm switch đc dùng thay cho if.. else if .. else khi s ố if else l ớn, break; khó nhìn. Nhưng cũng có mặt hạn chế là ko dùng cho float / chu ỗi, …….. và ko so sánh đc.
case “giá trị” : • Khi “biến” có giá trị = với “giá trị” ở case thì các lệnh xử lý ở case “xử lý”; đó sẽ đc thực thi đến khi gặp lệnh break break; } VD: VD: switch(thang) // thang la bien kieu int switch(c) // c la bien kieu char { { case 1 : case ‘a’ : printf(“Thang 1”); printf(“a”); break; break; …….. …….. case “12” : case “z” : printf(“Thang 12”); printf(“z”); break; break; } } 11. Lệnh vòng lặp while(điều kiện lặp): Đkiện lặp sẽ xét trước khi thực hiện các “xử lý” sau nó. V while( a > b ) { while( a > b ) while( a > b && a > 0) D a--; a--; a--; b++; b++; b++; } Nếu có {..} thì các lệnh trg dấu Nếu ko có {..} thì lệnh gần while nhất sẽ Liên kết 2 đk lặp cũng giống như ngoặc đều thuộc vòng lặp, sẽ đc thuộc vòng lặp & sẽ đc thực hiện đến if() thực hiện đến khi nào đk lặp sai khi nào đk lặp sai (tức a 0 ); Nếu có {..} thì các lệnh trg dấu ngoặc đều thuộc vòng l ặp, Liên kết 2 đk lặp cũng giống như if() sẽ đc thực hiện đến khi nào đk lặp sai (tức a thực thi các xử lý vòng for -> xử lý trog biểu thức 3 h) Biểu thức 1 & 3 ko có cũng đc, nhưng biểu thức 2 nếu ko có thì for sẽ lặp l ại mãi vì ko có đk d ừng V for(;;) for(int i=0; i
14. Xử lý Hàm void xuly(int a, int b){ int a++; Lúc này nếu trong void main ta gọi đến hàm tong() , thì sau khi khai báo x = 5, y = 3, int b--; CT sẽ gọi đến hàm xuly(x,y) … lúc này trước khi vào thân hàm xuly, sẽ xảy ra các printf(“a = %d\n”,a); câu lệnh sau: printf(“b = %d”,b); } int a = x; int b = y; void tong(){ => ta gán 2 bíên khác, là a và b, có giá tr ị b ằng v ới x và y => Khi x ử lý a,b trong hàm int x = 5, y = 3; xuly thì x,y ở ngoài ko thay đổi giá trị ban đầu. Khi ta xuất a, b ra màn hình thì xuly(x,y); a=6 printf(“x = %d\n”,x); b =2 printf(“y = %d”,y); Nhưng khi thoát khỏi xuly(x,y) trở lại tong(), ta xuất x, y ra màn hình thì v ẫn đc gía tr ị } x, y ban đầu : x = 5, y = 3 void xuly(int &a, int &b){ int a++; Lúc này nếu trong void main ta gọi đến hàm tong() , thì sau khi khai báo x = 5, y = 3, int b--; CT sẽ gọi đến hàm xuly(x,y) … lúc này trước khi vào thân hàm xuly, sẽ xảy ra các printf(“a = %d\n”,a); câu lệnh sau: printf(“b = %d”,b); } int &a = x; int &b = y; void tong(){ => ta gán 2 bíên mặt nạ, hay nói cách khác, đ ặt l ại tên cho x,y đ ể có th ể dùng trong int x = 5, y = 3; hàm, là a và b, có giá trị bằng với x và y => Khi x ử lý a,b trong hàm xuly thì x,y ở xuly(x,y); ngoài sẽ thay đổi y như vậy. Khi ta xuất a, b ra màn hình thì: printf(“x = %d\n”,x); a=6 printf(“y = %d”,y); b =2 } Và khi thoát khỏi xuly(x,y), trở lại tong(), ta xuất x, y ra màn hình thì đc gía tr ị x, y nh ư a,b trong hàm: x=6 y=2 void xuly(int &x, int y){ int a++; Lưu ý : Tên biến trong và ngoài hàm có thể khác nhau hoặc giống nhau. Chỉ có int b--; tên biến trong cùng 1 hàm thì phải khác nhau. printf(“a = %d\n”,a); printf(“b = %d”,b); } Dù cho tên biến trong và ngoài hàm có giống nhau, nh ưng nếu đó ko ph ải khai báo biến mặt nạ, thì cũng ko làm thay đổi khi ra khỏi hàm. VD bên: void tong(){ int x = 5, y = 3; Biến x thay đổi trong hàm xuly sẽ làm x ngoài hàm tong thay đ ổi theo. Nh ưng bi ến y xuly(x,y); thì ko printf(“x = %d\n”,x); printf(“y = %d”,y); Trong TH này, kiểu khai báo x ta gọi là khai báo tham số (thay đổi sau lới gọi hàm), } y ta gọi là khai báo tham trị (ko thay đổi sau lời gọi hàm)
CHƯƠNG 2: Mảng 1 chiều 1. Định nghĩa: Mảng 1 chiều thực chất là 1 tập hợp các biến có cùng kiểu, có địa ch ỉ sát bên nhau. VD : thay vì khai báo a,b,c,d,e,f,g,h là các biến số nguyên, ta có th ể khai báo int a[8]. Ta sẽ có a[0], a[1], .. ,a[7] là các bi ến int cũng giống như a,b,c,d,e,f,g,h, nhưng dễ dàng quản lý bởi vòng for: for( int i=0; i
5. Kĩ thuật liệt kê vị trí: Thay vì return như kĩ thuật tìm vị trí đầu, cuối, với mỗi pt ử thoã yêu c ầu, ta xu ất ra màn hình vị trí của nó. VD: liệt kê vị trí các ptử max, liệt kê vị trí các ptử dương min, hay liệt kê các pt ử ngt ố void lietke_ptu_lonhon_k(int a[], int n, int k) void lietke_ptu_chan(int a[], int n) void lietke_ptu_ngto(int a[], int n) { { { for(int i = vt; i
10. Một số bài tập minh hoạ: • Tính tổng các ptử dương trong mảng các số thực #include float tongptuduong(float a[], int n) { #include float s=0; #define maximum 100 for(int i=0; i0) void nhap(float a[],int &n) { s = s + a[i]; printf("Nhap vao tong cac phan tu :"); return s; scanf("%d", &n); } printf("Bat dau nhap cac ptu cua mang : \n"); for( int i=0; i
• Đếm số lượng số nguyên tố trong mảng các số nguyên #include #include int xet_so_nt(int k) { #include if (k
• Xoá các ptử âm trong mảng số thực #include #include #define maximum 100 void xoaam(float a[], int &n) { for(int i=0; i
CHƯƠNG 3: Ma trận – Con trỏ 1. Ma trận • Ma trận thực chất chính là mảng 1 chiều nếu xét về cách tổ chức trong b ộ nh ớ. Chỉ khác là khi xu ất ra màn hình ta có dạng bảng. • Khai báo ma trận: KDL [][]. • VD: int a[ 10 ][ 50 ]  Ma trận 10 dòng 50 cột • Nhập xuất ma trận: Nhập ma trận Xuất ma trận void nhaphangcot( int &m, int &n ) { void xuat( int a[][mx], int m, int n ) printf("Nhap vao so hang ma tran: "); { scanf("%d", &m); for( int i=0; i
o delete ptr[];
3. Một số bài tập minh hoạ: • Tính tích các số lẻ trong ma trận các số thực #include #include long tich_le( float a[][mx], int m, int n ) { #define mx 30 long t = 1; for( int j=0; j
• Đếm số lượng số âm trên 1 hàng trong ma trận các s ố nguyên #include #include void am_hang( int a[][mx], int m, int n ) { #define mx 30 for( int i=0; i
CHƯƠNG 4: Trừu tượng hoá dữ liệu 1. Định nghĩa: • Trừu tượng hoá dữ liệu chính là tạo ra 1 kiểu dữ liệu mới ( sv, nv, phanso, soao, taikhoan… ) bằng cách h ợp các kiểu dữ liệu đơn giản thành 1 kiểu phức tạp hơn, nhằm mô t ả 1 đối tượng trong thế gi ới th ực • VD: Ta khai báo kiểu dữ liệu sv, gán a là 1 sv: sv a  Ta có a là 1 biến có kiểu sv _ 1 sinh viên, có họ tên, điểm trung bình, năm sinh … • Cú pháp: • Mộ số KDL mới cơ bản: KDL sinh viên KDL nhân viên KDL đơn thức KDL tài khoản ngân hàng struct sv struct nv struct donthuc struct tk { { { { char ten[30]; char ten[30]; float a; char ten[30]; long mssv; long maNV; int n; long mstk; int ns; int namsinh; }; float sotien; float dtb; float luong; }; }; }; KDL nút của DSLK KDL nút của cây nhị phân KDL phân số KDL điểm trong mặt phẳng struct nodeList struct nodeTree struct ps struct diem { { { { data info; data info; int tu; float x; nodeList* next; nodeTree* left; int mau; float y; }; nodeTree* right; }; }; }; 2. Nhập – Xuất • Ta nhập – xuất lần lượt từng thành viên của mỗi struct theo như Nhập xuất cơ bản ( chương 1, mục 7 ), chỉ khác ở nhập float & thêm tên đối tượng của struct. VD: Ta khai báo: sv x; void nhap(sv &x){ void xuat(sv x){ flushall(); printf(“Ten SV: %s”, x.ten); printf(“Nhap ten:”); gets(x.ten); printf(“Mssv: %ld”, x.mssv); printf(“Nhap mssv:”); scanf(“%ld”,&x.mssv); printf(“Nam sinh: %d”, x.ns); printf(“Nam sinh:”); scanf(“%d”,&x.ns); printf(“Diem tb:%2.1f”, x.dtb); float t; } printf(“Diem tb:”); scanf(“%f”,&t); x.dtb = t; } • Như VD trên, khi nhập thành phần kiểu float thì ko nhập trực tiếp như scanf(“%f”,&x.dtb); mà phải thông qua 1 biến t kiểu float. Và trước khi gets(…) phải có flushall(); Khi xuất ra hay sử dụng thì bình thường. 3. Các bài tập minh hoạ • Tính tổng 2 phân số #include ps rutgon( ps p ) { #include int t = UCLN(p.tu,p.mau); p.tu /= t; struct ps { p.mau /= t; int tu,mau; return p; }; } void nhap( ps &p ){ ps tong( ps m , ps p) { printf("\nNhap tu cua phan so : "); scanf("%d",&p.tu); ps sum = m; printf("Nhap mau cua phan so : "); scanf("%d",&p.mau); if(m.mau == p.mau) sum.tu += p.tu; } else { sum.tu = sum.tu*p.mau + p.tu*sum.mau; void xuat( ps p ) { sum.mau = sum.mau*p.mau; if(p.mau == 1) printf("%3d",p.tu); } else printf(" %d/%d ",p.tu,p.mau); sum = rutgon(sum); } return sum; } int UCLN(int a, int b) { a = abs(a); void main() { b = abs(b); ps m,p; while(a!=b) printf("\tNhap phan so 1 : "); nhap(m); if(a>b) a-=b; printf("\tNhap phan so 2 : "); nhap(p); else b-=a; printf("\nPhan so vua nhap la : "); xuat(m); xuat(p); return a; ps kq = tong(m,p); } printf("\nTong 2 phan so la : "); xuat(kq); getch(); }
• Tính khoảng cách giữa 2 điểm trên mặt phẳng Oxy #include void xuat( dm a ) { #include printf(" (%4.1f , %4.1f) ",a.x,a.y); #include } typedef struct diem { float khoangcach( dm a, dm b ) { float x,y; return sqrt( (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) ); }dm; } void nhap( dm &a ) { void main() { float t; dm a,b; printf("\nNhap hoanh do x : "); scanf("%f",&t); printf("\tNhap toa do diem A trong Oxy: "); nhap(a); a.x = t; printf("\tNhap toa do diem B trong Oxy: "); nhap(b); printf("Nhap tung do y : "); scanf("%f",&t); printf("\nDiem vua nhap la : "); xuat(a); xuat(b); a.y = t; float kq = khoangcach(a,b); } printf("\nKhoang cach giua A & B la : %f",kq); getch(); } • Tính chu vi đường tròn #include #include void xuatdtron( dt A ) { struct dm { printf(" ((%4.1f,%4.1f),%4.1f) ",A.I.x,A.I.y,A.R); float x,y; } }; float chuvi( dt A ) { typedef struct duongtron { return 2*3.14*A.R; dm I; } float R; }dt; void main() { clrscr(); void nhapdiem( dm &a ) { dt A; float t; printf("\tNhap duong tron A trong mat phang Oxy: "); printf("\nNhap hoanh do x : "); scanf("%f",&t); nhapdtron(A); a.x = t; printf("\nDuong tron A vua nhap la : "); xuatdtron(A); printf("Nhap tung do y : "); scanf("%f",&t); float kq = chuvi(A); a.y = t; printf("\nChu vi duong tron A la : %4.1f",kq); } getch(); } void nhapdtron( dt &A ) { float t; printf("\nNhap tam I : "); nhapdiem(A.I); printf("Nhap ban kinh : "); scanf("%f",&t); A.R = t; } • Tính chu vi tam giác #include #include float chuvi( tg P) { #include float ab = khoangcach(P.A,P.B); float bc = khoangcach(P.B,P.C); typedef struct diem { float ac = khoangcach(P.A,P.C); float x,y; return ab+bc+ac; }dm; } typedef struct tamgiac { void main() { dm A,B,C; tg P; }tg; printf("\tNhap Tam giac P: "); nhaptamgiac(P); void nhapdiem( dm &a ) { printf("\tTam giac P : "); float t; xuattamgiac(P); printf("\nNhap hoanh do x : "); scanf("%f",&t); float kq = chuvi(P); a.x = t; printf("\nChu Vi cua P: %4.1f",kq); printf("Nhap tung do y : "); scanf("%f",&t); getch(); a.y = t; } } void nhaptamgiac( tg &P ) { printf("\nNhap dinh A : "); nhapdiem(P.A); printf("\nNhap dinh B : "); nhapdiem(P.B); printf("\nNhap dinh C : "); nhapdiem(P.C); } void xuattamgiac( tg P ) { printf(" ( (%4.1f,%4.1f);(%4.1f,%4.1f);(%4.1f,%4.1f) ) ",P.A.x,P.A.y,P.B.x,P.B.y,P.C.x,P.C.y); } float khoangcach( dm a, dm b ) { return sqrt( (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) ); }