Hướng dẫn hàm sort trong c++

Sắp xếp dữ liệu trong Excel là một việc tưởng như rất đơn giản, bạn chỉ cần chọn dữ liệu cần sắp xếp rồi bấm 1 nút lệnh Sort trong thẻ Data là xong. Nhưng thực tế có phải đơn giản như vậy? Hãy xem những thắc mắc sau:

• Dữ liệu không có sẵn mà phải dùng hàm, dùng các thao tác lọc ra nên mỗi khi muốn sắp xếp dữ liệu đó lại phải bấm lệnh Sort, việc này mất thời gian
• Tôi muốn tự động sắp xếp dữ liệu mà không cần bấm vào lệnh Sort.
• Tôi muốn làm việc tự động trên Excel nhưng không muốn học về VBA

Và trong Micrsoft Office 365 (phiên bản có bản quyền đầy đủ) có một hàm giúp làm việc này thật dễ dàng: đó là hàm SORT. Hãy cùng Học Excel Online tìm hiểu về hàm này nhé:

Cấu trúc của hàm SORT (Sort Function)

Hàm Sort có tác dụng lọc các dữ liệu theo mảng Cấu trúc của hàm: =SORT(array,[sort_index],[sort_order],[by_col]) Trong đó:

• array: là mảng dữ liệu cần sắp xếp (có thể gồm nhiều dòng, nhiều cột nhưng phải liên tục)
• sort_index: tiêu chuẩn sắp xếp theo cột hay dòng thứ mấy trong mảng dữ liệu (nhập số cụ thể, không bắt buộc). Mặc định là cột/dòng đầu tiên
• sort_order: thứ tự sắp xếp theo tăng dần hay giảm dần. Không bắt buộc, mặc định là tăng dần.
• by_col: sắp xếp theo cột hay theo dòng. Không bắt buộc, mặc định là theo cột.

Như vậy hàm SORT cho phép sắp xếp dữ liệu theo cột hoặc theo dòng tùy theo người dùng quy định. Điều này giúp hàm SORT rất linh hoạt theo các yêu cầu sắp xếp dữ liệu.

Cách sử dụng hàm SORT

Hàm Sort kết hợp với hàm Filter

Array có thể là một vùng dữ liệu hoặc kết quả của 1 công thức cho ra kết quả dạng mảng. Do đó hàm SORT rất thích hợp để kết hợp với hàm FILTER: trích lọc dữ liệu đồng thời sắp xếp luôn dữ liệu đó. Ví dụ như sau: Trong bài Hướng dẫn cách lập báo cáo chi tiết tự động với hàm Filter trong Excel chúng ta đã tìm hiểu cách sử dụng hàm Filter để lập ra báo cáo chi tiết tự động. Nhưng ở ví dụ trên, chúng ta thấy dữ liệu trong bảng kê bán hàng không được sắp xếp theo trật tự nào cả. Khi đưa kết quả ra báo cáo chi tiết, chúng ta muốn dữ liệu của báo cáo sẽ phải tự động sắp xếp theo Ngày bán. Do đó chúng ta sẽ viết hàm SORT lồng bên ngoài hàm FILTER, dùng nội dung hàm Filter vào vị trí tham số array. Kết quả thu được là dữ liệu vừa lọc, vừa tự động sắp xếp trong báo cáo chi tiết. Rất đơn giản phải không nào?

Hàm Sort kết hợp với hàm UNIQUE

Xét ví dụ sau: Khi muốn lọc danh sách các mặt hàng không trùng, chúng ta có thể sử dụng hàm UNIQUE. Tuy nhiên có thêm 1 yêu cầu là danh sách các mặt hàng được lọc ra phải tự động sắp xếp theo thứ tự chữ cái từ A đến Z. Khi đó chúng ta sử dụng hàm SORT bên ngoài hàm UNIQUE.

Sắp xếp theo điều kiện trong hàm Sort

