Viết chương trình c++ để tìm k phần tử lớn nhất trong một mảng các số nguyên đã cho

Bài viết này sẽ dạy chúng ta tìm phần tử lớn thứ k trong một mảng chưa sắp xếp. Có nhiều cách khác nhau để tìm lời giải cho bài toán đã cho. Các thực hành tốt nhất có thể được thảo luận dưới đây

Nội dung chính Show

Trong Python
Cách tiếp cận 3 - Sử dụng Max-Heap
Cách tiếp cận 4 - Sử dụng Min Heap
Cách tiếp cận 5 - Sắp xếp nhanh từng phần
Làm cách nào để tìm phần tử lớn nhất trong một mảng trong C?
Làm cách nào để tìm phần tử lớn thứ k trong một mảng trong C?
Làm cách nào để tìm số lớn thứ k trong một mảng mà không cần sắp xếp?
Mảng lớn nhất trong C là gì?

Bài toán - Xét một mảng chưa sắp xếp có N phần tử. Một số k nhỏ hơn kích thước của mảng được đưa ra;

Ví dụ

Cách tiếp cận 1. Phương pháp đơn giản nhất mà tôi nghĩ đến là sắp xếp mảng đã cho và trả về giá trị được yêu cầu. Chúng ta có thể tìm ra giải pháp trong thời gian O(N Log N) bằng cách sử dụng Sắp xếp đống hoặc Sắp xếp hợp nhất

Giả sử mảng không có phần tử giống nhau

Trong C++

Đầu ra mẫu

The 3th largest element = 15

trong C

Đầu ra mẫu

The 4th largest element = 12

Trong Python

Đầu ra mẫu

The 5th largest element = 8

mã C++

Đầu ra mẫu

My set = {2, 4, 5, 10, 12, 18, 22, 36, 54}
The 3th largest element = 22

Mã Python

đầu ra

My set = {8, 9, 10, 12, 15, 17, 22, 26, 27, 28, 29}
The 5th largest element = 22

Cách tiếp cận 3 - Sử dụng Max-Heap

Phần tử lớn thứ k có thể được tìm thấy với sự trợ giúp của heap. Ở đây, chúng tôi đã sử dụng heap tối đa; . Chúng tôi làm theo các bước tương tự k-1 lần. Sau đó, phần tử thứ k được tìm thấy tại gốc chỉ số = 0

Mã C++

đầu ra

The 2th largest element = 16

Mã C

đầu ra

The 3th largest element = 12

Cách tiếp cận 4 - Sử dụng Min Heap

Trong phương pháp này, chúng ta tạo một heap tối thiểu với k số phần tử và giá trị nhỏ nhất của nó (phần tử gốc) sẽ là giá trị lớn thứ k. Nếu mảng có nhiều hơn k phần tử thì ta kiểm tra từng phần tử xem có lớn hơn phần tử gốc của heap hay không, các phần tử còn lại ta làm theo các bước sau

Nếu phần tử sẽ nhỏ hơn gốc nghĩa là giá trị lớn thứ k vẫn là phần tử gốc và ta kiểm tra điều kiện cho phần tử tiếp theo
Nếu phần tử lớn hơn gốc có nghĩa là phần tử gốc không phải là giá trị lớn thứ k và chúng tôi thay thế gốc bằng phần tử và gọi min-heapify tại chỉ mục gốc
Khi kết thúc thực thi, chúng tôi sẽ trả về phần tử gốc, đây sẽ là giá trị lớn thứ k

Độ phức tạp về thời gian của phương pháp này là T(n) = klogk + (n-k)logk

Và độ phức tạp không gian = O(k)

mã C++

đầu ra

My array = {12, 15, 17, 23, 9, 16, 7, 45, 6, 42, 33}
The 5th largest value = 17

mã C

đầu ra

________số 8

Cách tiếp cận 5 - Sắp xếp nhanh từng phần

