NC76 用两个栈实现队列、NC68 跳台阶、NC41 最长无重复子数组、NC4 判断链表中是否有环

 NC76 用两个栈实现队列

描述

用两个栈来实现一个队列，使用n个元素来完成 n 次在队列尾部插入整数(push)和n次在队列头部删除整数(pop)的功能。 队列中的元素为int类型。保证操作合法，即保证pop操作时队列内已有元素。

数据范围： n≤1000n≤1000

要求：存储n个元素的空间复杂度为 O(n)O(n) ，插入与删除的时间复杂度都是 O(1)O(1)

示例1

输入：

["PSH1","PSH2","POP","POP"]

返回值：

1,2

说明：

"PSH1":代表将1插入队列尾部
"PSH2":代表将2插入队列尾部
"POP“:代表删除一个元素，先进先出=>返回1
"POP“:代表删除一个元素，先进先出=>返回2   

示例2

输入：

["PSH2","POP","PSH1","POP"]

返回值：

2,1

import java.util.*;
import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        if(stack2.empty()) {
            while(!stack1.empty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}

NC68 跳台阶

 

描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

数据范围：1≤n≤401≤n≤40

要求：时间复杂度：O(n)O(n) ，空间复杂度： O(1)O(1)

示例1

输入：

2

返回值：

2

说明：

青蛙要跳上两级台阶有两种跳法，分别是：先跳一级，再跳一级或者直接跳两级。因此答案为2       

示例2

输入：

7

返回值：

21

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param number int整型 
     * @return int整型
     */
    public int jumpFloor (int number) {
        // write code here
        int[] dp = new int[number+1];
        dp[0] = 1;
        dp[1] = 1;
        for(int i = 2; i <= number; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[number];
    }
}

NC41 最长无重复子数组

描述

给定一个长度为n的数组arr，返回arr的最长无重复元素子数组的长度，无重复指的是所有数字都不相同。

子数组是连续的，比如[1,3,5,7,9]的子数组有[1,3]，[3,5,7]等等，但是[1,3,7]不是子数组

数据范围：0≤arr.length≤1050≤arr.length≤105，0<arr[i]≤1050<arr[i]≤105

示例1

输入：

[2,3,4,5]

返回值：

4

说明：

[2,3,4,5]是最长子数组        

示例2

输入：

[2,2,3,4,3]

返回值：

3

说明：

[2,3,4]是最长子数组        

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param arr int整型一维数组 the array
     * @return int整型
     */

    #方法一：hashMap
    public int maxLength (int[] arr) {
        // write code here
        HashMap<Integer,Integer> map = new HashMap<>();
        int cnt = 0;
        int j = 0;
        for(int i = 0; i < arr.length; i++) {
            if(map.containsKey(arr[i])) {
                // 注意j需要比较取最大值，针对1 2 2 1这种情况
                j = Math.max(j, map.get(arr[i]) + 1);
            } 
            map.put(arr[i], i);
            cnt = Math.max(cnt, i - j + 1);
        }
        return cnt;
    }

    #方法二：队列
        public int maxLength(int[] arr) {
        //用链表实现队列，队列是先进先出的
        Queue<Integer> queue = new LinkedList<>();
        int res = 0;
        for (int c : arr) {
            while (queue.contains(c)) {
                //如果有重复的，队头出队
                queue.poll();
            }
            //添加到队尾
            queue.add(c);
            res = Math.max(res, queue.size());
        }
        return res;
    }
}

NC4 判断链表中是否有环

描述

判断给定的链表中是否有环。如果有环则返回true，否则返回false。

数据范围：链表长度 0≤n≤100000≤n≤10000，链表中任意节点的值满足 ∣val∣<=100000∣val∣<=100000

要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

输入分为两部分，第一部分为链表，第二部分代表是否有环，然后将组成的head头结点传入到函数里面。-1代表无环，其它的数字代表有环，这些参数解释仅仅是为了方便读者自测调试。实际在编程时读入的是链表的头节点。

例如输入{3,2,0,-4},1时，对应的链表结构如下图所示：

可以看出环的入口结点为从头结点开始的第1个结点（注：头结点为第0个结点），所以输出true。

示例1

输入：

{3,2,0,-4},1

返回值：

true

说明：

第一部分{3,2,0,-4}代表一个链表，第二部分的1表示，-4到位置1（注：头结点为位置0），即-4->2存在一个链接，组成传入的head为一个带环的链表，返回true           

示例2

输入：

{1},-1

返回值：

false

说明：

第一部分{1}代表一个链表，-1代表无环，组成传入head为一个无环的单链表，返回false           

 

import java.util.*;
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null) return false;
        ListNode slow = head;
        ListNode fast = head;
        while(slow.next != null && fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast) return true;
        }
        return false;
    }
}