華為OD機試真題——阿里巴巴找黃金寶箱 IV（2025A卷：200分）Java/python/JavaScript/C++/C語言/GO六種最佳實現

在這里插入圖片描述

2025 A卷 200分題型

本文涵蓋詳細的問題分析、解題思路、代碼實現、代碼詳解、測試用例以及綜合分析；
并提供Java、python、JavaScript、C++、C語言、GO六種語言的最佳實現方式！

華為OD機試真題《阿里巴巴找黃金寶箱 IV》：

- 題目名稱：阿里巴巴找黃金寶箱 IV
- - 題目描述
- Java
- - 題目分析
  - 解決思路
  - Java 代碼實現
  - 代碼解析
  - 示例測試
  - - 示例1：
    - 示例2：
  - 綜合分析
- python
- - 題目分析
  - 解決思路
  - Python 代碼實現
  - 代碼解析
  - 示例測試
  - - 示例1：
    - 示例2：
  - 綜合分析
- JavaScript
- - 題目分析
  - 解決思路
  - JavaScript 代碼實現
  - 代碼解析
  - 示例測試
  - - 示例1：
    - 示例2：
  - 綜合分析
- C++
- - 題目分析
  - 解決思路
  - C++ 代碼實現
  - 代碼解析
  - 示例測試
  - - 示例1：
    - 示例2：
  - 綜合分析
- C語言
- - 題目分析
  - 解決思路
  - C 代碼實現
  - 代碼解析
  - - 1. 棧結構定義
    - 2. 棧操作函數
    - 3. 核心算法
    - 4. 輸入處理
  - 示例測試
  - - 示例1：
    - 示例2：
  - 綜合分析
- GO
- - 題目分析
  - 解決思路
  - Go 代碼實現
  - 代碼解析
  - 示例測試
  - - 示例1：
    - 示例2：
  - 綜合分析
- 更多內容：

題目名稱：阿里巴巴找黃金寶箱 IV

知識點： 字符串、棧操作（單調棧算法）、邏輯處理
時間限制： 1秒
空間限制： 256MB
限定語言： 不限

題目描述

一貧如洗的樵夫阿里巴巴在去砍柴的路上，無意中發現了強盜集團的藏寶地。藏寶地有編號從0-N的箱子排列成環（編號最大的箱子的下一個是編號為0的箱子），每個箱子貼有一個數字。請輸出每個箱子之后的第一個比它大的數字，若不存在則輸出-1。

輸入描述
輸入一個數字子串，數字之間用逗號分隔，例如：1,2,3,1。

1 ≤ 子串中數字個數 ≤ 10000
-100000 ≤ 每個數字值 ≤ 100000

輸出描述
結果以逗號分隔，例如：2,3,6,-1,6。

測試用例

輸入：1,2,3,4,5 → 輸出：2,3,4,5,-1
輸入：2,5,2 → 輸出：5,-1,5（需循環搜索）

Java

題目分析

我們需要在給定的環形數組中，為每個元素找到其后第一個更大的元素。環形數組意味著最后一個元素的下一個元素是第一個元素。例如，輸入 2,5,2 中，第三個元素的下一個元素是第一個元素，但第一個更大的元素是第二個元素 5。

解決思路

單調棧算法：

遍歷兩次數組：模擬環形結構，每個元素會被處理兩次。
維護單調遞減棧：棧中保存元素索引，確保棧頂元素對應的值是遞減的。
處理每個元素：當當前元素比棧頂元素大時，棧頂元素的下一個更大元素即為當前元素，記錄結果并出棧。

Java 代碼實現

import java.util.*;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);String input = scanner.nextLine();String[] parts = input.split(",");int[] nums = new int[parts.length];for (int i = 0; i < parts.length; i++) {nums[i] = Integer.parseInt(parts[i]);}int[] result = nextGreaterElements(nums);System.out.println(arrayToString(result));}private static int[] nextGreaterElements(int[] nums) {int n = nums.length;int[] res = new int[n];Arrays.fill(res, -1);Deque<Integer> stack = new ArrayDeque<>();// 遍歷兩次數組，模擬環形結構for (int i = 0; i < 2 * n; i++) {int num = nums[i % n];// 維護單調遞減棧，處理棧頂元素while (!stack.isEmpty() && num > nums[stack.peek()]) {int index = stack.pop();res[index] = num;}// 只在第一次遍歷時壓入索引if (i < n) {stack.push(i);}}return res;}private static String arrayToString(int[] arr) {StringBuilder sb = new StringBuilder();for (int i = 0; i < arr.length; i++) {if (i > 0) {sb.append(",");}sb.append(arr[i]);}return sb.toString();}
}

