[leetcode]Next Greater Element

第一題：尋找子集合中每一個元素在原集合中右邊第一個比它大的數。

想到了用哈希表存這個數的位置，可是沒有想到能夠直接用哈希表存next great，用棧存還沒找到的數，沒遍歷一個數就考察棧中的元素小，小的話，這個數就是棧中數的next great，棧中的數確定是下大上小。

public int[] nextGreaterElement(int[] nums1, int[] nums2) {
         /*
        經過map創建當前元素和其next great的映射
        在創建映射時，用棧記錄尚未映射（就是尚未找到next great）的數，每新遍歷一個數，就考察棧頂元素能不能映射，能就
        創建映射，彈出棧頂，並繼續考察新棧頂。不能創建後，壓入該數。
        一開始不明白，會不會有下邊小，上邊大的狀況，若是有這種狀況的話，下邊的數是創建不了映射的，可是想了想是不可能出現的，
        由於每當有大的數的時候，小的會被彈出，大的會壓入，因此棧頂是最小的數。
         */
        Stack<Integer> st = new Stack<>();
        Map<Integer,Integer> map = new HashMap<>();
        int[] res = new int[nums1.length];
        for (int num :
                nums2) {
            while (!st.isEmpty() && st.peek() < num)
            {
                map.put(st.peek(),num);
                st.pop();
            }
            st.push(num);
        }
        for (int i = 0; i < res.length; i++) {
            res[i] = map.getOrDefault(nums1[i],-1);
        }
        return res;
    }

 

 

第二題：和第一題的不一樣點是此次是求一個循環數列中各個元素的next，並且可能有重複

循環的解決方法是遍歷兩輪，每次下標對n取餘，這樣兩輪的下標就相同了

重複的解決方法是stack記錄下標，而不是記錄數據，每次有了next，直接存到res的相應位置

最後的res就至關於一個哈希表

public int[] nextGreaterElements2(int[] nums) {
        /*
        相對第一題的改變時數組成了循環數組，遍歷到最後一個數以後能夠再從第一個數開始
        本身想的方案是暴力解，兩層for
        看了答案，這種循環數組遍歷，下標的問題是用取餘的方法，第二遍第1個數，至關於n+1個數，n+1%n = 1,正好是第一個數
        之後趕上循環數組，就遍歷兩倍長度，%n取餘後，兩次遍歷的下標就同樣了
         */
        int l = nums.length;
        int[] res = new int[l];
        //有的找不到，直接初始化數組爲-1
        Arrays.fill(res,-1);
        Stack<Integer> st = new Stack<>();
        //循環數組，遍歷兩倍長度的數組，每次都取餘，這樣每一個元素均可以把它先後的元素都遍歷到，對於第二輪遍歷下標不對應的解決方法是
        //取餘，對n取餘，下表就對應了。時間複雜度O（2n）
        //還要考慮此次有重複，因此不能記錄數，要記錄下標
        for (int i = 0; i < 2*l; i++) {
            int num = nums[i%l];
            while (!st.isEmpty() && nums[st.peek()] < num)
            {
                res[st.peek()] = num;
                st.pop();
            }
            //只在第一輪遍歷時記錄下標
            if (i<l) st.push(i);
        }
        return res;
    }

 

 

第三題：找全排列的下一個數，以前作過，可是沒作出來，f**k

public int nextGreaterElement3(int n) {
        /*
        沒作出來
        策略是:若是從第K爲到末尾是遞減的，且第k位大於第K-1位（也就是遞減序列最高位是k），那麼就倒序排列遞減序列，而且找到
        比k-1爲大的那個最小數，交換位置
        以前作過一個題，找全排列的下一個數，和這個如出一轍
         */
        String str = n+"";
        int l = str.length();
        if (l == 1)
            return -1;
        //注意這裏k的初始值不是0，是l-1。由於是倒着開始判斷，若是沒有判斷到則k不會改變，遞減數列應該是從l-1開始，也就是最後一個數
        int k = l-1;
        //處理成數列好操做，StringBuilder也能夠
        char[] ch = str.toCharArray();
        //找到遞減數列開始的地方
        for (int i = l-2; i >=0; i--) {
            if (ch[i] < ch[i+1])
            {
                k = i+1;
                break;
            }
        }
        //翻轉遞減數列，這裏也能夠轉爲字符串用string自帶的翻轉
        for (int i = k; i < k+(l-k)/2; i++) {
            char temp = ch[i];
            ch[i] = ch[l-1-(i-k)];
            ch[l-1-(i-k)] = temp;
        }
        //更換位置
        for (int i = k; i < l; i++) {
            if (ch[i] > ch[k-1])
            {
                char temp = ch[i];
                ch[i] = ch[k-1];
                ch[k-1] = temp;
                break;
            }
        }
        String res = new String(ch);
        //判斷是否是超過了int最大值
        Long a = Long.parseLong(res);
        if (a >Integer.MAX_VALUE)
            return -1;
        int b = Integer.parseInt(res);
        //若是數沒有改變說明這個數是全排列中最大的數，沒有下一個，輸出-1，要判斷一下
        if (b == n)
            return -1;
        return b;
    }