[LeetCode][M0950]按递增顺序显示卡牌（Java）（规律、模拟）

一、题目描述：

牌组中的每张卡牌都对应有一个唯一的整数。你可以按你想要的顺序对这套卡片进行排序。

最初，这些卡牌在牌组里是正面朝下的（即，未显示状态）。

现在，重复执行以下步骤，直到显示所有卡牌为止：

从牌组顶部抽一张牌，显示它，然后将其从牌组中移出。
如果牌组中仍有牌，则将下一张处于牌组顶部的牌放在牌组的底部。
如果仍有未显示的牌，那么返回步骤 1。否则，停止行动。
返回能以递增顺序显示卡牌的牌组顺序。

答案中的第一张牌被认为处于牌堆顶部。

示例：

输入：[17,13,11,2,3,5,7]
输出：[2,13,3,11,5,17,7]
解释：
我们得到的牌组顺序为 [17,13,11,2,3,5,7]（这个顺序不重要），然后将其重新排序。
重新排序后，牌组以 [2,13,3,11,5,17,7] 开始，其中 2 位于牌组的顶部。
我们显示 2，然后将 13 移到底部。牌组现在是 [3,11,5,17,7,13]。
我们显示 3，并将 11 移到底部。牌组现在是 [5,17,7,13,11]。
我们显示 5，然后将 17 移到底部。牌组现在是 [7,13,11,17]。
我们显示 7，并将 13 移到底部。牌组现在是 [11,17,13]。
我们显示 11，然后将 17 移到底部。牌组现在是 [13,17]。
我们展示 13，然后将 17 移到底部。牌组现在是 [17]。
我们显示 17。
由于所有卡片都是按递增顺序排列显示的，所以答案是正确的。

提示：

1 <= A.length <= 1000
1 <= A[i] <= 10^6
对于所有的 i != j，A[i] != A[j]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reveal-cards-in-increasing-order
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

二、解题思路：

1、自己的思路：

根据题目描述，这是把一个递增数组 按照 每次跳一个位置 排列起来的。

举例：[1,2,3,4,5,6,7]

答案应该是[1,6,2,5,3,7,4]

第一次：index = 0；读数为 1；
第二次：index = 2；读数为 2；跳过了index=1位置的数 6；
第三次：index = 4；读数为 3；跳过了（3）位置的 5；
第四次：index = 6；读数为 4；跳过了（5）位置的 7；
第五次：index = 3；读数为 5；跳过了（1）位置的 6；【把已经读取的数排除，剩余的数字首尾相连，读了数字 4 之后，下一个数字是 处于第一位置的 6 ，所以跳过 6 ，读取 5 】
第六次：index = 1；读数为 6；跳过了（5）位置的 7；
第七次；index = 5；读数为 7；就剩一个了，跳过7下一个还是7，所以不需要特殊处理。

这样看来，只需要 用一个 boolean 类型来交替 变换 true、false值 就可能进行 数字的读取与不读取，也就是决定了数组 存放与不存放 在当前位置；

首先对题目给的数组进行排序；
然后创建 存储答案的数组 res，和存储当前位置是否已经存储数字的数组 index；
由于第一遍一定是从零开始 0、2、4……，所以我单独拿出来了，稍微减少耗时；

后续只要在循环中 判断 原数组的值是否全部用完，
然后按照 跳一位 的思路来解决其他位置 数字的放置。

2、官方思路：

官方的思路简直太秒了，用一个队列模拟弹出与加入的过程，而队列中存储下标，这样模拟出来的下标顺序就是数值从小到大 应该放置的位置。

举例：[1,2,3,4,5]
队列存储下标<0,1,2,3,4>
模拟过程：
1、 0 <2,3,4,1>
2、 0,2<4,1,3>
3、 0,2,4<3,1>
4、 0,2,4,3,1
下标对应数字1,2,3,4,5
答案就是[1,5,2,4,3]

三、反思错误：

代码功力还是不够，有想法 但是写出来就很乱，而且 好多地方 都出错了，数组越界什么的。

甚至代码写着写着 还需要 回头去看 自己设置的变量 是什么意思。

之前有听说变量名字太长 也会影响速度，所以，名字我尽可能的取短了。

思路受限，想到了队列 但是就是没想到下标来做模拟。

四、Java代码：

自己的代码：

class Solution {
    public int[] deckRevealedIncreasing(int[] deck) {
    	// 排序
        Arrays.sort(deck);
        // 长度
        int len = deck.length;
        // deck 遍历到的位置
        int idx = 0;
        // 答案
        int[] res = new int[len];
        // 该位置是否已存放数字，存放为1，否则为0
        int[] index = new int[len];
        for(int i=0;i<len;i+=2){
            res[i] = deck[idx++];
            index[i] = 1;
        }
        // 判断最后一个是不是存放了数字，如果存放了，那么下一个就要跳过去，也就是use为false
        boolean use = index[len-1]==0; 
        while(idx<len){
            for(int i=0;i<len;++i){
                if(index[i]==0){
                    if(use){
                        res[i] = deck[idx++];
                        index[i] = 1;
                    }
                    use = !use;
                }
            }
        }
        return res;
    }
}

官方代码：

class Solution {
    public int[] deckRevealedIncreasing(int[] deck) {
        int N = deck.length;
        Deque<Integer> index = new LinkedList();
        for (int i = 0; i < N; ++i)
            index.add(i);

        int[] ans = new int[N];
        Arrays.sort(deck);
        for (int card: deck) {
            ans[index.pollFirst()] = card;
            if (!index.isEmpty())
                index.add(index.pollFirst());
        }

        return ans;
    }
}

五、执行结果：

（自己的执行结果）
执行用时：2 ms, 在所有 Java 提交中击败了95.73%的用户
内存消耗：38.7 MB, 在所有 Java 提交中击败了45.50%的用户