代碼解析

輸入處理：

String input = scanner.nextLine();
String[] parts = input.split(",");
int[] nums = new int[parts.length];
for (int i = 0; i < parts.length; i++) {nums[i] = Integer.parseInt(parts[i]);
}

讀取輸入字符串并分割為整數數組。

核心算法 nextGreaterElements：
```
int[] res = new int[n];
Arrays.fill(res, -1);
Deque<Integer> stack = new ArrayDeque<>();
```
- 初始化結果數組 res，默認值為 -1。
- 使用雙端隊列 Deque 作為棧，保存索引。
遍歷兩次數組：
```
for (int i = 0; i < 2 * n; i++) {int num = nums[i % n];while (!stack.isEmpty() && num > nums[stack.peek()]) {int index = stack.pop();res[index] = num;}if (i < n) {stack.push(i);}
}
```
- 遍歷邏輯：遍歷 2n 次，i % n 模擬環形訪問。
- 維護棧：棧中保存未找到更大元素的索引，確保棧中元素對應的值是遞減的。
- 處理棧頂元素：當當前元素 num 大于棧頂元素對應的值時，棧頂元素的下一個更大元素即為 num，記錄結果并出棧。
- 壓入索引：僅在第一次遍歷時壓入索引，避免重復處理。

結果轉換：

private static String arrayToString(int[] arr) {// 將數組轉換為逗號分隔的字符串
}

將結果數組轉換為題目要求的輸出格式。

示例測試

示例1：

輸入：

1,2,3,4,5

輸出：

2,3,4,5,-1

解析：

每個元素的下一個更大元素依次為后一個元素，最后一個元素無更大值。

示例2：

輸入：

2,5,2

輸出：

5,-1,5

解析：

第一個 2 的下一個更大元素是 5。
5 之后沒有更大元素。
最后一個 2 的下一個更大元素是循環后的 5。

綜合分析

時間復雜度 O(n)：每個元素最多入棧和出棧兩次，總操作次數為 4n，仍為線性復雜度。
空間復雜度 O(n)：棧和結果數組的空間均為 O(n)。
正確性保證：
- 環形處理：通過遍歷兩次數組，確保每個元素能訪問到環形后的元素。
- 單調棧特性：確保每個元素找到第一個更大元素。
適用場景：高效處理大規模數據（n ≤ 10000）。

python

題目分析

給定一個環形數組，每個元素需要找到其后的第一個更大元素。若不存在更大元素則輸出 -1。例如：

輸入 2,5,2 的輸出為 5,-1,5，最后一個元素循環到開頭找到更大值。
輸入 1,2,3,4,5 的輸出為 2,3,4,5,-1。

解決思路

單調棧算法：

遍歷兩次數組：模擬環形結構，每個元素處理兩次。
維護單調遞減棧：棧中保存元素索引，確保棧頂元素對應的值是遞減的。
處理當前元素：若當前元素比棧頂元素大，則棧頂元素的下一個更大元素即為當前元素。

Python 代碼實現

def next_greater_elements(nums):n = len(nums)res = [-1] * n  # 初始化結果數組，默認-1stack = []  # 單調遞減棧，保存索引# 遍歷兩倍數組長度，模擬環形結構for i in range(2 * n):current_num = nums[i % n]  # 當前元素（環形取模）# 維護單調棧：當前元素比棧頂元素大時，更新結果while stack and current_num > nums[stack[-1]]:index = stack.pop()  # 彈出棧頂索引res[index] = current_num  # 記錄下一個更大元素# 只在第一次遍歷時壓入索引，避免重復處理if i < n:stack.append(i % n)return res# 輸入處理與結果輸出
input_str = input().strip()
nums = list(map(int, input_str.split(',')))
result = next_greater_elements(nums)
print(','.join(map(str, result)))

代碼解析

