Để làm 1 hacker giỏi như mấy anh thì bước đâu tiên của em là như thế nào...
Có anh nào giúp em,em mê lắm nhưng chưa biết bắt đầu từ đâu và đi về đâu ( 

Nguyên tắc :
Chia mảng cần sắp thành 2 phần
Phần đã được sắp và phần chưa được sắp :
<A = phần được sắp> < B= phần chưa được sắp>
C = phần tử đầu tiên của B

Bước 1 : Tìm trong B phần tử lớn nhất max_key
Bước 2 : swap C và max_key ( hoán đổi vị trí )
Bước 3 : Bỏ max_key vào A . Khi này A mới = { A cũ , max_key } .
Quay lại bước 1  

void Sortable_List<Record>::selectionsort()
{
for ( int position = count -1 ; position > 0 ; position -- )
{
int max = max_key(0,position) ; // tìm key lớn nhất
swap ( max , position ) ;
}
}
void Sortable_List<Record>::swap ( int low , int high)
{
Record temp ;
temp = entry[low] ;
entry[low] = entry[high] ;
entry[high] = temp ;
}
.... max_key(int low , int high)
{
int largest , current ;
largest = low ;
for ( current = low +1 ; current <= high ; current ++ )
if ( entry[largest] < entry[current] )
{
largest = current ;
}
return largest ;
}

VD :
A = { 5 8 6 3 10 }
Insertion sort làm như sau :

Chia mảng A làm 2 phần sorted và unsorted
Ban đầu sorted là B = { 5 }
Unsorted là C = { 8 6 3 10 }

Lần làm thứ nhất :
Lấy phần tử đầu tiên của C là 8 ra---> C = { 6 3 10 }
Tìm vị trí của số 8 trong mảng B ---> B = { 5 8 }

Lần làm thứ hai :
Lấy phần tử đầu tiên của C là 6 ra---> C = { 3 10 }
Tìm vị trí của số 6 trong mảng B ---> B = { 5 6 8 }

Lần làm thứ ba :
Lấy phần tử đầu tiên của C là 3 ra---> C = { 10 }
Tìm vị trí của số 3 trong mảng B ---> B = { 3 5 6 8 }

Lần làm thứ tư :
Lấy phần tử đầu tiên của C là 10 ra---> C = { }
Tìm vị trí của số 10 trong mảng B ---> B = { 3 5 6 8 10}

Kết thúc thuật toán  

void Sortable_List<Record>::insertion_sort() // phien bản nay list được hien thưc thông qua mảng chứ kg phải con trỏ
{
int first_unsorted ;
int position ;
Record current ;
for( first_unsorted = 1 ; first_unsorted < count ; first_unsorted ++)
{
if(entry[first_unsorted] < entry[first_unsorted-1])
{
position = first_unsorted ;
current = entry[first_unsorted] ;
do {
entry[position] = entry [ position -1] ;
position -- ;
} while (position > 0 && entry[position-1]> current );
entry[position] = current ;
}
}
}

Heap là một cấu trúc dữ liệu , có thể được biểu diễn thông qua 2 cách :
-Dạng thứ 1: Dạng cây nhị phân có đặc điểm là node cha thì lớn hơn 2 node con trực tiếp của nó .
-Dạng thứ 2: nếu ta đánh số các node theo thứ tự từ trên xuống và từ trái qua . Bắt đầu là node root = 0 , thì ta có thể định nghĩa heap thông qua mảng một chiều , có đặc điểm là phần tử thứ k sẽ lớn hơn các phần tử thứ 2k+1 và 2k+2 . Ta có thể dễ nhận thấy là phàn tử thứ 0 sẽ tương ứng với root trong cây ở cách biểu diễn thứ 1

Nguyên tắc sắp xếp của heap sort
Dựa vào tính chất của heap trong cách biểu diễn thứ 1 và thứ 2 , ta có thể thấy phần tử đầu tiên trong cách biểu diễn theo mảng sẽ là phần tử lớn nhất ---> cách sắp xếp đơn giản là : ( Gọi mảng ban đầu là A )

Khởi tạo : Tạo heap từ mảng ban đầu đã cho (mảng A )
1. Lấy phần tử đầu tiên trong mảng ra bỏ vào mảng kết quả
2. Tạo lại heap từ mảng A
3.Quay lại bước 1

VD : Ta lấy một mảng đã được tạo thành một heap :

y r p d f b k a c

Lấy phần tử đầu tiên là y bỏ vào mảng kết quả C = { y }

khi này A = r p d f b k a c
Tạo heap A = r f p d c b k a

Lấy phần tử đầu tiên ra là r bỏ vào mảng C = { r y }
Khi này A = { f p d c b k a }
Tạo heap cho A = { p f k d c b a}

Lấy phần tử đầu tiên ra là p bỏ vào mảng C = { p r y }
Khi này A = { f k d c b a }
Tạo heap cho A = { k f b d c a}

Lấy phần tử đầu tiên ra là k bỏ vào mảng C = { k p r y }
Khi này A = { f b d c a }
Tạo heap cho A = { f d b a c}

Lấy phần tử đầu tiên ra là f bỏ vào mảng C = { f k p r y }
Khi này A = { b d c a }
Tạo heap cho A = { d c b a}

Lấy phần tử đầu tiên ra là d bỏ vào mảng C = {d f k p r y }
Khi này A = { c b a }
Tạo heap cho A = { c a b }


Lấy phần tử đầu tiên ra là c bỏ vào mảng C = {c d f k p r y }
Khi này A = { b a }
Tạo heap cho A = { b a }

Lấy phần tử đầu tiên ra là b bỏ vào mảng C = {b c d f k p r y }
Khi này A = { a }
Tạo heap cho A = { a }

Kết thúc ta có được mảng C đã có thứ tự .

Cải tiến:
Ta có thể hạn chế việc sử dụng thêm mảng C bằng cách tận dụng luôn mảng A ban đầu . Ta làm như sau

A = y r p d f b k a c
Bước 1 :
Lấy y ra
Lấy c ra
Bỏ y vào chổ của c .
Bỏ c vào chỗ của y

Khi ta bỏ y vào chỗ của c thì giống như ta bỏ y vảo mảng C .
Khi này mảng A sẽ coi như gồm 2 phần A = c r p d f b k a ---- y

Bước 2 : tạo heap cho phần đứng trước của A là c r p d f b k a
Phần sau là chứa y để nguyên

Ta sẽ có A mới là : r f p d c b k a -- y

Quay lại bước 1 : Lấy r , a ra và swap r và a
A sẽ thành A= a f p d c b k -- r y
Tạo heap cho A = p f k d c b a -- r y
...........
Làm tương tự đến khi kết thúc

Qua VD ta thấy rằng phần quan trọng nhất là làm sao sinh ra heap từ một mảng cho trước

Sau đây là phần code cho phần cải tiến
Giải thuật

Post Condition : Dùng để phục hồi lại heap .
Pre Condition :


Ta sẽ có A mới là : r f p d c b k a -- y
Quay lại bước 1 : Lấy r , a ra và swap r và a
A sẽ thành A= a f p d c b k -- r y
Tạo heap cho A = p f k d c b a -- r y

Thì khi này current chính là a
low là 0
high là 7
 

void Sortable_List<Record>::insert_heap(const Record ¤t, int low , int high )
{
int large ;
large = 2*low+1 ;
while ( large <= high ) {
if (large < high && entry[large] < entry[large+1] )
large ++ ;
if(current >= entry[large] )
{
break ;
}
else
{
entry[low] = entry[large] ;
low = large ;
large = 2 * low + 1 ;
}
}
entry[low] = current ;
}
Tạo ra heap lúc ban đầu , lúc chưa chạy giải thuật
void Sortable_List<Record>::bulidheap()
{
int low ;
for ( low = count / 2- 1; low >= 0 ; low -- )
{
Record current = entry[low] ;
insert_heap(current, low, count -1) ;
}
}
void Sortable_List<Record>::heapsort ()
{
Record current ;
int last_unsorted ;
buildheap() ;
for ( last_unsorted = count -1 ; last_unsorted > 0 ; last_unsorted -- )
{
current = entry[ last_unsorted] ;
entry[last_unsorted] = entry[0] ;
insert_heap(current,0,last_unsorted-1) ;
}
}

Ý tưởng:
Gần giống như merge sort , ta sẽ chia đôi mảng cần xếp rồi sắp xếp các mảng con , sau đó sẽ ghép mảng con đã sắp xếp thành mảng ban đầu nhưng đã sắp xếp

Điểm khác nhau: Là chổ ta chia đôi mảng con theo nguyên tắc riêng :
Gọi điểm mà tại đó ta chia đôi mảng ban đầu có trị là pivot (không nhất thiết là nằm đúng vị trí chính giữa . Nhưng giải thuật sẽ chạy tốt nếu nó nằm gần điểm chính giữa) và ta sẽ không cần merge 2 dãy con (do đó nhìn chung sẽ chạy nhanh hơn ) , thỏa điều kiện là tất cả những phần tử bên trái pivot đều nhỏ hơn pivot và nằm bên phải pivot thì lớn hơn pivot

VD :
2 4 6 7 18 14 13
Ta chọn phần tử pivot = 7 ( do bên trái của nó nhỏ hơn pivot = 7 , bên phải lớn hơn pivot = 7 ) (Thực ra ta phải tìm pivot , do ở đây làm bằng tay nên dễ thấy )
Chia đôi : A = { 2 4 6 } B = { 18 14 13 }
+ Sắp A
+ Trong dãy A ta cũng chọn phần tử pivot là 4
+ Được 2 dãy con là A11 = {2 } A12 = {6}
+ Sắp A11 ( sắp sẵn rồi )
+ Sắp A12 ( sắp sẵn rồi )
+ Tạo lại mảng A = { A11 được sắp , pivot , A12 được sắp } = {2 4 6 }
+Sắp B . Trong B ta không thấy được pivot do chọn cái nào ta cũng không thấy thỏa . Nhưng mục tiêu của quick sort là làm sao ta được dãy
<C= dãy có trị nhỏ hơn pivot > pivot < D= dãy có trị lớn hơn pivot >
Sắp 2 dãy con C , D rồi ghép lại ta được dãy sắp thứ tự .


Vì vậy áp dụng một giải thuật tìm pivot trong B( sẽ trình bày sau ) ta sẽ được C = { 13} D = {18} và pivot là 14 .
+ Sắp dãy con C , D ( do chỉ có một phần tử nên không sắp , hoặc tìm pivot)
+ Ghép lại tạo thành mảng B được sắp B = { 13 14 18 }

+Ghép A và B để tạo thành mảng được sắp xếp ban đầu
 

void Sortable_List<Record>::quick_sort()
{
recursive_quick_sort(0 , count -1 ) ;
}
void Sortable_List<Record>::recursive_quick_sort(int low , int high )
{
int pivot_position ;
if (low < high )
{
pivot_position = partition (low , high ) ;
recursive_quick_sort(low , high ) ;
recursive_quick_sort(pivot_position +1 , high ) ;
}
}
int Sortable_List<Record>::partition(int low , int high )
{
Record pivot ;
int i , last_small;
swap ( low , (low +high) /2 ;
pivot = entry[low] ;
last_small = low ;
for ( i = low +1 ; i <= high ; i ++ )
{
if(entry[i] < pivot )
{
last_small = last_small +1 ;
swap ( last_small , i ) ;
}
}
swap (low , last_small );
return last_small ;
}

Nguyên tắc :

VD ta có
12 13 45 32 100 34 65 10

Ta có ở trên là 8 phần tử cần được sắp xếp :
Ý tưởng của merge sort là thay vì sắp xếp 8 phần tử (khó sắp ) thì ta chia đôi dãy đó ra làm đôi (số phần tử nhỏ hơn --> sắp dễ hơn ) và sắp xếp các dãy con rồi ghép 2 dãy con lại ( gọi là merge 2 dãy con )

Vậy ta làm như sau:
Chia đôi --> được hai dãy con mới là 12 13 45 32 và 100 34 65 10
sắp 2 dãy con lại : 12 13 45 32 gọi là dãy A
100 34 65 10 gọi là dãy B
+ Muốn sắp A ta cũng làm y như trên
Chia đôi A , được 2 dãy mới là A11 = { 12 13 } A12 = {45 32 }
Chia đôi B được 2 dãy mới là B11 = {100 34} B12 = {65 10 }
+ Sắp xếp A11, B11 , A12 , B12
+ Muốn sắp xếp A11 thì ta cũng chia đôi đến khi sắp được
ta có 2 dãy con là A21 = {12} A22 = { 13}
Sắp 2 dãy con trên được ( đơn giản vì chỉ có một phần tử ) là A21 = {12 } A22 = {13}
Sắp xong thì ta merge lại thành A11 = { 12 13 }
+ Tương tự sắp xếp cho B11 , A12 , B12 ta cũng có
B11 = {34 100} B12 = {10 65 } A12 = {32 45 }
+Sắp xếp xong , ta sẽ merge lại A11 , A12 thành A = { 12 13 32 45 }
B11 , B12 thành B = { 10 34 65 100 }
Sắp xong A , B , ta sẽ merge chúng lại thành dãy ban đầu :
{10 12 13 32 34 45 65 100 }

Phương pháp merge:
VD A = { 12 13 32 45 }
B = { 10 34 65 100}

Đầu tiên lấy phần tử đầu tiên của A và B : 12 và 10
10 < 12 nên ta lấy 10 bỏ vào mảng kết quả là C = {10}
Giử lại số 12 , và lấy tiếp phần tử thay thế 10 trong mảng B là 34
So sánh 12 và 34 . 12 < 34 , lấy 12 ra và bỏ vào C = {10 12}
Giử lại 34 . Lấy phần tử kế tiếp để thay cho 12 trong mảng A là 32
So sánh 32 và 34 chọn 32 bỏ vảo C = { 10 12 32 }
........ Làm tương tự ......
Đến bước cuối cùng A hết phần tử B còn lại B = { 65 100}
Ta sẽ bỏ toàn bộ mảng B vào C . Kết quả C đã được merge và có thứ tự

Giải thuật:(cho trường hợp dùng list để chứa các phần tử cần sort)

Sortable_List là một lớp list có đặc điểm là có hàm sort
Node là một template class biểu diễn cho các node trong list
Record là class dùng để biểu diễn data cần sắp xếp . ( VD như sắp một dãy các số nguyên , hay VD là sắp theo tên của các record bao gồm tên , tuổi , số điện thoại ...)
sublist là list cần sắp xếp
 

Sortable_List<Record>::recursive_merge_sort(Node<Record> *&sublist )
{
if ( sublist != 0 && sublist->next != 0 } //tức là có tồn tại 2 node trở lên để có thể chia đôi sublist được
{
Node <Record > *second_half = divide_from (sublist);
recursive_merge_sort(sublist) ;
recursive_merge_sort(second_half) ;
sublist = merge(sublist, second_half)
}
}
Node<Record>* Sortable_List <Record>::divide_from( Node<Record> *sublist)
{
Node<Record> *position , *midpoint , *second_half ;
if (( midpoint = sublist) == NULL) return NULL ; // hổng có ds để chia
position = midpoint->next ;
while(position != 0)
{
position = position->next ;
if ( position != 0)
{
midpoint = midpoint->next ;
position = position->next ;
// midpoint duyêt 1 thì position duyệt 2 node cùng 1 lúc nên khi position kết thúc = NULL thì midpoint cũng đang ở vị trí chính giữa;
}
}
second_half = midpoint->next ;
midpoint->next = NULL ;
return second_half ;
}
Node <Record> * merge(Node<Record> *first , Node<Record>* second )
{
Node<Record> *last_sorted ;
Node<Record> combined ;
last_sorted = &combined ;
while ( first != NULL && second != NULL )
{
if (first->entry <= second->entry ) {
last_sortesorted->next = first ;
last_sorted = first ;
first = first->next ;
}
else
{
last_sorted->next = second ;
last_sorted = second ;
second = second->next ;
}
}
if ( first == NULL )
last_sorted->next = second ;
else
last_sorted-> next = first ;
return combind.next
}

Thằng bạn em nó vừa thi kỳ thi tuyển sinh ĐH xong, nó không đủ điểm chuẩn vào khoa CNTT trường BK mà nó mong muốn. Nó tính ở nhà ôn sang năm thi tiếp nhưng ba má nó kêu nó đi học một số khoá học chuyên viên hay kỹ thuật viên cũng được chứ không nhất thiết phải học ĐH. Nó nói với em là nếu học thì nó chọn học một trong 2 hướng: 1 là học quản trị mạng, 2 là học đồ hoạ. Nó có hỏi em là học một trong 2 hướng đó thì khi ra trường cái nào sẽ dễ xin việc và áp dụng thực tế nhiều hơn.  

Một trong những kĩ năng của người dùng Internet là tìm kiếm thông tin. Tại sao em không thử tìm 1 vòng trên các search engine, vd tại Google http://www.google.com/search?hl=en&q=Caesar+Cipher&btnG=Google+Search 

Từ trước đến giờ mình thấy cái nào cũng có cánh quạt đi kèm, nhưng đợt vừa rồi đi lên cửa hàng trung tâm máy tính thấy có cái không có cánh quạt(mà giá thì vẫn ngang ngửa với mấy cái có cánh quạt, tầm 40 €), mình lại không thạo mấy cái này lắm, không biết có tốt không. 

-Còn cái ổ nguồn thì nó bảo phải mua cái từ 400W chở lên. Mà khi đi xem thì hầu như toàn thấy cái cánh quạt của nó ở phía trên chứ không phải ở đằng sau như mấy cái máy mình thường gặp, nếu như mua cái đó mình có thể lộn ngược cái hướng của cánh quạt xuống dưới được không (tại nếu để hướng lên thì phải khoan một lỗ ở phía trên máy).Có cái mình còn thấy nó có cả ở trên lẫn dưới, như thế tôt hay là không tôt. 

Đậy là cấu hình của máy mình:
CPU: AMD Athlon XP 3000+ L2/512KB, Sockel 939  

Anh nói như vậy thì em đã hiểu rõ vấn đó đó rồi em rất cảm ơn anh nhe !
nhưng vậy thì vẫn còn cái khác em chưa biết em muốn hỏi anh thêm không biết có phiền gì anh không nữa nếu như có phiền anh thì cho em xin lỗi anh nhe còn nếu anh giúp được cho em thì em mừng và cảm ơn anh nhiều .Chuyện là em muốn biết cách hạn chế người truy cập internet nếu người đó muốn truy cập internet thì phải thông qua pasword nếu không có pass thì sẽ không truy cập được internet vậy anh biết cách thì giúp em với .Minh phải cần thay đổi thông số nào hay phải sử dụng phần mềm hổ trợ vậy anh ,mong anh giúp cho em với !  

nhu cầu bạn dùng là gì ? có xài .NET không ? có xài Eclipse hay đồ hoạ không ? từ đó mới hình thành nhu cầu về cấu hình ( nếu là dân SV) , thưc ra bạn chọn con Pentium 2X cũng không cần thiết lắm vì nó sẽ không hoạt động hết công suất trong quá trình bạn làm việc đâu ! bạn nên chú ý tới RAM,Cache có lẽ cần hơn .
Thân. 

Hờ, cái BIOS máy em nó chẳng hiểu sao nữa, hình như là hư(Em không chắc lắm )
Tình trạng nó thế này:
Máy chạy khá chập chờn, có lúc thì boot vào được DOS, lúc thì bị đứng ở chỗ test ram, có lúc thì detect được cái ổ CD+HDD thì đứng luôn. Sáng nay bật ra thì nó báo lỗi gì đó liên quan đến check sum(Em không nhớ rõ, lúc đó lú lẫn quá, quyên ghi lại) rồi đứng. Em tắt máy đi ra ngoài một lát, quay vào bật lại thì màn hình chả thèm hiện nữa, em đã kiểm tra đủ kiểu rồi nó vẫn không chịu lên.
Khi bật máy mấy lần em có thấy cái đèn ổ đĩa mềm nó sáng trưng(em không set khởi động từ đĩa mềm). Có lần nào đó em đọc hình như BIOS trục trặc nó kiểm tra ổ đĩa mềm để phục hồi gì đó nên em đoán BIOS có vấn đề. Em thử search nhưng toàn thấy nó update từ DOS :?) .
Vậy giờ làm sao em sửa được cái BIOS ạ? 

Mình cũng kiểm tra rồi các bạn ạ. Mang Ram sang máy khác thi no vẫn chạy bình thường vẫn nhận đủ Ram (Mình có 2 thanh 128 ), mang ổ cứng cài ở máy khác vẫn cài ngon. Còn đĩa SP2 thi vẫn cài ở máy khác bình thường. CÓ khi nào la do CD ROM ko nhi? 

Thằng bạn tui nó nói là có loại main mà cứ cắm RAM vào thì dung lượng RAM lại tăng gấp đôi??
Có loại đấy không các bác????? :?) :?)

 

Cài 1 chương trình vào máy,run nó thì chỉ thấy 1 màn hình đen ngòm xuất hiện trong 3 s,sau đó nó trả về màn hình desktop như cũ ><.cài lại win vẫn thế ><,lỗi như thế thường là do đâu.Mong các anh chỉ giáo :?  

Em có thằng em trai, hiện giờ nó đang học bên Nhật bủn. Sắp tới nó muốn đón em sang đó để học. Vậy có anh chị nào trong diễn đàn thành thạo về vấn đề du học thì giúp em 1 chút được không??
- Thủ tục để thằng em em bảo lãnh em sang đấy học là như thế nào, bao gồm những gì???
- Hoặc có ai biết thông tin về vấn đề này thì chỉ giáo em 1 chút nha.

Em xin cảm ơn