求下一个更大的数

本文提供了一种高效的解决LeetCode NextGreaterElementII问题的方法,利用栈结构实现了一次遍历算法,显著提高了运行效率。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

LeetCode原题:

Next Greater Element II

Description:

Given a circular array (the next element of the last element is the first element of the array), print the Next Greater Number for every element. The Next Greater Number of a number x is the first greater number to its traversing-order next in the array, which means you could search circularly to find its next greater number. If it doesn’t exist, output -1 for this number.

Example 1:

Input: [1,2,1]
Output: [2,-1,2]
Explanation: The first 1's next greater number is 2; 
The number 2 can't find next greater number; 
The second 1's next greater number needs to search circularly, which is also 2.

Note: The length of given array won’t exceed 10000.

分析:
题目意思是说给定一个数组,并对数组中的每一个元素,找出在此元素后且比它大的第一个元素(如果没找到,就从头开始找,但任在该元素之前),如果没找到,则为-1。

简单的算法:

大多数同学会想到遍历的方法,也就是O(n2)的算法,小编用这个算法提交后,显示有123ms,仅仅高于20%的Java提交者。很明显,第一个想到的方法往往并不是最好的。所以,小编也不推荐这种算法。

推荐的算法:

巧妙利用栈,一次遍历
1. 将数组第一个元素的下标入栈
2. 如果栈顶元素(下标)对应元素>=当前判断的元素,则将此元素的下标入栈,
3. 否则,如果栈不为空且栈顶元素(下标)对应元素<当前元素,则记录下来,并pop栈顶元素。继续此判断过程,结束后,push当前元素。
4. 如果栈中元素不为空,则进行第二次遍历,与第一次遍历过程类似。

这种算法的时间复杂度是O(n),小编用这个算法提交后,显示有50ms,高于70%的Java提交者,效率大大提高。

附Java代码:

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        if(nums == null)
            return null;
        if(nums.length <= 0)
            return new int[]{};
        Stack<Integer> stack = new Stack<>();//存储下标
        int[] resInt = new int[nums.length];
        stack.push(0);//将第一个元素的下标存入栈
        resInt[0] = -1;
        for(int i = 1 ; i < nums.length; i ++){
            resInt[i] = -1;
            if(nums[stack.peek()] >= nums[i])
                stack.push(i);//如果栈顶下标对应元素大于或等于当前元素,则将当前元素的下标入栈
            else{
                while(!stack.isEmpty() && nums[stack.peek()] < nums[i]){
                    //否则,如果栈不为空且栈顶下标对应元素小于当前元素,则记录并pop
                    resInt[stack.pop()] = nums[i];
                }
                stack.push(i);
            }
        }
        if(!stack.isEmpty()){
            //第二次遍历,清理栈内的元素
            for(int i = 0 ; i < nums.length; i ++){
                if(nums[stack.peek()] < nums[i]){
                    while(!stack.isEmpty() && nums[stack.peek()] < nums[i]){
                        //否则,如果栈不为空且栈顶下标对应元素小于当前元素,则记录并pop
                        resInt[stack.pop()] = nums[i];
                    }
                    stack.push(i);
                }
            }
        }
        return resInt;
    }
}
要找到一个$n$的最真因子(即除了自身以外最的能够整除该的因),可以采用以下几种方法之一: 最真因子是指能被原整除并且小于原本身的自然。 1. 迭代检查法 从$\lfloor \frac{n}{2} \rfloor$向下迭代至2,第一个能整除$n$的就是最真因子。这是因为任何于$\frac{n}{2}$的都不可能成为$n$的真因子(除非$n$是偶且这个正好等于$\frac{n}{2}$)。如果$n=1$或者$n$是一个,则没有真因子存在。 ```python def max_proper_divisor(n): if n <= 1: return None # No proper divisors for 1 or negative numbers. for divisor in range(n // 2, 0, -1): if n % divisor == 0: return divisor return 1 # If no other proper divisor found and n is prime. ``` 2. 平方根优化查找 对于较,可以从2开始直到$\sqrt{n}$进行遍历寻找最小因子$m$,一旦找到了这样的$m$,那么对应的另一个因子$k = \frac{n}{m}$将是最真因子(前提是$n > m^2$;若$n=m^2$则$m=k=\sqrt{n}$)。 ```python import math def max_proper_divisor_optimized(n): if n <= 1: return None root_n = int(math.sqrt(n)) for i in range(2, root_n + 1): if n % i == 0: return n // i return 1 if n != 1 else None # Return 1 only when n is a prime number greater than one. ``` 3. 因子分解法 先找出所有的质因子,再组合这些质因子得到所有因子,其中第二的那个即是所的最真因子。此方法适用于需要频繁查询的情况,因为可以通过预先计算出一系列的所有因子来加速后续查询过程。 选择哪种方法取决于具体的应用场景以及性能需。对于较小值可以直接使用简单的方法,而对于较值或高性能要的情况下应该考虑更高效的算法。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值