LeetCode386.字典序排数-CSDN博客

本文链接：https://blog.csdn.net/qq_53947552/article/details/124254962

📜个人简介

⭐️个人主页：摸鱼の文酱博客主页🙋‍♂️
🍑博客领域：java编程基础,mysql
🍅写作风格：干货,干货,还是tmd的干货
🌸精选专栏：【Java】【mysql】【算法刷题笔记】
🎯博主的码云gitee，平常博主写的程序代码都在里面。
🚀支持博主：点赞👍、收藏⭐、留言💬
🍭作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！

文章目录

📃字典序排数

📃字典序排数

🎯1.原题链接

字典序排数

🎯2.题目要求

给你一个整数n，按字典序返回范围[1, n]内所有整数。
你必须设计一个时间复杂度为O(n)且使用 O(1)额外空间的算法。

样例输入: n = 13

样例输出: [1,10,11,12,13,2,3,4,5,6,7,8,9]

🎯3.基础框架

java版本的基础框架代码如下:

class Solution {
    public List<Integer> lexicalOrder(int n) {
    }
}

c版本

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* lexicalOrder(int n, int* returnSize){
  
}

🎯4.解题思路

1.由于本题限制了时间复杂度为O(n)且使用 O(1)额外空间,所以不能选择直接遍历排序
2.那么对于一个整数 number，它的下一个字典序整数对应下面的规则：

3.字典序最小的整数为 number=1，我们从它开始，然后依次获取下一个字典序整数，加入结果中，结束条件为已经获取到n个整数。

🎯5.完整代码

java

 public static List<Integer> lexicalOrder(int n) {
        List<Integer> ret = new ArrayList<Integer>();
        int number = 1;
        for (int i = 0; i < n; i++) {
            ret.add(number);
            if (number * 10 <= n) {
                number *= 10;
            } else {  //遍历个位的数
                while (number % 10 == 9 || number >= n) { //当number个位数变成9,十位数要加1
                                                        //或者当number=n时,剩下的就是[number/10+1,9];
                    number /= 10; //除以10给十位进1或者遍历剩下的[number/10+1,9]
                }
                number++;
            }
        }
        return ret;
    }

递归版本

class Solution {
    public List<Integer> lexicalOrder(int n) {
        List<Integer> ans = new ArrayList<>();
        public List<Integer> lexicalOrder(int n) {
            for (int i = 1; i <= 9; i++) dfs(i, n);
            return ans;
    }
    void dfs(int cur, int limit) {
            if (cur > limit) return ;
            ans.add(cur);
            for (int i = 0; i <= 9; i++) dfs(cur * 10 + i, limit);
        }
}

c语言

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
void  backTrack(int n,int *returnNums, int* returnSize,int sum)
{
    if(sum > n)
    {
        return ;
    }

    returnNums[*returnSize ] = sum;
    *returnSize = *returnSize + 1;
    //第二位可以选择零
    //0-9
    for(int i = 0; i < 10; i++)
    {
        backTrack(n,returnNums,returnSize,sum*10 + i);
    }

}


int* lexicalOrder(int n, int* returnSize)
{
    //回溯
    *returnSize = 0;
    int *returnNums = (int *)malloc(sizeof(int)*n);
    //不能从0开始遍历
    //1 - 9
    for(int i = 1; i < 10; i++)
    {
        backTrack(n,returnNums,returnSize,i);
    }
    return returnNums;
}