Output : Chuỗi đã được mã hoá  

2. Nối ký tự đã chọn vào chuỗi đích.

3. Đếm số lần xuất hiện tiếp theo của ký tự được chọn và thêm số đếm vào chuỗi đích.

4.Chọn ký tự tiếp theo và lặp lại các bước 2, 3 và 4 nếu KHÔNG đến cuối chuỗi

2.   Trong khi chia mảng, phần tử trục phải được định vị sao cho các phần tử nhỏ hơn trục được giữ ở phía bên trái và các phần tử lớn hơn trục nằm ở phía bên phải của trục

3.   Các mảng con bên trái và bên phải cũng được chia theo cách tiếp cận tương tự. Quá trình này tiếp tục cho đến khi mỗi mảng con chứa một phần tử duy nhất(Đệ Quy)

4.   Tại thời điểm này, các yếu tố đã được sắp xếp. Cuối cùng, các phần tử được kết hợp để tạo thành một mảng được sắp xếp

Output: mảng gồm các vị trí bắt đầu của chuỗi (b) trong (a)

'Tiếp tục': nếu có ‘vị trí lưu’ thì quay lại xét các chữ cái trong (a) từ vị trí lưu. Nếu không thì tiếp tục xét từ chữ cái tiếp theo

-        Output: Chuỗi mẫu có khớp với chuỗi văn bản hay không.

Trường hợp 1: kí tự đang xét là ‘*’. Ở đây ta có hai trường hợp:

a)    Chúng ta có thể bỏ qua kí tự ‘*’ và xét kí tự tiếp theo trong chuỗi mẫu.

b)   Kí tự ‘*’ khớp với 1 hoặc nhiều ki tự trong chuỗi văn bản. Lúc này chúng ta xét kí tự tiếp theo trong chuỗi.

Trường hợp 2: kí tự đang xét là ‘?’: chúng ta bỏ qua kí tự đang xét trong văn bản và xét tiếp kí tự tiếp theo trong chuỗi mẫu và văn bản.

Trường hợp 3: kí tự đang xét không phải kí tự đại diện: nếu hai kí tự đang xét trong chuỗi mẫu và chuỗi văn bản không khớp thì chuỗi mẫu và chuỗi văn bản không khớp, nếu có thì xét tiếp kí tự tiếp theo trong mẫu và văn bản.

T[i][j] = 1 nếu và chỉ nếu i kí tự đầu tiên trong chuỗi văn bản khớp với j kí tự đầu tiên trong chuỗi mẫu.

Ngược lại T[i][j] = 0.

Với n là độ dài chuỗi văn bản, m là độ dài chuỗi mẫu.

+) Khởi tạo mảng hai chiều với T[i][j] = 0 (i chạy từ 0 đến n, j chạy từ 0 đến m)

+) Đầu tiên hai chuỗi rỗng thì luôn khớp nhau: T[0][0] = 1.

+) Tiếp theo đối sánh mẫu với chuỗi rỗng, ta chỉ xét các kí tự ‘*’ ở chuỗi rỗng (chỉ có ‘*’ mới khớp với chuỗi rỗng): 

a.     T[0][j] = 1 khi kí tự thứ j trong mẫu là ‘*’ và j – 1 kí tự đầu tiên trong mẫu khớp với chuỗi rỗng.

b.    T[0][j] = 0 khi kí tự thứ j trong mẫu là ‘*’ và j – 1 kí tự đầu tiên trong mẫu không khớp với chuỗi rỗng.

=> T[0][j] = T[0][j – 1] khi kí tự thứ j trong mẫu là ‘*’.

          +) Tiếp theo ta đối sánh lần lượt từng kí tự thứ i trong văn bản và thứ j trong mẫu:

·       Hai trường hợp nảy sinh nếu kí tự thứ j trong chuỗi mẫu là ‘*’: 

a.     Kí tự ‘*’ khớp với chuỗi rỗng: bỏ qua kí tự j.