初始化結果數組：
```
n = len(nums)
res = [-1] * n
```
- 創建長度與輸入相同的數組，默認值為 -1。
遍歷兩次數組：
```
for i in range(2 * n):current_num = nums[i % n]
```
- i % n 將索引映射到原數組范圍，模擬環形結構。

維護單調遞減棧：

while stack and current_num > nums[stack[-1]]:index = stack.pop()res[index] = current_num

當當前元素比棧頂元素大時，彈出棧頂并記錄結果。

壓入索引：
```
if i < n:stack.append(i % n)
```
- 僅在第一次遍歷時壓入索引，避免重復處理。

示例測試

示例1：

輸入：

1,2,3,4,5

輸出：

2,3,4,5,-1

解析：

每個元素的下一個更大元素是后一個元素，最后一個元素無更大值。

示例2：

輸入：

2,5,2

輸出：

5,-1,5

解析：

第一個 2 的下一個更大元素是 5。
5 之后沒有更大元素。
最后一個 2 循環到開頭找到 5。

綜合分析

時間復雜度 O(n)：每個元素最多入棧和出棧兩次，總操作次數為 4n，時間復雜度為線性。
空間復雜度 O(n)：棧和結果數組的空間均為 O(n)。
正確性保障：
- 環形處理：通過遍歷兩次數組，確保每個元素能訪問到環形后的元素。
- 單調棧特性：棧中保存未找到更大元素的索引，保證找到的是第一個更大值。
適用場景：高效處理大規模數據（n ≤ 10000）。

JavaScript

題目分析

給定一個環形數組，每個元素需要找到其后第一個更大的元素。若不存在，則返回 -1。例如：

輸入 2,5,2 的輸出為 5,-1,5，最后一個元素在循環中找到更大的 5。
輸入 1,2,3,4,5 的輸出為 2,3,4,5,-1。

解決思路

單調棧算法：

遍歷兩次數組：模擬環形結構，確保每個元素處理兩次。
維護單調遞減棧：棧中保存元素索引，棧頂元素對應的值最小。
處理當前元素：若當前元素比棧頂元素大，則棧頂元素的下一個更大元素為當前元素。

JavaScript 代碼實現

function nextGreaterElements(nums) {const n = nums.length;const result = new Array(n).fill(-1); // 初始化結果數組為-1const stack = []; // 單調棧，保存索引// 遍歷兩倍數組長度以模擬環形結構for (let i = 0; i < 2 * n; i++) {const currentNum = nums[i % n]; // 當前元素（環形取模）// 維護棧：當前元素比棧頂元素大時，更新結果while (stack.length > 0 && currentNum > nums[stack[stack.length - 1]]) {const index = stack.pop();result[index] = currentNum; // 棧頂元素的下一個更大元素是當前元素}// 僅在第一次遍歷時壓入索引，避免重復處理if (i < n) {stack.push(i % n);}}return result;
}// 輸入處理與結果輸出
const input = '2,5,2'; // 示例輸入
const nums = input.split(',').map(Number);
const result = nextGreaterElements(nums);
console.log(result.join(',')); // 輸出：5,-1,5

代碼解析

初始化結果數組：
```
const result = new Array(n).fill(-1);
```
- 創建長度與輸入數組相同的數組，默認值為 -1。
遍歷兩次數組：
```
for (let i = 0; i < 2 * n; i++) {const currentNum = nums[i % n];
```
- i % n 將索引映射到原數組范圍，模擬環形結構。

維護單調遞減棧：

while (stack.length > 0 && currentNum > nums[stack[stack.length - 1]]) {const index = stack.pop();result[index] = currentNum;
}

當當前元素比棧頂元素大時，彈出棧頂并記錄結果。

壓入索引：
```
if (i < n) {stack.push(i % n);
}
```
- 僅在第一次遍歷時壓入索引，避免重復處理。

示例測試

示例1：

輸入：

const input = '1,2,3,4,5';

輸出：

2,3,4,5,-1

解析：

每個元素的下一個更大元素是后一個元素，最后一個元素無更大值。

示例2：

輸入：

const input = '2,5,2';

輸出：

5,-1,5

解析：

第一個 2 的下一個更大元素是 5。
5 之后沒有更大元素。
最后一個 2 循環到開頭找到 5。

綜合分析

