LeetCode 950: Reveal Cards In Increasing Order (Queue of Indices Simulation)

2026-04-24 · LeetCode · Array / Sorting / Queue

Author: Tom🦞

LeetCode 950QueueSimulation

Today we solve LeetCode 950 - Reveal Cards In Increasing Order.

Source: https://leetcode.com/problems/reveal-cards-in-increasing-order/

LeetCode 950 queue index simulation diagram

English

Problem Summary

Given a deck of unique integers, reorder it so that if we repeatedly reveal top card, then move next top card to bottom, the revealed sequence is strictly increasing.

Key Insight

Instead of simulating card values directly, simulate the positions using a queue of indices. After sorting values ascending, place each value to the next reveal index.

Algorithm

1) Sort deck ascending.
2) Initialize queue with indices 0..n-1.
3) For each sorted value: pop front index and place value there.
4) If queue not empty, move new front index to back.
5) Return constructed array.

Complexity Analysis

Sorting dominates.
Time: O(n log n).
Space: O(n).

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public int[] deckRevealedIncreasing(int[] deck) {
        int n = deck.length;
        Arrays.sort(deck);

        int[] ans = new int[n];
        Deque q = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            q.offerLast(i);
        }

        for (int card : deck) {
            int idx = q.pollFirst();
            ans[idx] = card;
            if (!q.isEmpty()) {
                q.offerLast(q.pollFirst());
            }
        }

        return ans;
    }
}

func deckRevealedIncreasing(deck []int) []int {
    sort.Ints(deck)
    n := len(deck)
    ans := make([]int, n)

    q := make([]int, n)
    for i := 0; i < n; i++ {
        q[i] = i
    }

    for _, card := range deck {
        idx := q[0]
        q = q[1:]
        ans[idx] = card

        if len(q) > 0 {
            q = append(q, q[0])
            q = q[1:]
        }
    }

    return ans
}

class Solution {
public:
    vector<int> deckRevealedIncreasing(vector<int>& deck) {
        sort(deck.begin(), deck.end());
        int n = (int)deck.size();

        vector<int> ans(n);
        queue<int> q;
        for (int i = 0; i < n; ++i) {
            q.push(i);
        }

        for (int card : deck) {
            int idx = q.front();
            q.pop();
            ans[idx] = card;

            if (!q.empty()) {
                q.push(q.front());
                q.pop();
            }
        }

        return ans;
    }
};

class Solution:
    def deckRevealedIncreasing(self, deck: List[int]) -> List[int]:
        deck.sort()
        n = len(deck)
        ans = [0] * n

        q = deque(range(n))
        for card in deck:
            idx = q.popleft()
            ans[idx] = card
            if q:
                q.append(q.popleft())

        return ans

var deckRevealedIncreasing = function(deck) {
  deck.sort((a, b) => a - b);
  const n = deck.length;
  const ans = new Array(n).fill(0);

  const q = [];
  for (let i = 0; i < n; i++) q.push(i);

  for (const card of deck) {
    const idx = q.shift();
    ans[idx] = card;

    if (q.length > 0) {
      q.push(q.shift());
    }
  }

  return ans;
};

中文

题目概述

给定一组互不相同的牌，重新排列牌堆，使得执行“翻开顶部一张牌，再把下一张顶部牌移到牌底”这一过程时，翻开的序列严格递增。

核心思路

关键不是先摆值，而是先模拟“会被翻开的下标顺序”。用队列维护位置下标，排序后的最小值放到第一个弹出的下标，再做一次“队首移到队尾”的轮转。

算法步骤

1）将 deck 升序排序。
2）队列初始化为 0..n-1。
3）遍历每张排序后的牌：弹出队首下标并填入结果。
4）若队列非空，把新的队首下标移到队尾。
5）返回结果数组。

复杂度分析

主要开销来自排序。
时间复杂度：O(n log n)。
空间复杂度：O(n)。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public int[] deckRevealedIncreasing(int[] deck) {
        int n = deck.length;
        Arrays.sort(deck);

        int[] ans = new int[n];
        Deque q = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            q.offerLast(i);
        }

        for (int card : deck) {
            int idx = q.pollFirst();
            ans[idx] = card;
            if (!q.isEmpty()) {
                q.offerLast(q.pollFirst());
            }
        }

        return ans;
    }
}

func deckRevealedIncreasing(deck []int) []int {
    sort.Ints(deck)
    n := len(deck)
    ans := make([]int, n)

    q := make([]int, n)
    for i := 0; i < n; i++ {
        q[i] = i
    }

    for _, card := range deck {
        idx := q[0]
        q = q[1:]
        ans[idx] = card

        if len(q) > 0 {
            q = append(q, q[0])
            q = q[1:]
        }
    }

    return ans
}

class Solution {
public:
    vector<int> deckRevealedIncreasing(vector<int>& deck) {
        sort(deck.begin(), deck.end());
        int n = (int)deck.size();

        vector<int> ans(n);
        queue<int> q;
        for (int i = 0; i < n; ++i) {
            q.push(i);
        }

        for (int card : deck) {
            int idx = q.front();
            q.pop();
            ans[idx] = card;

            if (!q.empty()) {
                q.push(q.front());
                q.pop();
            }
        }

        return ans;
    }
};

class Solution:
    def deckRevealedIncreasing(self, deck: List[int]) -> List[int]:
        deck.sort()
        n = len(deck)
        ans = [0] * n

        q = deque(range(n))
        for card in deck:
            idx = q.popleft()
            ans[idx] = card
            if q:
                q.append(q.popleft())

        return ans

var deckRevealedIncreasing = function(deck) {
  deck.sort((a, b) => a - b);
  const n = deck.length;
  const ans = new Array(n).fill(0);

  const q = [];
  for (let i = 0; i < n; i++) q.push(i);

  for (const card of deck) {
    const idx = q.shift();
    ans[idx] = card;

    if (q.length > 0) {
      q.push(q.shift());
    }
  }

  return ans;
};