Sắp xếp dữ liệu theo điều kiện nhất định, nói cách khác chính là phải sử dụng các tham số còn lại trong hàm SORT, không phải chỉ viết đơn giản là chỉ có array, còn các giá trị còn lại thì để mặc định. Trong ví dụ dùng hàm SORT kết hợp với hàm FILTER, nếu như yêu cầu sắp xếp là “Sắp xếp kết quả báo cáo chi tiết theo số lượng Giảm dần” thì chúng ta sẽ xử lý như thế nào?

• sort_index: theo cột Số lượng, là cột thứ 3 từ trái sang (nhập số 3)
• sort_order: thứ tự sắp xếp là giảm dần (nhập số -1). Nếu thứ tự tăng dần (mặc định) thì là số 1.

Khi đó hàm sort được viết như sau:

=SORT(FILTER(B3:D14,(B3:B14>=G2)*(B3:B14<=G3)*(A3:A14=G4),””),3,-1)

Hy vọng qua bài viết này, các bạn đã có thêm những kiến thức hữu ích để áp dụng vào công việc của mình. Có thể thấy rằng Microsoft rất chú ý phát triển Excel để nó ngày càng thân thiện, dễ sử dụng và đạt hiệu quả cao hơn. Với những hàm mới của Microsoft Office 365, chúng ta đã có thể cảm thấy Excel tuyệt vời hơn rất nhiều phải không. Xem thêm các bài viết cùng chủ đề sắp xếp dữ liệu trong Excel:

Hướng dẫn cách trả về thứ tự ban đầu trước khi sắp xếp bằng sort trong Excel

Hướng dẫn cách sắp xếp dữ liệu theo nhiều điều kiện trong Excel

Hướng dẫn cách sắp xếp và lọc dữ liệu trong GoogleSheet

Hàm qsort trong C là một hàm có sẵn trong header file stdlib.h, giúp chúng ta sắp xếp mảng trong C. Cú pháp sử dụng hàm qsort() trong C như sau:

qsort(array, length, size, compare_fuct);

Trong đó:

• #include 
  #include 
  
  /*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
  #define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))
  
  /*Tạo hàm in phần tử trong mảng*/
  void show_array(int array[], int length){
    for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
    printf("\n");
  }
  
  /*Tạo hàm so sánh tăng dần sử dụng trong hàm qsort*/
  int compareIntAsc(const void* a, const void* b){
      int aNum = *(int*)a;
      int bNum = *(int*)b;
  
      return aNum - bNum;
  }
  
  
  int main(void){
      int array1[] = {5, 4, 7, 2, 8, 7, 3};
      int array2[] = {99, 4, 5, 2, 80, 7, 3};
  
      /*Sử dụng hàm qsort để sắp xếp mảng tăng dần*/
      qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntAsc);
      qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntAsc);
  
      /*Xem kết quả sắp xếp mảng*/
      show_array(array1, SIZE_OF_ARRAY(array1));
      show_array(array2, SIZE_OF_ARRAY(array2));
  
      return 0;
  }
  

  1 là mảng cần so sánh

• #include 
  #include 
  
  /*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
  #define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))
  
  /*Tạo hàm in phần tử trong mảng*/
  void show_array(int array[], int length){
    for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
    printf("\n");
  }
  
  /*Tạo hàm so sánh tăng dần sử dụng trong hàm qsort*/
  int compareIntAsc(const void* a, const void* b){
      int aNum = *(int*)a;
      int bNum = *(int*)b;
  
      return aNum - bNum;
  }
  
  
  int main(void){
      int array1[] = {5, 4, 7, 2, 8, 7, 3};
      int array2[] = {99, 4, 5, 2, 80, 7, 3};
  
      /*Sử dụng hàm qsort để sắp xếp mảng tăng dần*/
      qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntAsc);
      qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntAsc);
  
      /*Xem kết quả sắp xếp mảng*/
      show_array(array1, SIZE_OF_ARRAY(array1));
      show_array(array2, SIZE_OF_ARRAY(array2));
  
      return 0;
  }
  

  2 là độ dài (số phần tử) của mảng đó. Xem thêm: Độ dài mảng trong C.