b.    Kí tự ‘*’ khớp với i kí tự đầu tiên của chuỗi văn bản

T[i][j] = T[i][j - 1] || T[i - 1][j]

·       Nếu kí tự thứ j trong mẫu đang xét là ‘?’ hoặc hai kí tự đang xét khớp nhau thì bỏ qua hai kí tự đó:

                              T[i][j] = T[i – 1][j – 1]

·       Nếu 2 kí tự đang xét không phải kí tự đại diện và không khớp nhau:

T[i][j] = 0

Kết quả: Nếu T[n][m] = 1 thì chuỗi văn bản khớp với chuỗi mẫu, ngược lại thì không.

#include<conio.h>

#include<string.h>

 

int isMatch(char pattern[], int m, char text[], int n){

          // Khi chuoi mau rong:

          // Neu chuoi van ban khong rong thi tra ve dung, 

          // neu khong thi nguoc lai

    if (m == 0) 

        return (n == 0); 

        

    //Khai bao mang kiem tra:

    int lookup[n + 1][m + 1];

    

    //Khoi tao mang:

    for(int i = 0; i <= n; i++)

          for(int j = 0; j <= m; j++)

                    lookup[i][j] = 0;

    lookup[0][0] = 1;//Hai chuoi rong thi khop nhau

    

    //Chi co ki tu '*' khop voi chuoi rong:

    for(int j = 1; j <= m; j++)

          if(pattern[j - 1] == '*')

                    lookup[0][j] = lookup[0][j - 1];

                    

    //Thuc hien quy hoach dong de tinh tiep:

    for(int i = 1; i <= n; i++){

          for(int j = 1; j <= m; j++){

            // Hai truong hop neu la ki tu '*'

            // a) Bo qua ki tu '*' xet tiep 

            //    ki tu tiep theo cua chuoi mau,

            //    Tuc la '*' khop voi chuoi rong.

            // b) ki tu '*' khop voi i ki tu 

                              //    dau tien trong chuoi van ban

            if (pattern[j - 1] == '*')

                lookup[i][j]

                    = lookup[i][j - 1] || lookup[i - 1][j];

 

            // Ki tu dang xet khop o 2 truong hop:

            // (a) ki tu o chuoi mau dang xet la '?'

            // (b) hai ki tu dang xet khop nhau

            else if (pattern[j - 1] == '?'

                     || text[i - 1] == pattern[j - 1])

                lookup[i][j] = lookup[i - 1][j - 1];

 

            // Neu 2 ki tu dang xet khong khop

            else

                lookup[i][j] = 0;

                    }

          }

          return lookup[n][m];                  

}

 

 

main(){

          char sm[1000], sn[1000];

          printf("Nhap xau van ban: ");

          gets(sn);

          printf("Nhap xau mau: ");

          gets(sm);

          if(isMatch(sm, strlen(sm), sn, strlen(sn)))

                    printf("Khop!");

          else

                    printf("Khong khop!");

} 

Output: dãy số tăng dần

-        Output: dãy số tăng dần.

Lúc này ta dùng thuật toán trộn để trộn hai phần trên:

-        So sánh 2 khóa từ đầu dãy.

-        Chọn ra khóa nhỏ hơn đưa vào mảng tạm, sau khi chọn thì tăng biến vị trí của phần có khóa được chọn và mảng tạm lên 1.

-        Lần lượt làm cho đển khi một phần được chọn hết, đưa phần dư còn lại vào mảng tạm.

-        Sao chép mảng tạm vào dãy số.

 

void NhapMang(int arr[], int n){

          for(int i =1 ; i<=n ;i++){

                    printf("Nhap so thu %d : ",i);

                    scanf("%d",&arr[i]);

          }

}

 

void XuatMang(int arr[], int n){

          for(int i = 1; i<= n; i++)

                    printf("%d ",arr[i]);

}

 

