896. 单调数列(java)

题目

如果数组是单调递增或单调递减的,那么它是单调的。

如果对于所有 i <= j,A[i] <= A[j],那么数组 A 是单调递增的。 如果对于所有 i <= j,A[i]> = A[j],那么数组 A 是单调递减的。

当给定的数组 A 是单调数组时返回 true,否则返回 false。

思路

一开始是想一次遍历,先根据前面几项判断数列是递增还是递减,然后如果遍历过程中顺序变化就返回false,否则返回true。
用flag来表示数列的顺序,1为增,0为减,2为相等。
需要考虑一个特殊情况就是当前面几项都是相等的时候,这时候无法正确判断数列为递增或者递减,所以需要在遍历中将其flag进行转变。

class Solution {
    public boolean isMonotonic(int[] A) {
        // 遍历一次 顺序变换两次则为false  否则为true
        if(A.length<=2) return true;
        int cnt = 1,flag;
        if(A[1] > A[0]){
            flag = 1;
        }else if(A[1] < A[0]){
            flag = 0;
        }else {
            flag = 2;
        }
 
        for(int i=2;i<A.length;i++){
            if(A[i] > A[i-1] && flag == 0){
                return false;
            }
            if(A[i] < A[i-1] && flag == 1){
                return false;
            }
            if( flag == 2){
                if(A[i] < A[i-1]){
                    flag = 0;
                }else if(A[i] > A[i-1]){
                    flag = 1;
                }
            } 
        }
        return true;

    }
}

在这里插入图片描述
插个比较简洁的一次遍历(答案):

class Solution {
    public boolean isMonotonic(int[] A) {
        // inc 递增  dec递减
        boolean inc=true,dec=true;
        int n = A.length;
        for(int i=0;i<n-1;i++){
            if(A[i]<A[i+1]){
                dec=false;
            }
            if(A[i]>A[i+1]){
                inc=false;
            }
        }
        return inc || dec;
    }
}

还有两次遍历:
两次遍历比较好理解,原以为遍历两次速度会比遍历一次慢,不过时间复杂度都是O(n),所以还是差不多。

class Solution {
    public boolean isMonotonic(int[] A) {
        return isSort(A,true) || isSort(A,false);   

    }

    boolean isSort(int[] A,boolean key){
        int n = A.length;
        if(key == true){
            // 判断是否递增
            for(int i=1;i<n;i++){
                if(A[i]<A[i-1]) {
                    return false;
                }
            }
        }else{
            // 判断是否递减
            for(int i=1;i<n;i++){
                if(A[i]>A[i-1]){
                    return false;
                }
            }
        }
        return true;
    }

}

在这里插入图片描述

  • 2
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Deque<Integer> deque = new LinkedList<>(); for(int i=0; i<n; i++){ int num = scanner.nextInt(); while(!deque.isEmpty() && deque.getLast() > num){ deque.removeLast(); } deque.addLast(num); } System.out.println(deque.getFirst()); ### 回答2: 单调队列(Monotonic Queue)是一种特殊的队列数据结构,它具有以下特点: 1. 队列中的元素满足一定的单调性,例如单调递增单调递减; 2. 每次插入一个新的元素时,会将队列中比新元素小的元素删除; 3. 队列中的元素按插入的顺序排列。 以下是用Java编写的单调队列的代码: ```java import java.util.*; public class MonotonicQueue { Deque<Integer> deque; // 可以用双端队列来实现单调队列 public MonotonicQueue() { deque = new ArrayDeque<>(); } // 向队尾插入元素,删除比新元素小的元素 public void push(int num) { while (!deque.isEmpty() && deque.getLast() < num) { deque.removeLast(); // 删除队尾元素 } deque.addLast(num); // 插入新元素到队尾 } // 返回队列中的最大元素 public int getMax() { return deque.getFirst(); // 队头元素始终是最大值 } // 删除队头元素 public void pop() { deque.removeFirst(); } } ``` 上述代码中,我们使用了Java的双端队列(Deque)来实现单调队列。在插入新元素时,我们不断地将队列中比新元素小的元素删除,以保持队列的单调性。同时,我们可以通过调用`getMax()`方法获取队列中的最大元素,通过调用`pop()`方法删除队头元素。 使用单调队列的时间复杂度为O(n),其中n为元素个数。 ### 回答3: 单调队列是一种特殊的队列,可以高效地找到队列中的最大或最小值。下面是一个使用Java实现的单调队列的代码示例: ```java import java.util.ArrayDeque; import java.util.Deque; public class MonotonicQueue { private Deque<Integer> queue; // 存储队列中的元素 private Deque<Integer> maxElements; // 存储单调队列中的最大值 public MonotonicQueue() { queue = new ArrayDeque<>(); maxElements = new ArrayDeque<>(); } public void push(int val) { while (!maxElements.isEmpty() && maxElements.peekLast() < val) { maxElements.pollLast(); // 如果当前值比最大值大,则移除最大值 } maxElements.offerLast(val); // 将当前值加入最大元素队列 queue.offerLast(val); // 将当前值加入原始队列 } public void pop() { // 如果要移除的元素是最大元素,也要从最大元素队列中移除 if (queue.peekFirst().equals(maxElements.peekFirst())) { maxElements.pollFirst(); } queue.pollFirst(); // 移除原始队列中的第一个元素 } public int getMax() { return maxElements.peekFirst(); // 返回最大元素队列中的第一个元素 } public static void main(String[] args) { MonotonicQueue queue = new MonotonicQueue(); queue.push(3); queue.push(5); queue.push(2); System.out.println(queue.getMax()); // 输出 5 queue.pop(); System.out.println(queue.getMax()); // 输出 5 queue.pop(); System.out.println(queue.getMax()); // 输出 2 } } ``` 在上述代码中,我们使用`ArrayDeque`作为队列的实现,分别维护了`queue`和`maxElements`两个队列。`push`方法用于往队列中添加元素,其中使用了一个`while`循环来将队列中所有小于当前值的元素移除,保持队列的单调性。`pop`方法用于移除队列中的元素,如果要移除的元素是最大元素,则需要同时从最大元素队列中移除。`getMax`方法用于返回当前队列中的最大值。在`main`方法中,我们展示了单调队列的基本使用。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值