• #include 
  #include 
  
  /*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
  #define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))
  
  /*Tạo hàm in phần tử trong mảng*/
  void show_array(int array[], int length){
    for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
    printf("\n");
  }
  
  /*Tạo hàm so sánh tăng dần sử dụng trong hàm qsort*/
  int compareIntAsc(const void* a, const void* b){
      int aNum = *(int*)a;
      int bNum = *(int*)b;
  
      return aNum - bNum;
  }
  
  
  int main(void){
      int array1[] = {5, 4, 7, 2, 8, 7, 3};
      int array2[] = {99, 4, 5, 2, 80, 7, 3};
  
      /*Sử dụng hàm qsort để sắp xếp mảng tăng dần*/
      qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntAsc);
      qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntAsc);
  
      /*Xem kết quả sắp xếp mảng*/
      show_array(array1, SIZE_OF_ARRAY(array1));
      show_array(array2, SIZE_OF_ARRAY(array2));
  
      return 0;
  }
  

  3 là kích thước một phần tử trong mảng. Ví dụ như kiểu int là 4 byte, char là 1 byte chẳng hạn. Xem thêm: Kiểu dữ liệu trong C.

• #include 
  #include 
  
  /*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
  #define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))
  
  /*Tạo hàm in phần tử trong mảng*/
  void show_array(int array[], int length){
    for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
    printf("\n");
  }
  
  /*Tạo hàm so sánh tăng dần sử dụng trong hàm qsort*/
  int compareIntAsc(const void* a, const void* b){
      int aNum = *(int*)a;
      int bNum = *(int*)b;
  
      return aNum - bNum;
  }
  
  
  int main(void){
      int array1[] = {5, 4, 7, 2, 8, 7, 3};
      int array2[] = {99, 4, 5, 2, 80, 7, 3};
  
      /*Sử dụng hàm qsort để sắp xếp mảng tăng dần*/
      qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntAsc);
      qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntAsc);
  
      /*Xem kết quả sắp xếp mảng*/
      show_array(array1, SIZE_OF_ARRAY(array1));
      show_array(array2, SIZE_OF_ARRAY(array2));
  
      return 0;
  }
  

  4 là hàm so sánh để quyết định thứ tự sắp xếp

Để quyết định thứ tự sắp xếp mảng bằng hàm qsort(), chúng ta cần sử dụng tới một hàm trung gian là hàm so sánh

#include 
#include 

/*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))

/*Tạo hàm in phần tử trong mảng*/
void show_array(int array[], int length){
  for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
  printf("\n");
}

/*Tạo hàm so sánh tăng dần sử dụng trong hàm qsort*/
int compareIntAsc(const void* a, const void* b){
    int aNum = *(int*)a;
    int bNum = *(int*)b;

    return aNum - bNum;
}


int main(void){
    int array1[] = {5, 4, 7, 2, 8, 7, 3};
    int array2[] = {99, 4, 5, 2, 80, 7, 3};

    /*Sử dụng hàm qsort để sắp xếp mảng tăng dần*/
    qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntAsc);
    qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntAsc);

    /*Xem kết quả sắp xếp mảng*/
    show_array(array1, SIZE_OF_ARRAY(array1));
    show_array(array2, SIZE_OF_ARRAY(array2));

    return 0;
}

4 giúp tìm ra quan hệ lớn nhỏ giữa hai phần tử.

Trong trường hợp sắp xếp mảng tăng dần trong C thì chúng ta sẽ định nghĩa hàm so sánh này như sau:

Copy

int compareIntAsc(const void* a, const void* b){
    int aNum = *(int*)a;
    int bNum = *(int*)b;

    return aNum - bNum;
}