時間復雜度 O(n)：每個元素最多入棧和出棧兩次，總操作次數為 4n，時間復雜度為線性。
空間復雜度 O(n)：棧和結果數組的空間均為 O(n)。
正確性保障：
- 環形處理：通過遍歷兩次數組，確保每個元素能訪問到環形后的元素。
- 單調棧特性：棧中保存未找到更大元素的索引，保證找到的是第一個更大值。
適用場景：高效處理大規模數據（n ≤ 10000）。

C++

題目分析

給定一個環形數組，每個元素需要找到其后的第一個更大元素。若不存在，則返回 -1。例如：

輸入 1,2,3,4,5 的輸出為 2,3,4,5,-1。
輸入 2,5,2 的輸出為 5,-1,5。

解決思路

單調棧算法：

遍歷兩次數組：通過取模操作模擬環形數組，確保每個元素的后繼元素被檢查兩次。
維護單調遞減棧：棧中保存元素索引，確保棧頂元素對應的值最小。
更新結果數組：當當前元素大于棧頂元素時，棧頂元素的下一個更大元素即為當前元素。

C++ 代碼實現

#include <iostream>
#include <vector>
#include <stack>
#include <sstream>
#include <string>using namespace std;vector<int> nextGreaterElements(vector<int>& nums) {int n = nums.size();vector<int> res(n, -1);  // 初始化結果數組為-1stack<int> st;           // 單調棧，保存未找到更大元素的索引// 遍歷兩倍數組長度以模擬環形結構for (int i = 0; i < 2 * n; ++i) {int current = nums[i % n];  // 當前元素（環形取模）// 維護單調棧：當前元素比棧頂元素大時，更新結果while (!st.empty() && current > nums[st.top()]) {int idx = st.top();st.pop();res[idx] = current;  // 記錄棧頂索引對應的下一個更大元素}// 僅在第一次遍歷時壓入索引，避免重復處理if (i < n) {st.push(i % n);}}return res;
}int main() {string input;getline(cin, input);  // 讀取輸入字符串// 解析輸入為整數數組vector<int> nums;stringstream ss(input);string token;while (getline(ss, token, ',')) {nums.push_back(stoi(token));}// 計算下一個更大元素數組vector<int> res = nextGreaterElements(nums);// 輸出結果for (int i = 0; i < res.size(); ++i) {if (i != 0) {cout << ",";}cout << res[i];}cout << endl;return 0;
}

代碼解析

結果數組初始化：
```
vector<int> res(n, -1);
```
- 創建一個長度為 n 的數組，所有元素初始化為 -1。
遍歷兩倍數組長度：
```
for (int i = 0; i < 2 * n; ++i) {int current = nums[i % n];
```
- 通過 i % n 模擬環形數組，遍歷兩次原數組。

維護單調棧：

while (!st.empty() && current > nums[st.top()]) {int idx = st.top();st.pop();res[idx] = current;
}

當前元素比棧頂元素大時，彈出棧頂并更新結果。

壓入索引：
```
if (i < n) {st.push(i % n);
}
```
- 僅在第一次遍歷時壓入索引，確保每個元素只處理一次。

示例測試

示例1：

輸入：

1,2,3,4,5

輸出：

2,3,4,5,-1

解析：

每個元素的后一個元素更大，最后一個元素無更大值。

示例2：

輸入：

2,5,2

輸出：

5,-1,5

解析：

第二個 2 循環到數組開頭找到 5 作為下一個更大元素。

綜合分析

時間復雜度 O(n)：每個元素最多入棧和出棧兩次，總操作次數為 4n，時間復雜度為線性。
空間復雜度 O(n)：棧和結果數組的空間均為 O(n)。
正確性保障：
- 環形處理：通過遍歷兩次數組，確保每個元素的后繼被完整檢查。
- 單調棧特性：確保每個元素找到第一個更大的元素。
適用場景：高效處理大規模數據（n ≤ 10000）。

C語言

題目分析

給定一個環形數組，每個元素需要找到其后第一個更大的元素。若不存在，則返回 -1。例如：

輸入 2,5,2 的輸出為 5,-1,5
輸入 1,2,3,4,5 的輸出為 2,3,4,5,-1

解決思路

單調棧算法：

遍歷兩次數組：通過取模操作模擬環形結構
維護單調遞減棧：棧中保存元素索引，確保棧頂元素的值最小
更新結果數組：當當前元素大于棧頂元素時，更新結果

C 代碼實現