Trong cách tiếp cận này, chúng tôi sử dụng ý tưởng sắp xếp nhanh để tìm phần tử lớn thứ k trong mảng. Như chúng ta đã biết, sắp xếp nhanh chọn một phần tử trục, đặt nó vào đúng chỉ mục của nó và lặp lại đệ quy quy trình tương tự cho đến khi mảng được sắp xếp. Tương tự, ta thực hiện các bước tương tự nhưng không thực hiện đầy đủ thao tác sắp xếp nhanh. Khi trục chính là giá trị lớn thứ k, chúng tôi sẽ dừng thực thi và in giá trị cần thiết. Độ phức tạp thời gian tồi tệ nhất của phương pháp này là O(n^2) và độ phức tạp thời gian trung bình là O(N logN). Chúng tôi đạt được kết quả mong muốn trong thời gian ngắn hơn so với mức độ phức tạp trung bình của trường hợp

Mảng là một cấu trúc dữ liệu chứa một tập hợp các giá trị hoặc biến. Kiểu mảng đơn giản nhất là mảng tuyến tính hoặc mảng một chiều. Một mảng có thể được định nghĩa trong C với cú pháp sau

int Arr[5] = {12, 56, 34, 78, 100};
/* ở đây 12,56,34,78,100 là các phần tử tại chỉ số 0,1

Trong ví dụ này, mảng Arr là tập hợp của 5 số nguyên. Mỗi số nguyên có thể được xác định và truy cập bởi chỉ số của nó. Các chỉ số của mảng bắt đầu bằng 0, vì vậy phần tử đầu tiên của mảng sẽ có chỉ số 0, tiếp theo sẽ có chỉ số 1, v.v.

Phần tử lớn nhất của mảng là phần tử của mảng có giá trị bằng số lớn nhất trong tất cả các phần tử của mảng

ví dụ

Nếu chúng ta đang nhập 5 phần tử (N = 5), với các giá trị phần tử mảng là 12, 56, 34, 78 và 100
Khi đó, phần tử lớn nhất có trong mảng đã cho là. 100

Theo dõi ngay. Bản tin chương trình C. Chủ đề quan trọng Bản tin

quảng cáo

Nếu chúng ta đang nhập 4 phần tử (N = 4), với các giá trị phần tử mảng là 1, 6, 3 và 2
Khi đó, phần tử lớn nhất có trong mảng đã cho là. 6

Mô tả vấn đề

Viết chương trình C tìm phần tử lớn nhất trong mảng đã cho

Giải pháp vấn đề

Trong chương trình này, chúng ta phải tìm phần tử lớn nhất có trong mảng. Chúng tôi sẽ làm điều này bằng cách trước tiên lưu giá trị của phần tử đầu tiên trong biến 'lớn nhất'. Sau đó ta sẽ so sánh với các phần tử còn lại của mảng và lưu trữ giá trị nếu tìm thấy số khác lớn hơn trong mảng này. Điều này sẽ diễn ra N-1 lần và chương trình kết thúc

Trình tự các bước cho giải pháp sẽ như sau.
1. Tạo một mảng có kích thước do người dùng xác định.
2. Chạy vòng lặp for cho đến kích thước do người dùng xác định để chèn phần tử vào từng vị trí.
3. Coi phần tử đầu tiên của mảng là lớn nhất, so sánh tất cả các phần tử còn lại của mảng và thay đổi giá trị lớn nhất nếu phần tử lớn nhất được giả định nhỏ hơn phần tử được so sánh.
4. Cuối cùng, phần tử lớn nhất sẽ giữ giá trị thực lớn nhất trong mảng. Vì vậy, in nó.

Nhận Bằng khen Lập trình C miễn phí ngay

Có một số cách tìm phần tử lớn nhất của mảng trong ngôn ngữ C. Hãy xem xét chi tiết tất cả các cách tiếp cận để tìm phần tử lớn nhất của một mảng

Phương pháp 1. Phần tử lớn nhất của một mảng trong C sử dụng Vòng lặp (Cách tiếp cận ngây thơ)

Theo cách tiếp cận này, lúc đầu, chúng tôi giả định rằng phần tử đầu tiên là phần tử lớn nhất. Sau đó, chúng tôi duyệt qua mảng và nếu phần tử hiện tại lớn hơn phần tử lớn nhất, chúng tôi sẽ cập nhật phần tử lớn nhất

Ví dụ

Mảng đã cho. [1,2,4,1,6,4]

quảng cáo

Ban đầu, phần tử lớn nhất. 1

Bây giờ chúng ta bắt đầu duyệt mảng

Chỉ mục. 1
Phần tử chỉ mục > Phần tử lớn nhất, vì vậy hãy cập nhật phần tử lớn nhất bằng 2.

Chỉ mục. 2
Phần tử chỉ mục > Phần tử lớn nhất, vì vậy hãy cập nhật phần tử lớn nhất bằng 4.

Chỉ mục. 3
Phần tử chỉ mục < Phần tử lớn nhất nên phần tử lớn nhất không đổi.

quảng cáo

Chỉ mục. 4
Phần tử chỉ mục > Phần tử lớn nhất, vì vậy hãy cập nhật phần tử lớn nhất bằng 6.

Chỉ mục. 5
Phần tử chỉ mục < Phần tử lớn nhất nên phần tử lớn nhất không đổi.

Vậy Phần Tử Lớn Nhất là 6

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

Đây là mã nguồn của Chương trình C tìm số lớn nhất trong mảng bằng vòng lặp. 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

```
/*
```
```
The 4th largest element = 12
```
0
```
The 4th largest element = 12
```
1
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
3
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
5
```
The 4th largest element = 12
```
6
```
The 4th largest element = 12
```
7
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
00
```
The 4th largest element = 12
```
01
```
The 4th largest element = 12
```
02
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
04
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
06
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
08
```
The 4th largest element = 12
```
09
```
The 4th largest element = 12
```
10
```
The 4th largest element = 12
```
11
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
13
```
The 4th largest element = 12
```
14
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
16
```
The 4th largest element = 12
```
17
```
The 4th largest element = 12
```
18
```
The 4th largest element = 12
```
19
```
The 4th largest element = 12
```
11
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
22
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
24
```
The 4th largest element = 12
```
25

Giải thích chương trình

1. Lấy kích thước của mảng làm đầu vào từ người dùng.
2. Sau đó, khởi tạo một mảng có kích thước do người dùng đưa ra.
3. Sử dụng vòng lặp for, lấy phần tử mảng làm đầu vào từ người dùng và chèn chúng vào mảng.
4. Sau khi chèn tất cả các phần tử của mảng, coi phần tử đầu tiên của mảng là phần tử lớn nhất.
5. Chạy vòng lặp for, từ 1 đến arraySize-1, trích xuất từng phần tử mảng và so sánh nó với phần tử lớn nhất.
6. Nếu phần tử lớn nhất nhỏ hơn phần tử được so sánh, thì phần tử lớn nhất được cập nhật với giá trị của phần tử hiện tại của mảng.
7. Cuối cùng, phần tử lớn nhất sẽ giữ giá trị lớn nhất thực tế có trong mảng.

Độ phức tạp về thời gian. O(n)
Trong chương trình ta duyệt mảng nên độ phức tạp về thời gian là O(n).

Độ phức tạp của không gian. O(n)
Cần có không gian để lưu trữ mảng, vì vậy độ phức tạp của không gian là O(n).

Các trường hợp kiểm tra thời gian chạy

Đây là đầu ra thời gian chạy của chương trình C nơi người dùng đang đọc mảng gồm 6 phần tử với các giá trị là 1, 2, 4, 1, 6 và 4. Sau đó, nó tìm ra phần tử lớn nhất và hiển thị giá trị của nó

The 4th largest element = 12

Phương pháp 2. Phần tử lớn nhất của một mảng trong C sử dụng đệ quy

Trong cách tiếp cận đệ quy, hàm đệ quy trả về giá trị lớn nhất của phần tử hiện tại và phần còn lại của các phần tử với trường hợp cơ sở sẽ dừng khi mảng được duyệt qua

Ví dụ

Mảng. [7,2,4,1,5]

The 4th largest element = 12

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

Đây là mã nguồn của Chương trình C tìm số lớn nhất trong mảng bằng đệ quy. 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

```
/*
```
```
The 4th largest element = 12
```
29
```
The 4th largest element = 12
```
1
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
3
```
The 4th largest element = 12
```
33
```
The 4th largest element = 12
```
34
```
The 4th largest element = 12
```
35
```
The 4th largest element = 12
```
6
```
The 4th largest element = 12
```
37
```
The 4th largest element = 12
```
38
```
The 4th largest element = 12
```
39
```
The 4th largest element = 12
```
20
```
The 4th largest element = 12
```
21
```
The 4th largest element = 12
```
22
```
The 4th largest element = 12
```
6
```
The 4th largest element = 12
```
24
```
The 4th largest element = 12
```
25
```
The 4th largest element = 12
```
26
```
The 4th largest element = 12
```
21
```
The 4th largest element = 12
```
5
```
The 4th largest element = 12
```
6
```
The 4th largest element = 12
```
50
```
The 4th largest element = 12
```
51
```
The 4th largest element = 12
```
52
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
54
```
The 4th largest element = 12
```
55
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
04
```
The 4th largest element = 12
```
58
```
The 4th largest element = 12
```
59
```
The 4th largest element = 12
```
60
```
The 4th largest element = 12
```
61
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
24
```
The 4th largest element = 12
```
21

Giải thích chương trình

1. Lấy kích thước của mảng làm đầu vào từ người dùng.
2. Sử dụng vòng lặp for, lấy phần tử mảng làm đầu vào từ người dùng và chèn chúng vào mảng.
3. Khai báo một hàm để tìm phần tử lớn nhất của mảng trả về giá trị lớn nhất giữa phần tử hiện tại và tất cả các phần tử khác có điểm dừng cơ sở khi mảng được duyệt qua.
4. In giá trị được hàm trả về là phần tử lớn nhất.

Độ phức tạp về thời gian. O(n)
Vì có n lệnh gọi hàm nên độ phức tạp về thời gian là O(n).

Độ phức tạp của không gian. O(n)
Cần có không gian để lưu trữ mảng, vì vậy độ phức tạp của không gian là O(n).

Các trường hợp kiểm tra thời gian chạy

Đây là đầu ra thời gian chạy của chương trình C nơi người dùng đang đọc mảng gồm 5 phần tử với các giá trị là 7, 2, 4, 1 và 5. Sau đó, nó tìm ra phần tử lớn nhất và hiển thị giá trị của nó

The 4th largest element = 12

Phương pháp 3. Phần tử lớn nhất của mảng trong C sử dụng hàm

Trong cách tiếp cận này, chúng ta khai báo một hàm trong đó chúng ta giả sử rằng phần tử đầu tiên của một mảng là lớn nhất. Sau đó, chúng tôi duyệt qua mảng và nếu phần tử hiện tại lớn hơn phần tử lớn nhất, chúng tôi sẽ cập nhật phần tử lớn nhất. Kết thúc hàm trả về phần tử lớn nhất

Ví dụ

Mảng. [11, 34, 21, 100]

Ban đầu, phần tử lớn nhất. 11

Bây giờ chúng ta bắt đầu duyệt mảng

Chỉ mục. 1
Phần tử chỉ mục > Phần tử lớn nhất, vì vậy hãy cập nhật phần tử lớn nhất bằng 34.

Chỉ mục. 2
Phần tử chỉ mục < Phần tử lớn nhất, vì vậy phần tử lớn nhất vẫn giữ nguyên i. e. 34.

Chỉ mục. 3
Phần tử chỉ mục > Phần tử lớn nhất, vì vậy hãy cập nhật phần tử lớn nhất bằng 100

Vậy Phần Tử Lớn Nhất là 100

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

Đây là mã nguồn của Chương trình C tìm số lớn nhất trong mảng bằng hàm. 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

```
/*
```
```
The 4th largest element = 12
```
67
```
The 4th largest element = 12
```
1
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
3
```
The 4th largest element = 12
```
33
```
The 4th largest element = 12
```
72
```
The 4th largest element = 12
```
6
```
The 4th largest element = 12
```
74
```
The 4th largest element = 12
```
75
```
The 4th largest element = 12
```
76
```
The 4th largest element = 12
```
17
```
The 4th largest element = 12
```
78
```
The 4th largest element = 12
```
79
```
The 4th largest element = 12
```
20
```
The 4th largest element = 12
```
11
```
The 4th largest element = 12
```
22
```
The 4th largest element = 12
```
21
```
The 4th largest element = 12
```
5
```
The 4th largest element = 12
```
6
```
The 4th largest element = 12
```
50
```
The 4th largest element = 12
```
51
```
The 4th largest element = 12
```
52
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
54
```
The 4th largest element = 12
```
55
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
04
```
The 4th largest element = 12
```
58
```
The 4th largest element = 12
```
59
```
The 4th largest element = 12
```
60
```
The 4th largest element = 12
```
007
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
24
```
The 4th largest element = 12
```
21

Giải thích chương trình

1. Lấy kích thước của mảng làm đầu vào từ người dùng.
2. Sử dụng vòng lặp for, lấy phần tử mảng làm đầu vào từ người dùng và chèn chúng vào mảng.
3. Khai báo hàm tìm phần tử lớn nhất.
4. Bên trong hàm, khởi tạo phần tử lớn nhất là phần tử đầu tiên của mảng.
5. Duyệt qua mảng và nếu phần tử hiện tại lớn hơn phần tử lớn nhất, hãy cập nhật phần tử lớn nhất.
6. Trả về và in phần tử lớn nhất.

Độ phức tạp về thời gian. O(n)
Trong chương trình ta duyệt mảng nên độ phức tạp về thời gian là O(n).

Độ phức tạp của không gian. O(n)
Cần có không gian để lưu trữ mảng, vì vậy độ phức tạp của không gian là O(n).

Các trường hợp kiểm tra thời gian chạy

Đây là đầu ra thời gian chạy của chương trình C nơi người dùng đang đọc mảng gồm 4 phần tử với các giá trị là 11, 34, 21 và 100. Sau đó, nó tìm ra phần tử lớn nhất và hiển thị giá trị của nó

The 4th largest element = 12

011

Phương pháp 4. Phần tử lớn nhất của mảng trong C sử dụng con trỏ

Trong cách tiếp cận này, chúng ta tìm phần tử lớn nhất của một mảng bằng cách sử dụng các con trỏ. Chúng tôi khai báo một hàm để tìm phần tử lớn nhất lấy mảng, kích thước của nó và con trỏ tới phần tử lớn nhất. Chúng tôi duyệt qua toàn bộ mảng và nếu phần tử hiện tại lớn hơn phần tử lớn nhất, chúng tôi cập nhật con trỏ phần tử lớn nhất. Lúc đầu, chúng tôi giả sử rằng phần tử đầu tiên là lớn nhất. Sau đó, chúng tôi duyệt qua mảng và nếu phần tử hiện tại lớn hơn phần tử lớn nhất, chúng tôi sẽ cập nhật phần tử lớn nhất

Ví dụ

Mảng. [2, 5, 21, 9]

Ban đầu, phần tử lớn nhất. 2

Bây giờ chúng ta bắt đầu duyệt mảng

Chỉ mục. 1
Phần tử chỉ mục > Phần tử lớn nhất, vì vậy hãy cập nhật phần tử lớn nhất bằng 5.

Chỉ mục. 2
Phần tử chỉ mục > Phần tử lớn nhất, vì vậy hãy cập nhật phần tử lớn nhất bằng 21.

Chỉ mục. 3
Phần tử chỉ mục < Phần tử lớn nhất nên phần tử lớn nhất vẫn giữ nguyên i. e 21.

Vậy Phần Tử Lớn Nhất là 21

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

Đây là mã nguồn của Chương trình C tìm số lớn nhất trong mảng sử dụng con trỏ. 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

```
/*
```
```
The 4th largest element = 12
```
013
```
The 4th largest element = 12
```
1
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
3
```
The 4th largest element = 12
```
33
```
The 4th largest element = 12
```
018
```
The 4th largest element = 12
```
6
```
The 4th largest element = 12
```
74
```
The 4th largest element = 12
```
021
```
The 4th largest element = 12
```
76
```
The 4th largest element = 12
```
17
```
The 4th largest element = 12
```
78
```
The 4th largest element = 12
```
025
```
The 4th largest element = 12
```
026
```
The 4th largest element = 12
```
11
```
The 4th largest element = 12
```
21
```
The 4th largest element = 12
```
5
```
The 4th largest element = 12
```
6
```
The 4th largest element = 12
```
50
```
The 4th largest element = 12
```
51
```
The 4th largest element = 12
```
52
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
54
```
The 4th largest element = 12
```
036
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
04
```
The 4th largest element = 12
```
58
```
The 4th largest element = 12
```
59
```
The 4th largest element = 12
```
60
```
The 4th largest element = 12
```
042
```
The 4th largest element = 12
```
043
```
The 4th largest element = 12
```
2
```
The 4th largest element = 12
```
24
```
The 4th largest element = 12
```
21

Giải thích chương trình

1. Lấy kích thước của mảng làm đầu vào từ người dùng.
2. Sử dụng vòng lặp for, lấy phần tử mảng làm đầu vào từ người dùng và chèn chúng vào mảng.
3. Khai báo một hàm để tìm phần tử lớn nhất lấy một mảng, kích thước của nó và con trỏ tới phần tử lớn nhất làm tham số.
4. trong chức năng.

Khởi tạo phần tử lớn nhất là phần tử đầu tiên của mảng
Duyệt qua mảng và nếu phần tử hiện tại lớn hơn phần tử lớn nhất, hãy cập nhật phần tử lớn nhất

5. In phần tử lớn nhất

Độ phức tạp về thời gian. O(n)
Trong chương trình ta duyệt mảng nên độ phức tạp về thời gian là O(n).

Độ phức tạp của không gian. O(n)
Cần có không gian để lưu trữ mảng, vì vậy độ phức tạp của không gian là O(n).

Các trường hợp kiểm tra thời gian chạy

Đây là đầu ra thời gian chạy của chương trình C nơi người dùng đang đọc mảng gồm 4 phần tử với các giá trị là 2, 5, 21 và 9. Sau đó, nó tìm ra phần tử lớn nhất và hiển thị giá trị của nó

The 4th largest element = 12

047

Để thực hành các chương trình về mọi chủ đề trong C, vui lòng truy cập “Ví dụ lập trình trong C”, “Cấu trúc dữ liệu trong C” và “Thuật toán trong C”

Làm cách nào để tìm phần tử lớn nhất trong một mảng trong C?

THUẬT TOÁN. .

BƯỚC 1. BẮT ĐẦU

BƯỚC 2. KHỞI TẠO mảng[] = {25, 11, 7, 75, 56}

BƯỚC 3. chiều dài = sizeof(arr)/sizeof(arr[0])

BƯỚC 4. tối đa = mảng [0]

BƯỚC 5. ĐẶT tôi = 0. LẶP LẠI BƯỚC 6 và BƯỚC 7 i<độ dài

BƯỚC 6. if(arr[i]>max) max=arr[i]

BƯỚC 7. tôi=i+1

BƯỚC 8. IN "Phần tử lớn nhất trong mảng đã cho. " chỉ định tối đa

Làm cách nào để tìm phần tử lớn thứ k trong một mảng trong C?

Phần tử lớn thứ k có thể được tìm thấy với sự trợ giúp của heap . Ở đây, chúng tôi đã sử dụng heap tối đa; . Chúng tôi làm theo các bước tương tự k-1 lần.

Làm cách nào để tìm số lớn thứ k trong một mảng mà không cần sắp xếp?

Thuật toán .

Chúng ta cần xây dựng một heap tối đa có kích thước N và chèn tất cả các phần tử của mảng vào đó

Sau đó, chúng tôi bật các phần tử k-1 đầu tiên từ nó

Bây giờ, phần tử lớn thứ k sẽ xuất hiện ở gốc của heap tối đa, chỉ cần in giá trị của gốc

Mảng lớn nhất trong C là gì?

Không có giới hạn cố định cho kích thước của mảng trong C . Kích thước của bất kỳ đối tượng đơn lẻ nào, bao gồm bất kỳ đối tượng mảng nào, bị giới hạn bởi SIZE_MAX , giá trị tối đa của loại size_t , là kết quả của toán tử sizeof.