Và chúng ta sử dụng hàm qsort để viết chương trình sắp xếp phần tử trong mảng C theo thứ tự tăng dần như sau:

Copy

#include 
#include 

/*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))

/*Tạo hàm in phần tử trong mảng*/
void show_array(int array[], int length){
  for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
  printf("\n");
}

/*Tạo hàm so sánh tăng dần sử dụng trong hàm qsort*/
int compareIntAsc(const void* a, const void* b){
    int aNum = *(int*)a;
    int bNum = *(int*)b;

    return aNum - bNum;
}


int main(void){
    int array1[] = {5, 4, 7, 2, 8, 7, 3};
    int array2[] = {99, 4, 5, 2, 80, 7, 3};

    /*Sử dụng hàm qsort để sắp xếp mảng tăng dần*/
    qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntAsc);
    qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntAsc);

    /*Xem kết quả sắp xếp mảng*/
    show_array(array1, SIZE_OF_ARRAY(array1));
    show_array(array2, SIZE_OF_ARRAY(array2));

    return 0;
}

Kết quả của phép sắp xếp mảng tăng dần trong C như dưới đây. Bạn hãy thử chạy chương trình và kiểm tra nhé.

Copy

2 3 4 5 7 7 8 
2 3 4 5 7 80 99 

Sắp xếp mảng giảm dần trong C bằng hàm qsort

Như ở phần trên Kiyoshi đã giải thích, thì việc sắp xếp tăng dần hay giảm dần mảng trong C bằng hàm qsort() sẽ phụ thuộc vào hàm so sánh sử dụng trong hàm này.

Do đó, để sắp xếp phần tử trong mảng C theo thứ tự giảm dần dần bằng hàm qsort, chúng ta đơn giản chỉ cần thay đổi hàm so sánh như dưới đây là xong:

Copy

int compareIntDesc(const void* a, const void* b){
    int aNum = *(int*)a;
    int bNum = *(int*)b;

    return bNum - aNum;
}

Sự khác biệt giữa 2 hàm so sánh này là ở giá trị mà nó trả về. Với hàm compareIntAsc() ở sắp xếp tăng dần thì chúng ta trả về

#include 
#include 

/*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))

/*Tạo hàm in phần tử trong mảng*/
void show_array(int array[], int length){
  for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
  printf("\n");
}

/*Tạo hàm so sánh tăng dần sử dụng trong hàm qsort*/
int compareIntAsc(const void* a, const void* b){
    int aNum = *(int*)a;
    int bNum = *(int*)b;

    return aNum - bNum;
}


int main(void){
    int array1[] = {5, 4, 7, 2, 8, 7, 3};
    int array2[] = {99, 4, 5, 2, 80, 7, 3};

    /*Sử dụng hàm qsort để sắp xếp mảng tăng dần*/
    qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntAsc);
    qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntAsc);

    /*Xem kết quả sắp xếp mảng*/
    show_array(array1, SIZE_OF_ARRAY(array1));
    show_array(array2, SIZE_OF_ARRAY(array2));

    return 0;
}

6, và với hàm compareIntDesc() ở sắp xếp giảm dần thì chúng ta trả về giá trị ngược lại là

#include 
#include 

/*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))

/*Tạo hàm in phần tử trong mảng*/
void show_array(int array[], int length){
  for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
  printf("\n");
}

/*Tạo hàm so sánh tăng dần sử dụng trong hàm qsort*/
int compareIntAsc(const void* a, const void* b){
    int aNum = *(int*)a;
    int bNum = *(int*)b;

    return aNum - bNum;
}


int main(void){
    int array1[] = {5, 4, 7, 2, 8, 7, 3};
    int array2[] = {99, 4, 5, 2, 80, 7, 3};

    /*Sử dụng hàm qsort để sắp xếp mảng tăng dần*/
    qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntAsc);
    qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntAsc);

    /*Xem kết quả sắp xếp mảng*/
    show_array(array1, SIZE_OF_ARRAY(array1));
    show_array(array2, SIZE_OF_ARRAY(array2));

    return 0;
}

7.

Và chúng ta sử dụng hàm qsort để viết chương trình sắp xếp phần tử trong mảng C theo thứ tự giảm dần như sau:

Copy

#include 
#include 

/*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))

/*Tạo hàm in phần tử trong mảng*/
void show_array(int array[], int length){
  for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
  printf("\n");
}

/*Tạo hàm so sánh giảm dần sử dụng trong hàm qsort*/
int compareIntDesc(const void* a, const void* b){
    int aNum = *(int*)a;
    int bNum = *(int*)b;

    return bNum - aNum;
}

int main(void){
    int array1[] = {5, 4, 7, 2, 8, 7, 3};
    int array2[] = {99, 4, 5, 2, 80, 7, 3};

    /*Sử dụng hàm qsort để sắp xếp mảng giảm dần*/
    qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntDesc);
    qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntDesc);

    /*Xem kết quả sắp xếp mảng*/
    show_array(array1, SIZE_OF_ARRAY(array1));
    show_array(array2, SIZE_OF_ARRAY(array2));

    return 0;
}

Kết quả của phép sắp xếp mảng giảm dần trong C như dưới đây. Bạn hãy thử chạy chương trình và kiểm tra nhé.

Copy

8 7 7 5 4 3 2 
99 80 7 5 4 3 2 

Sắp xếp mảng trong C bằng hàm tự tạo

Chúng ta nên sử dụng hàm qsort() ở trên trong các dự án thực tế khi cần sắp xếp mảng trong C. Tuy nhiên nếu bạn muốn luyện tập viết code C, cũng như muốn hiểu rõ hơn về cách sắp xếp trong C như thế nào, thì hãy thử tự tạo các hàm sắp xếp mảng tăng dần và giảm dần trong C ở phần dưới đây.

Logic sắp xếp mảng

Ví dụ chúng ta có mảng int như sau:

Copy

int array[] = {4, 1, 0, 2, 3};

Để sắp xếp mảng này tăng dần trong C, chúng ta sử dụng ý tưởng rất đơn giản. Chúng ta xét số đầu tiên của mảng và so sánh lần lượt với các số còn lại từ vị trí số đó tới cuối mảng. Nếu tìm thấy số đầu tiên nhỏ hơn số đang xét thì sẽ hoán đổi vị trí của 2 số này với nhau, rồi tiếp tục lặp cho tới khi không còn số nào nhỏ hơn số đang xét nữa, thì chuyển sang xét ở số thứ 2 trong mảng. Cứ như thế cho tới khi tất cả các số đều được xét.

Với mảng ở trên thì chúng ta sẽ hoán đổi lần lượt như sau:

1. So sánh số đầu tiên là số 4 lần lượt với các số còn lại. Số 1 là số đầu tiên nhỏ hơn 4 nên hoán đổi vị trí 4 với 1. Lúc này, 1 trở thành số đầu tiên trong mảng.

2. So sánh 1 lần lượt với các số còn lại. Số 0 là số đầu tiên nhỏ hơn 1 nên hoán đổi vị trí 4 với 1. Lúc này, 0 trở thành số đầu tiên trong mảng.

3. So sánh 0 lần lượt với các số còn lại. Do không còn số nào nhỏ hơn 0 nữa, nên kết thúc xét số đầu tiên và chuyển sang xét số thứ 2 trong mảng, lúc này là số 4.

4. Lặp lại qúa trình xét ở trên cho tới số cuối cùng trong mảng.

Cuối cùng, kết quả chúng ta thu về mảng kết quả là {0, 1, 2, 3, 4}.