void MergeSort(int data[], int left, int right) {

          if (right - left < 1) 

                    return;

          int mid = (left + right) / 2;

          

          MergeSort(data, left, mid);

          MergeSort(data, mid+1, right);

 

          int i = left, j = mid + 1;

          int cur = 0;

          

          int a[right + 1];

 

          while (i <= mid || j <= right) 

                    if (i > mid) 

                              a[cur++] = data[j++];

                    else if (j > right)

                              a[cur++] = data[i++];

                    else if (data[i] < data[j])

                              a[cur++] = data[i++];

                    else 

                              a[cur++] = data[j++];

 

          for (int i = 0; i < cur; i++)

                    data[left + i] = a[i];

}

 

main(){

          int dso[1000], n; 

          printf("Nhap bao nhieu phan tu: ");

          scanf("%d", &n);

          NhapMang(dso, n);

          printf("\nDay so : ");

          XuatMang(dso, n);

          MergeSort(dso, 1, n);

          printf("\nDay so sau khi sap xep MergeSort: ");

          XuatMang(dso, n); 

} 

-        Output: dãy số tăng dần.

Chuyển những phần tử bé hơn phần tử chốt sang trái phần tử chốt, những phần tử còn lại sang phải.

Sắp xếp 2 mảng con bên trái và bên phải của phần tử chốt

 

void NhapMang(int arr[], int n){

          for(int i =1 ; i<=n ;i++){

                    printf("Nhap so thu %d : ",i);

                    scanf("%d",&arr[i]);

          }

}

 

void XuatMang(int arr[], int n){

          for(int i = 1; i<= n; i++)

                    printf("%d ",arr[i]);

}

 

void swap(int &x, int &y){

          int tg = x;

          x = y;

          y = tg;

}

 

void quickSort(int a[], int left, int right) {

          int i = left, j = right;

          int prio = a[left];

          

          while (i <= j) {

                    while (a[i] < prio) ++i;

                    while (a[j] > prio) --j;

 

                    if (i <= j) {

                              swap(a[i], a[j]);

                              ++i;

                              --j;

                    }

          }

          

          if (left < j) quickSort(a, left, j);

          if (i < right) quickSort(a, i, right);

}

 

main(){

          int dso[1000], n; 

          printf("Nhap bao nhieu phan tu: ");

          scanf("%d", &n);

          NhapMang(dso, n);

          printf("\nDay so : ");

          XuatMang(dso, n);

          quickSort(dso, 1, n);

          printf("\nDay so sau khi sap xep quickSort: ");

          XuatMang(dso, n);

} 

- Output: Dãy số tăng dần

-        Quá trình phân chia này diễn ra cho đến khi độ dài của các mảng con đều bằng 1

void NhapMang(int arr[],int n)

{

  for(int i=1;i<=n;i++)

  {

  printf("Nhap phan tu thu %d: ",i);

  scanf("%d",&arr[i]); 

  } 

} 

 

void XuatMang(int arr[],int n)

{

  for(int i=1;i<=n;i++) 

  printf("  %d  ",arr[i]);

} 

void HoanVi(int &a,int &b)

{

  int tg=a;

  a=b;

  b=tg; 

}

 

void QuickSort(int a[], int tr, int ph)

{

  if (tr>=ph)

  return;

  int chot = a[(tr+ph)/2];

  int i=tr;

  int j=ph;

  do

  {

  while(a[i]<chot)

       i++;

  while(a[j]>chot)

       j--;

  if (i<=j)

  {

       HoanVi(a[i], a[j]);

       i++;

       j--;

  }

  }

  while(i<j);

  QuickSort(a, tr, j);

  QuickSort(a, i, ph);

}

main()

{

  int dso[100], ptu;

  printf("Nhap bao nhieu phan tu: ");

  scanf("%d",&ptu);

  NhapMang(dso, ptu);

  printf("Day so vua nhap la: ");

  XuatMang(dso, ptu);

  QuickSort(dso, 1, ptu);

  printf("\nDay so sau khi sap xep la:\n");

  XuatMang(dso, ptu);

}