Sắp xếp mảng C++

Thuật toán tiêu chuẩn là sử dụng các con trỏ tới điểm bắt đầu/kết thúc và đưa chúng vào trong cho đến khi chúng gặp nhau hoặc giao nhau ở giữa. Trao đổi khi bạn đi

Nội dung chính Show

hoạt động
Chương trình
Vui lòng Đăng nhập để nhận xét.
Cách nhanh nhất để sắp xếp một mảng trong C là gì?
Làm cách nào để sắp xếp lại một mảng trong C?
Có chức năng sắp xếp trong C không?
Làm cách nào để sắp xếp chuỗi mảng trong C?

Đảo ngược chuỗi ASCII, tôi. e. một mảng 0-kết thúc trong đó mỗi ký tự phù hợp với 1 ký tự. (Hoặc các bộ ký tự không nhiều byte khác)

voidstrrev(char *head)
{
if (!head) return;
char *tail = head;
while(*tail) ++tail;    // find the 0 terminator, like head+strlen
  --tail;               // tail points to the last real char
// head still points to the first
for( ; head < tail; ++head, --tail) {
// walk pointers inwards until they meet or cross in the middle
char h = *head, t = *tail;
      *head = t;           // swapping as we go
      *tail = h;
  }
}
// test program that reverses its args
#include

intmain(int argc, char **argv)
{
do {
printf("%s ",  argv[argc-1]);
strrev(argv[argc-1]);
printf("%s\n", argv[argc-1]);
  } while(--argc);

return0;
}

Thuật toán tương tự hoạt động với các mảng số nguyên có độ dài đã biết, chỉ cần sử dụng tail = start + length - 1 thay vì vòng lặp tìm kết thúc

Mảng là một nhóm các mục dữ liệu có liên quan được lưu trữ với một tên duy nhất

Ví dụ, int sinh viên[30];

Ở đây, sinh viên là một tên mảng chứa 30 tập hợp các mục dữ liệu, với một tên biến duy nhất

hoạt động

Các hoạt động của một mảng được giải thích dưới đây -

Tìm kiếm - Nó được sử dụng để tìm xem một phần tử cụ thể có hiện diện hay không
Sắp xếp - Giúp sắp xếp các phần tử trong một mảng theo thứ tự tăng dần hoặc giảm dần
Traversing - Xử lý mọi phần tử trong một mảng, tuần tự
Chèn - Giúp chèn các phần tử trong một mảng
Xóa - Giúp xóa một phần tử trong một mảng

Trong chương trình này, chúng tôi đang sử dụng kỹ thuật hoán đổi để sắp xếp các phần tử theo thứ tự tăng dần

Logic mà chúng ta đã áp dụng để sắp xếp một mảng theo thứ tự tăng dần như sau -

for(i=0;i<10-1;i++){
   for(j=i+1;j<10;j++){
      if(element[i]>element[j]){
         temp=element[i]; //swapping element[i] with element[j]
         element[i]=element[j];
         element[j]=temp;
      }
   }
}

Chương trình

Đưa ra dưới đây là chương trình C để sắp xếp một mảng gồm mười phần tử theo thứ tự tăng dần -

Bản thử trực tiếp