Với sắp xếp mảng giảm dần trong C, chúng ta cũng sử dụng logic tương tự. Tuy nhiên thay vì tìm số đầu tiên nhỏ hơn số đang xét, thì chúng ta sẽ làm ngược lại là tìm số đầu tiên lớn hơn số đang xét mà thôi.

Logic hoán đổi phần tử

Để có thể hoán đổi 2 phần tử như trên, chúng ta cần phải chuẩn bị một vùng tạm thời để chứa một trong 2 phần tử, và hoán đổi với logic temp = X; X = Y; Y = temp;

Và để thực hiện được logic hoán đổi 2 số ở trên, chúng ta sẽ sử dụng từ khoá define để tạo một macro dùng để hoán đổi phần tử, mà Kiyoshi đã hướng dẫn trong Đảo ngược mảng trong C như sau:

Copy

#define SWAP(type,x,y) do{type tmp = x; x = y; y = tmp;}while(0)

Sắp xếp mảng trong C bằng hàm tự tạo

Ứng dụng các kiến thức trên, chúng ta sẽ viết hàm sắp xếp mảng tăng dần trong C và hàm sắp xếp mảng giảm dần trong C như sau:

Copy

// Tạo hàm sắp xếp mảng tăng dần trong C
void asc_order(int array[], int n){
    //Tạo vòng lặp để sắp xếp mảng
    for(int i = 0; i < n - 1; i++){
        for(int j = i + 1; j < n; j++){
            //Nếu tìm ra số nhỏ hơn đầu tiên thì hoán đổi với số đang xét
            if(array[i] > array[j]) SWAP(int,array[i],array[j]);   
        }
    }
}

// Tạo hàm sắp xếp mảng giảm dần trong C
void desc_order(int * array,int n){
    //Tạo vòng lặp để sắp xếp mảng
    for(int i = 0; i < n - 1; i++){
        for(int j = i + 1; j < n; j++){
            //Nếu tìm ra số lớn hơn đầu tiên thì hoán đổi với số đang xét
            if(array[i] < array[j]) SWAP(int,array[i],array[j]);   
        }
    }
}

Và chúng ta viết chương trình nhập một mảng và sắp xếp phần tử trong mảng C như sau:

Copy

#include 

/*Định nghĩa macro SWAP để hoán đổi phần tử trong mảng chỉ định*/
#define SWAP(type,x,y) do{type tmp = x; x = y; y = tmp;}while(0)

/*Tạo hàm in phần tử trong mảng*/
void show_array(int array[], int length){
  for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
  printf("\n");
}

// Tạo hàm sắp xếp mảng tăng dần trong C
void asc_order(int array[], int n){
    //Tạo vòng lặp để sắp xếp mảng
    for(int i = 0; i < n - 1; i++){
        for(int j = i + 1; j < n; j++){
            //Nếu tìm ra số nhỏ hơn đầu tiên thì hoán đổi với số đang xét
            if(array[i] > array[j]) SWAP(int,array[i],array[j]);   
        }
    }
}

// Tạo hàm sắp xếp mảng giảm dần trong C
void desc_order(int * array,int n){
    //Tạo vòng lặp để sắp xếp mảng
    for(int i = 0; i < n - 1; i++){
        for(int j = i + 1; j < n; j++){
            //Nếu tìm ra số lớn hơn đầu tiên thì hoán đổi với số đang xét
            if(array[i] < array[j]) SWAP(int,array[i],array[j]);   
        }
    }
}
  
int main(void){
    int array[100], n;
    printf(">>Nhap so phan tu: ");
    scanf("%d", &n);
 
    printf(">>Nhap phan tu:\n");
    for (int i = 0; i < n; i++) scanf("%d", &array[i]);

    //sắp xếp mảng tăng dần trong C
    asc_order(array,n);
   
    /*Xem kết quả sắp xếp mảng*/
    show_array(array, n);

    //sắp xếp mảng giảm dần trong C
    desc_order(array,n);

    /*Xem kết quả sắp xếp mảng*/
    show_array(array, n);
     
     return 0;
}