#include <stdio.h>
#include <stdlib.h>
#include <string.h>#define INIT_CAPACITY 100  // 棧初始容量// 定義棧結構
typedef struct {int *data;     // 存儲索引的數組int top;       // 棧頂指針int capacity;  // 棧容量
} Stack;// 初始化棧
void initStack(Stack *s) {s->data = (int*)malloc(INIT_CAPACITY * sizeof(int));s->top = -1;s->capacity = INIT_CAPACITY;
}// 擴展棧容量
void resizeStack(Stack *s) {s->capacity *= 2;s->data = (int*)realloc(s->data, s->capacity * sizeof(int));
}// 壓棧操作
void push(Stack *s, int val) {if (s->top == s->capacity - 1) resizeStack(s);s->data[++s->top] = val;
}// 彈棧操作
int pop(Stack *s) {return s->data[s->top--];
}// 獲取棧頂元素
int top(Stack *s) {return s->data[s->top];
}// 判斷棧是否為空
int isEmpty(Stack *s) {return s->top == -1;
}// 釋放棧內存
void freeStack(Stack *s) {free(s->data);
}// 核心算法函數
int* nextGreaterElements(int* nums, int numsSize, int* returnSize) {int* res = (int*)malloc(numsSize * sizeof(int));*returnSize = numsSize;memset(res, -1, numsSize * sizeof(int));  // 初始化結果數組Stack s;initStack(&s);// 遍歷兩倍數組長度模擬環形for (int i = 0; i < 2 * numsSize; i++) {int current = nums[i % numsSize];// 維護單調棧while (!isEmpty(&s) && current > nums[top(&s)]) {int idx = pop(&s);res[idx] = current;}// 只壓入第一次遍歷的索引if (i < numsSize) {push(&s, i % numsSize);}}freeStack(&s);return res;
}// 字符串分割函數
int* parseInput(const char* input, int* size) {char* str = strdup(input);int count = 0;char* token = strtok(str, ",");int* arr = NULL;while (token) {arr = (int*)realloc(arr, (count + 1) * sizeof(int));arr[count++] = atoi(token);token = strtok(NULL, ",");}*size = count;free(str);return arr;
}int main() {char input[100000];fgets(input, sizeof(input), stdin);input[strcspn(input, "\n")] = '\0';  // 去除換行符int numsSize;int* nums = parseInput(input, &numsSize);int returnSize;int* res = nextGreaterElements(nums, numsSize, &returnSize);// 輸出結果for (int i = 0; i < returnSize; i++) {if (i > 0) printf(",");printf("%d", res[i]);}free(nums);free(res);return 0;
}

代碼解析

1. 棧結構定義

typedef struct {int *data;     // 存儲索引的數組int top;       // 棧頂指針int capacity;  // 棧容量
} Stack;

使用動態數組實現棧，支持自動擴容

2. 棧操作函數

void push(Stack *s, int val) {if (s->top == s->capacity - 1) resizeStack(s);s->data[++s->top] = val;
}

壓棧時自動檢查容量，不足時自動擴容

3. 核心算法

int* nextGreaterElements(int* nums, int numsSize, int* returnSize) {int* res = (int*)malloc(numsSize * sizeof(int));memset(res, -1, numsSize * sizeof(int));Stack s;initStack(&s);for (int i = 0; i < 2 * numsSize; i++) {int current = nums[i % numsSize];while (!isEmpty(&s) && current > nums[top(&s)]) {int idx = pop(&s);res[idx] = current;}if (i < numsSize) push(&s, i % numsSize);}freeStack(&s);return res;
}

關鍵邏輯：
- 遍歷 2*n 次模擬環形
- 維護單調遞減棧
- 只在第一次遍歷時壓入索引

4. 輸入處理

int* parseInput(const char* input, int* size) {char* str = strdup(input);int count = 0;int* arr = NULL;// 使用 strtok 分割字符串
}

動態解析逗號分隔的輸入字符串

示例測試

示例1：

輸入：

1,2,3,4,5

輸出：

2,3,4,5,-1

解析過程：

每個元素的后繼即為其下一個更大值
最后一個元素沒有更大值

示例2：

輸入：

2,5,2

輸出：

5,-1,5

解析過程：

第一個 2 找到后面的 5
第二個 5 沒有更大值
第三個 2 循環找到開頭的 5

