386. 字典序排数

题目描述

给你一个整数 n ，按字典序返回范围 [1, n] 内所有整数。

你必须设计一个时间复杂度为 O(n) 且使用 O(1) 额外空间的算法。

示例 1：

输入：n = 13
输出：[1,10,11,12,13,2,3,4,5,6,7,8,9]

示例 2：

输入：n = 2
输出：[1,2]

提示：

1 <= n <= 5 * 10⁴

解法

方法一：迭代

思考

输出 \([1,n]\) 的字典序。排序全部数字为 \(O(n\log n\cdot \log n)\)。十叉树上前序遍历即字典序。

从 \(1\) 出发：能乘 \(10\) 则深入下一层；否则若个位为 \(9\) 或 \(v+1>n\) 则回退，再加一到兄弟。迭代 \(n\) 次恰好枚举每个数一次。

我们首先定义一个变量 \(v\)，初始时 \(v = 1\)。然后我们从 \(1\) 开始迭代，每次迭代都将 \(v\) 添加到答案数组中。然后，如果 \(v \times 10 \leq n\)，我们将 \(v\) 更新为 \(v \times 10\)；否则，如果 \(v \bmod 10 = 9\) 或者 \(v + 1 > n\)，我们就循环将 \(v\) 除以 \(10\)。循环结束后，我们将 \(v\) 加一。继续迭代，直到我们添加了 \(n\) 个数到答案数组中。

时间复杂度 \(O(n)\)，其中 \(n\) 是给定的整数 \(n\)。忽略答案数组的空间消耗，空间复杂度 \(O(1)\)。

Python3JavaC++GoTypeScriptRustJavaScript

class Solution:
    def lexicalOrder(self, n: int) -> List[int]:
        ans = []
        v = 1
        for _ in range(n):
            ans.append(v)
            if v * 10 <= n:
                v *= 10
            else:
                while v % 10 == 9 or v + 1 > n:
                    v //= 10
                v += 1
        return ans

class Solution {
    public List<Integer> lexicalOrder(int n) {
        List<Integer> ans = new ArrayList<>(n);
        int v = 1;
        for (int i = 0; i < n; ++i) {
            ans.add(v);
            if (v * 10 <= n) {
                v *= 10;
            } else {
                while (v % 10 == 9 || v + 1 > n) {
                    v /= 10;
                }
                ++v;
            }
        }
        return ans;
    }
}

class Solution {
public:
    vector<int> lexicalOrder(int n) {
        vector<int> ans;
        int v = 1;
        for (int i = 0; i < n; ++i) {
            ans.push_back(v);
            if (v * 10 <= n) {
                v *= 10;
            } else {
                while (v % 10 == 9 || v + 1 > n) {
                    v /= 10;
                }
                ++v;
            }
        }
        return ans;
    }
};

func lexicalOrder(n int) (ans []int) {
    v := 1
    for i := 0; i < n; i++ {
        ans = append(ans, v)
        if v*10 <= n {
            v *= 10
        } else {
            for v%10 == 9 || v+1 > n {
                v /= 10
            }
            v++
        }
    }
    return
}

function lexicalOrder(n: number): number[] {
    const ans: number[] = [];
    let v = 1;
    for (let i = 0; i < n; ++i) {
        ans.push(v);
        if (v * 10 <= n) {
            v *= 10;
        } else {
            while (v % 10 === 9 || v === n) {
                v = Math.floor(v / 10);
            }
            ++v;
        }
    }
    return ans;
}

impl Solution {
    pub fn lexical_order(n: i32) -> Vec<i32> {
        let mut ans = Vec::with_capacity(n as usize);
        let mut v = 1;
        for _ in 0..n {
            ans.push(v);
            if v * 10 <= n {
                v *= 10;
            } else {
                while v % 10 == 9 || v + 1 > n {
                    v /= 10;
                }
                v += 1;
            }
        }
        ans
    }
}

/**
 * @param {number} n
 * @return {number[]}
 */
var lexicalOrder = function (n) {
    const ans = [];
    let v = 1;
    for (let i = 0; i < n; ++i) {
        ans.push(v);
        if (v * 10 <= n) {
            v *= 10;
        } else {
            while (v % 10 === 9 || v === n) {
                v = Math.floor(v / 10);
            }
            ++v;
        }
    }
    return ans;
};

386. 字典序排数

题目描述

解法

方法一：迭代

评论