Kết quả của phép sắp xếp mảng trong C bằng hàm tự tạo sẽ như dưới đây. Bạn hãy thử chạy chương trình và kiểm tra nhé.

Copy

#include 
#include 

/*Định nghĩa macro SIZE_OF_ARRAY để lấy độ dài (số phần tử) trong mảng chỉ định*/
#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))

/*Tạo hàm in phần tử trong mảng*/
void show_array(int array[], int length){
  for(short i = 0; i < length; i++)  printf("%d ", array[i]);  
  printf("\n");
}

/*Tạo hàm so sánh tăng dần sử dụng trong hàm qsort*/
int compareIntAsc(const void* a, const void* b){
    int aNum = *(int*)a;
    int bNum = *(int*)b;

    return aNum - bNum;
}


int main(void){
    int array1[] = {5, 4, 7, 2, 8, 7, 3};
    int array2[] = {99, 4, 5, 2, 80, 7, 3};

    /*Sử dụng hàm qsort để sắp xếp mảng tăng dần*/
    qsort(array1, SIZE_OF_ARRAY(array1), sizeof(int), compareIntAsc);
    qsort(array2, SIZE_OF_ARRAY(array2), sizeof(int), compareIntAsc);

    /*Xem kết quả sắp xếp mảng*/
    show_array(array1, SIZE_OF_ARRAY(array1));
    show_array(array2, SIZE_OF_ARRAY(array2));

    return 0;
}

0

Tổng kết

Trên đây Kiyoshi đã hướng dẫn bạn cách sắp xếp mảng trong C rồi. Để nắm rõ nội dung bài học hơn, bạn hãy thực hành viết lại các ví dụ của ngày hôm nay nhé.

Và hãy cùng tìm hiểu những kiến thức sâu hơn về C trong các bài học tiếp theo.

URL Link

https://laptrinhcanban.com/c/lap-trinh-c-co-ban/mang-trong-c/sap-xep-mang-trong-c/

Viết bởi Kiyoshi. Đã đăng ký bản quyền tác giả tại Creativecommons và DMCA

Bài viết liên quan

• Đảo ngược mảng trong C

• Con trỏ mảng 2 chiều trong c

• Lấy kích thước, độ dài và số phần tử trong mảng 2 chiều

• Độ dài mảng trong C

• Kiểm tra và lấy phần tử trùng trong mảng C

• Ghép nối mảng trong C

• Lấy kích thước mảng trong C

• Mảng 1 chiều trong c

Hãy chia sẻ và cùng lan tỏa kiến thức lập trình Nhật Bản tại Việt Nam!

HOME  › lập trình c cơ bản dành cho người mới học lập trình>>14. mảng trong c

Bài sau

Tìm số đảo ngược trong C

Bài tiếp

Tìm max và min trong mảng C

• Bài viết mới nhất

• Tách chuỗi trong PHP (explode, preg_split) tháng 9 17, 2022

• Cắt chuỗi trong PHP (substr, mb_substr) tháng 9 17, 2022

• Tách chuỗi thành mảng trong PHP (explode) tháng 9 17, 2022

• Tìm kiếm chuỗi trong PHP (strpos) tháng 9 17, 2022

• Đếm số lần xuất hiện của ký tự và chuỗi trong chuỗi PHP (substr_count) tháng 9 17, 2022

• Tách từng ký tự trong chuỗi PHP (substr, preg_split) tháng 9 17, 2022

• Chuyển chuỗi thành mảng trong PHP (str_split, mb_str_split) tháng 9 17, 2022

• Xóa ký tự trong chuỗi PHP tháng 9 15, 2022

---

Profile

Tác giả : Kiyoshi (Chis Thanh)

Kiyoshi là một cựu du học sinh tại Nhật Bản. Sau khi tốt nghiệp đại học Toyama năm 2017, Kiyoshi hiện đang làm BrSE tại Tokyo, Nhật Bản.