綜合分析

時間復雜度 O(n)：每個元素最多入棧和出棧兩次
空間復雜度 O(n)：棧和結果數組各占用線性空間
內存管理：
- 動態數組自動擴容
- 嚴格釋放所有分配的內存
健壯性：
- 處理任意長度輸入（最大 100,000 字符）
- 支持正負數輸入
優勢：
- 完全手動實現棧操作
- 更精細的內存控制
- 適合嵌入式等資源受限環境

GO

題目分析

給定一個環形數組，每個元素需要找到其后的第一個更大元素。若不存在則返回 -1。例如：

輸入 2,5,2 的輸出為 5,-1,5，最后一個元素循環后找到更大的 5。
輸入 1,2,3,4,5 的輸出為 2,3,4,5,-1。

解決思路

單調棧算法：

遍歷兩次數組：通過取模操作模擬環形結構。
維護單調遞減棧：棧中保存元素索引，確保棧頂元素對應的值最小。
更新結果數組：當當前元素大于棧頂元素時，棧頂元素的下一個更大元素即為當前元素。

Go 代碼實現

package mainimport ("fmt""strings"
)func nextGreaterElements(nums []int) []int {n := len(nums)res := make([]int, n)for i := range res {res[i] = -1 // 初始化結果數組為-1}stack := []int{} // 單調棧，保存索引// 遍歷兩倍數組長度以模擬環形結構for i := 0; i < 2*n; i++ {current := nums[i%n] // 當前元素（環形取模）// 維護單調棧：當前元素比棧頂元素大時，更新結果for len(stack) > 0 && current > nums[stack[len(stack)-1]] {top := stack[len(stack)-1]stack = stack[:len(stack)-1] // 彈出棧頂res[top] = current          // 記錄下一個更大元素}// 僅在第一次遍歷時壓入索引if i < n {stack = append(stack, i%n)}}return res
}func main() {// 示例測試input1 := "1,2,3,4,5"nums1 := parseInput(input1)result1 := nextGreaterElements(nums1)fmt.Println("示例1輸出:", strings.Join(strings.Fields(fmt.Sprint(result1)), ",")) // 輸出: 2,3,4,5,-1input2 := "2,5,2"nums2 := parseInput(input2)result2 := nextGreaterElements(nums2)fmt.Println("示例2輸出:", strings.Join(strings.Fields(fmt.Sprint(result2)), ",")) // 輸出: 5,-1,5
}// 將輸入字符串轉換為整數數組
func parseInput(input string) []int {strs := strings.Split(input, ",")nums := make([]int, len(strs))for i, s := range strs {fmt.Sscanf(s, "%d", &nums[i])}return nums
}

代碼解析

初始化結果數組：
```
res := make([]int, n)
for i := range res {res[i] = -1
}
```
- 創建長度與輸入相同的數組，默認值為 -1。
模擬環形遍歷：
```
for i := 0; i < 2*n; i++ {current := nums[i%n]
```
- 遍歷 2n 次，i%n 將索引映射到原數組范圍。

維護單調棧：

for len(stack) > 0 && current > nums[stack[len(stack)-1]] {top := stack[len(stack)-1]stack = stack[:len(stack)-1]res[top] = current
}

當當前元素大于棧頂元素時，彈出棧頂并更新結果。

壓入索引：
```
if i < n {stack = append(stack, i%n)
}
```
- 只在第一次遍歷時壓入索引，避免重復處理。

示例測試

示例1：

輸入：1,2,3,4,5
輸出：2,3,4,5,-1
解析：

每個元素的后一個元素更大，最后一個元素無更大值。

示例2：

輸入：2,5,2
輸出：5,-1,5
解析：

第一個 2 的下一個更大元素是 5。
5 之后沒有更大元素。
最后一個 2 循環到開頭找到 5。

綜合分析

時間復雜度 O(n)：每個元素最多入棧和出棧兩次，總操作次數為 4n，時間復雜度為線性。
空間復雜度 O(n)：棧和結果數組的空間均為 O(n)。
正確性保障：
- 環形處理：通過遍歷兩次數組，確保每個元素的后繼被完整檢查。
- 單調棧特性：棧中保存未找到更大元素的索引，確保找到的是第一個更大值。
適用場景：高效處理大規模數據（n ≤ 10000）。