#include
int main(){
   int element[10],i,j,temp;
   printf("enter 10 integer numbers:");
   for(i=0;i<10;i++){
      scanf("%d",&element[i]);
   }
   for(i=0;i<10-1;i++){
      for(j=i+1;j<10;j++){
         if(element[i]>element[j]){
            temp=element[i]; //swapping element[i] with element[j]
            element[i]=element[j];
            element[j]=temp;
         }
      }
   }
   printf("Elements are now in ascending order:");
   for(i=0;i<10;i++)
      printf("%d
",element[i]);
   return 0;
}

đầu ra

Đầu ra được đưa ra dưới đây -

enter 10 integer numbers:
12
23
34
1
22
34
56
45
33
78
Elements are now in ascending order:1
12
22
23
33
34
34
45
56
78

Chương trình này sẽ cài đặt một mảng một chiều có kích thước cố định, chứa một số số ngẫu nhiên, sau đó sẽ sắp xếp tất cả các phần tử đã điền của mảng

Giải pháp vấn đề

1. Tạo một mảng có kích thước cố định (dung lượng tối đa), giả sử 10.
2. Lấy n, một biến lưu số lượng phần tử của mảng, nhỏ hơn dung lượng tối đa của mảng.
3. Lặp qua vòng lặp for để lấy các phần tử mảng làm đầu vào và in chúng.
4. Các phần tử của mảng chưa được sắp xếp, để sắp xếp chúng, hãy tạo một vòng lặp lồng nhau.
5. Trong vòng lặp lồng nhau, mỗi phần tử sẽ được so sánh với tất cả các phần tử bên dưới nó.
6. Trường hợp phần tử lớn hơn phần tử đứng bên dưới thì đổi chỗ cho nhau
7. Sau khi thực hiện xong vòng lặp lồng nhau ta sẽ thu được một mảng được sắp xếp các phần tử theo thứ tự tăng dần.

Chương trình/Mã nguồn

Đây là mã nguồn của chương trình C để sắp xếp mảng theo thứ tự tăng dần. Chương trình được biên dịch và thử nghiệm thành công bằng trình biên dịch Turbo C trong môi trường windows. Đầu ra chương trình cũng được hiển thị bên dưới

Chương trình C để sắp xếp một mảng theo thứ tự tăng dần

Cải thiện bài viết

Lưu bài viết

Thích bài viết

Độ khó. Dễ dàng
Cập nhật lần cuối. 31 tháng 5 năm 2021

Đọc

Bàn luận

khóa học

Luyện tập

Băng hình

Cải thiện bài viết

Lưu bài viết

Cho một mảng arr[] có kích thước N, nhiệm vụ là sắp xếp mảng này theo thứ tự tăng dần trong C.
Ví dụ.

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Khuyến khích. Vui lòng thử cách tiếp cận của bạn trên {IDE} trước, trước khi chuyển sang giải pháp

Cách tiếp cận.
Có nhiều cách để sắp xếp mảng theo thứ tự tăng dần, chẳng hạn như.

Sắp xếp lựa chọn
Sắp xếp bong bóng
Hợp nhất Sắp xếp
Sắp xếp cơ số
Sắp xếp chèn, v.v.

Để đơn giản, chúng ta sẽ sử dụng Sắp xếp lựa chọn trong bài viết này.
Mảng có thể được sắp xếp theo thứ tự tăng dần bằng cách liên tục tìm phần tử nhỏ nhất (xét theo thứ tự tăng dần) từ phần chưa sắp xếp và đặt nó ở đầu. Thuật toán duy trì hai mảng con trong một mảng nhất định.

Mảng con đã được sắp xếp
Mảng con còn lại chưa được sắp xếp

Trong mỗi lần lặp lại của sắp xếp lựa chọn, phần tử nhỏ nhất (xét theo thứ tự tăng dần) từ mảng con chưa sắp xếp được chọn và chuyển sang mảng con đã sắp xếp.
Dưới đây là cách triển khai của phương pháp trên.

C

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____48

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____56

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____58

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____48

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

_______52____442

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____444

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

________ 453 ________ 454 ________ 455

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

56____457

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____59

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

69____48

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____48

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____444

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

_______446____482____483

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2______482____483

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____48

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2______48

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

81____482

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2______482____483

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

_______52____502

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____504

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2______482____483

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Input: arr[] = {0, 23, 14, 12, 9}
Output: {0, 9, 12, 14, 23}

Input: arr[] = {7, 0, 2}
Output: {0, 2, 7}

_______52____502

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

2____513

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

đầu ra.

Original array: 
0 23 14 12 9 

Sorted array in Ascending order: 
0 9 12 14 23

Thời gian phức tạp. O(N2)

Không gian phụ trợ. Ô(1)

Ghi chú cá nhân của tôi arrow_drop_up

Tiết kiệm

Vui lòng Đăng nhập để nhận xét.

Cách nhanh nhất để sắp xếp một mảng trong C là gì?

Sắp xếp hợp nhất có thể là cách tốt nhất vì nó quản lý độ phức tạp về không gian và thời gian tốt hơn theo thuật toán Big-O (Điều này phù hợp hơn với mảng lớn).

Làm cách nào để sắp xếp lại một mảng trong C?

Sắp xếp lại một mảng sao cho arr[i] = i

Sắp xếp lại mảng sao cho mảng[i] >= mảng[j] nếu tôi chẵn và mảng[i]<=arr[j] nếu tôi lẻ và j < i

Sắp xếp lại mảng trong các mục dương và âm xen kẽ với khoảng trắng thừa O(1). Hiệp 1

Di chuyển tất cả các số không đến cuối mảng

Có chức năng sắp xếp trong C không?

Thư viện C chuẩn cung cấp hàm qsort có thể dùng để sắp xếp mảng . Sau đây là nguyên mẫu của hàm qsort(). // Sắp xếp một mảng có kiểu bất kỳ.

Làm cách nào để sắp xếp chuỗi mảng trong C?

Cho một mảng các chuỗi trong đó tất cả các ký tự đều giống nhau, hãy viết một hàm C để sắp xếp chúng theo thứ tự bảng chữ cái. Ý tưởng là sử dụng qsort() trong C và viết hàm so sánh sử dụng strcmp() để so sánh hai chuỗi .

programming c++

Sắp xếp mảng C++

hoạt động

Chương trình

đầu ra

C

Vui lòng Đăng nhập để nhận xét.

Cách nhanh nhất để sắp xếp một mảng trong C là gì?

Làm cách nào để sắp xếp lại một mảng trong C?

Có chức năng sắp xếp trong C không?

Làm cách nào để sắp xếp chuỗi mảng trong C?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội