剑指offer——面试题17:打印从1到最大的n位数

用字符串模拟加法:

 1 #include"iostream"
 2 #include"string.h"
 3 using namespace std;
 4
 5 bool AddOne(char *number,int n);
 6 void PrintNumber(char *number,int n);
 7
 8 void Print1ToN(int n)
 9 {
10     if(n<=0)
11         return;
12     char *number=new char[n+1];
13     memset(number,‘0‘,n);
14     number[n]=‘\0‘;
15     while(AddOne(number,n))
16     {
17         PrintNumber(number,n);
18     }
19     delete[] number;
20 }
21
22 bool AddOne(char *number,int n)
23 {
24     bool isInRange=true;
25     int carry=0;
26     int iDigit;
27     for(int i=n-1;i>=0;i--)
28     {
29         iDigit=number[i]-‘0‘+carry;
30         if(i==n-1)
31             iDigit++;
32         if(iDigit>=10)
33         {
34             if(i==0)
35                 isInRange=false;
36             else
37             {
38                 carry=iDigit/10;
39                 iDigit%=10;
40                 number[i]=iDigit+‘0‘;
41             }
42         }
43         else
44         {
45             number[i]=iDigit+‘0‘;
46             break;
47         }
48     }
49     return isInRange;
50 }
51
52 void PrintNumber(char *number,int n)
53 {
54     bool firstNoZero=false;
55     for(int i=0;i<n;i++)
56     {
57         if(!firstNoZero&&number[i]!=‘0‘)
58         {
59             firstNoZero=true;
60         }
61         if(firstNoZero)
62             cout<<number[i];
63     }
64     cout<<endl;
65 }
66 int main()
67 {
68     int n;
69     while(cin>>n)
70     {
71         Print1ToN(n);
72     }
73     return 0;
74 }

还可以用全排列的思想,递归调用去解决:

 1 #include"iostream"
 2 using namespace std;
 3
 4 void Print1ToNRecursively(int *number,int length,int index);
 5 void PrintNumber(int *number,int n);
 6
 7 void Print1ToN(int n)
 8 {
 9     int *number=new int[n];
10
11     for(int i=0;i<10;i++)
12     {
13         number[0]=i;
14         Print1ToNRecursively(number,n,0);
15     }
16 }
17
18 void Print1ToNRecursively(int *number,int length,int index)
19 {
20     if(index==length-1)
21     {
22         PrintNumber(number,length);
23         return;
24     }
25     for(int i=0;i<10;i++)
26     {
27         number[index+1]=i;
28         Print1ToNRecursively(number,length,index+1);
29     }
30 }
31
32 void PrintNumber(int *number,int n)
33 {
34     int i=-1;
35     while(i<n&&number[++i]==0) continue;
36     while(i<n) cout<<number[i++];
37     cout<<endl;
38 }
39
40 int main()
41 {
42     int n;
43     while(cin>>n)
44     {
45         Print1ToN(n);
46     }
47     return 0;
48 }

原文地址:https://www.cnblogs.com/acm-jing/p/10406412.html

时间: 2024-11-05 15:55:41

剑指offer——面试题17:打印从1到最大的n位数的相关文章

剑指offer之面试题17合并两个排序的链表

问题描述: 输入两个递增的链表,合并这两个链表并使新链表中的结点仍然是按照递增排序的. 实现代码如下: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> struct List{ int date; struct List *next; }; struct List* doMergeList(struct List *P1head,struct List *P2head){ if(P1head==NU

剑指offer[面试题17:打印从1到最大的n位数]

题目:输入数字n,按顺序打印出从1到最大的n位十进制数.比如输入3,则打印出1.2.3一直到最大的三位数999. 思路: 隐藏考点:当输入的n很大时,用整型(int)或者长整型(long int)求最大的n位数都会溢出.也就是需要考虑大数问题. 用递归实现全排列,数字(用字符串容器装)的每一位都是0~9中的一个数,然后设置下一位.递归结束的条件是已经设置了数字的最后一位. class Solution { public: void PrintMaxOfDigits(int n){ if (n <

剑指Offer面试题17(Java版):合并两个排序的链表

题目:输入两个递增排序的链表,合并这两个链表并使新链表中的结点仍然是按照递增排序的.例如输入图中的链表1和链表2,则合并之后的升序链表3所示. 这是一个经常被各公司采用的面试题.在面试过程中,我们发现应聘者最容易犯两个错误:一是在写代码之前没有对合并的过程想清楚,最终合并出来的链表要么中间断开要么并没有递增排序:二是代码的鲁棒性方面存在问题,程序一旦有特殊的输入(如空链表)就会崩溃.接下来分析如何解决这个问题. 首先分析合并两个链表的过程.我们的分析从合并两个链表的头结点开始.链表1的头结点的值

剑指offer面试题17:合并两个排序的链表

题目:输入两个递增排序的链表,合并这两个链表并使新链表中的节点人是按照递增排序的.解题思路:两个链表分别都已经是有序的了,遍历链表的时候只要比较两个链表当前位置大小,取出最小的添加到新链表中. 可以有递归.循环两种方式来解决. 1 package Solution; 2 3 4 public class No17MergeSortedLists { 5 6 public static class ListNode { 7 int data; 8 ListNode next; 9 10 publi

【剑指offer 面试题17】合并两个排序的链表

思路: 比较两个链表端点值的大小,通过递归的方式排列. 1 #include <iostream> 2 using namespace std; 3 4 struct ListNode 5 { 6 int val; 7 ListNode *next; 8 ListNode(int v = 0):val(v), next(NULL){} 9 }; 10 11 ListNode *SortedListMerge(ListNode *phead1, ListNode *phead2) 12 { 13

剑指offer面试题17——合并两个排序的链表

题目1519:合并两个排序的链表 题目描述: 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则.(hint: 请务必使用链表.) 输入: 输入可能包含多个测试样例,输入以EOF结束.对于每个测试案例,输入的第一行为两个整数n和m(0<=n<=1000, 0<=m<=1000):n代表将要输入的第一个链表的元素的个数,m代表将要输入的第二个链表的元素的个数.下面一行包括n个数t(1<=t<=1000000):代表链表一中的元素.接

剑指offer之面试题17 :合并两个排序的链表

题目: 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. 思路1:让两个指针分别指向两个链表,谁小就将当前节点尾插入新链表中 代码:  /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public:     ListNode* Merge(ListNode* pHead1

剑指offer 面试题17—合并两个排序的链表

题目: 输入两个递增排序的链表,合并这两个链表并使得新链表中的节点仍然是按照递增排序的. 基本思想: 当我们得到两个链表中值较小的头结点并把它连接到已经合并的链表之后,两个链表剩余的节点依然是排序的,因此合并的步骤和之前的而不周是一样的.这就是典型的递归的过程. #include <iostream> using namespace std; typedef int ElemType;//数据类型模板 typedef struct Node//结点 { ElemType data; struc

LeetCode | 面试题17. 打印从1到最大的n位数【剑指Offer】【Python】

LeetCode 面试题17. 打印从1到最大的n位数[剑指Offer][Easy][Python][遍历] 问题 力扣 输入数字 n,按顺序打印出从 1 到最大的 n 位十进制数.比如输入 3,则打印出 1.2.3 一直到最大的 3 位数 999. 示例 1: 输入: n = 1 输出: [1,2,3,4,5,6,7,8,9] 说明: 用返回一个整数列表来代替打印 n 为正整数 思路 Python3代码 class Solution: def printNumbers(self, n: int