刷题啦刷题啦，剑指offer好像比较有名，所以就在牛客网上刷这个吧~
btw，刷了一些题发现编程之美的题好典型啊！！有不少都在笔试遇到过或者是特别有名之前做过的题。后悔没早点刷T T
1.二维数组中的查找
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路就是从右上角开始，比target大就向左移一位找小一点的，比target小就向下移找大一点的，直到找到为止。
public class Solution {
public boolean Find(int target, int [][] array) {
if(array.length == 0 || array[0].length == 0){
return false;
}
int row = array.length;
int col = array[0].length;
for(int i = 0, j = col - 1; i < row && j >= 0;){
if(target == array[i][j]){
return true;
}
else if(target > array[i][j]){
i++;
continue;
}
else{
j--;
continue;
}
}
return false;
}
}
2.替换空格
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
public class Solution {
public String replaceSpace(StringBuffer str) {
StringBuffer sb = new StringBuffer();
for(int i = 0; i < str.length(); i++){
if(' ' == str.charAt(i)){
sb.append("%20");
}else{
sb.append(str.charAt(i));
}
}
return sb.toString();
}
}
3.从尾到头打印链表
输入一个链表，从尾到头打印链表每个节点的值。
有几种解法：
第一种是正序链表元素并存在list后反转list；
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> list = new ArrayList<Integer>();
ListNode head = listNode;
while(head != null){
list.add(head.val);
head = head.next;
}
int num = list.size();
for(int i = 0; i < num/2; i++){
int temp = list.get(i);
list.set(i,list.get(num-1-i));
list.set(num-1-i,temp);
}
return list;
}
}
第二种是使用栈，入栈再出栈就会使原顺序反向；
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> list = new ArrayList<Integer>();
Stack<Integer> stack = new Stack<Integer>();
ListNode head = listNode;
while(head != null){
stack.push(head.val);
head = head.next;
}
while(!stack.empty()){
list.add(stack.pop());
}
return list;
}
}
第三种方法是用递归。
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> list = new ArrayList<Integer>();
ListNode head = listNode;
if(head != null){
list = printListFromTailToHead(head.next);
list.add(head.val);
}
return list;
}
}
4.重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
之前分析二叉树的帖子已经写过一次了，这次再写发现root.right那一行递归中最后一个参数（表明此时前序中的root位置）很容易写错。index-inFrom是在中序中当前左子树的结点数目，preIndex是指从此时的前序root算起。
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if(null == pre || pre.length == 0) return null;
return construct(pre, in, 0, in.length - 1, 0);
}
public TreeNode construct(int [] pre, int [] in, int inFrom, int inTo, int preIndex){
if(inFrom > inTo) return null;
TreeNode root = new TreeNode(pre[preIndex]);
int index = inFrom;
for(; index <= inTo; index++){
if(in[index] == pre[preIndex]){
break;
}
}
root.left = construct(pre, in, inFrom, index - 1, preIndex + 1);
root.right = construct(pre, in, index + 1, inTo, preIndex + index - inFrom + 1);
return root;
}
}
5.用两个栈实现队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
栈那篇文章分析过，记得挺简单的就不再写了。
6.旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
典型二分法，分几种情况讨论就行。要注意的是当元素变为2个的时候是个特殊情况，如果不拿出来单独讨论就会陷在low=mid<high这个循环里了。
很奇怪的是，这段代码在我自己给的几个测试用例还有leetcode下都是对的，可是牛客网上不对，不知道为什么。
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length == 0) return 0;
int low = 0;
int high = array.length - 1;
int mid;
while(low < high){
if(low == high - 1) return array[low] > array[high] ? array[high] : array[low];
mid = (low + high) / 2;
if(array[low] <= array[high]){
return array[low];
}
else{
if(array[low] <= array[mid]){
low = mid;
}else{
high = mid;
}
}
}
return array[low];
}
}
7.斐波那契数列
public int Fibonacci(int n) {
if(n == 0) return 0;
if(n == 1) return 1;
return Fibonacci(n-2) + Fibonacci(n-1);
}
8.跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
曾经面试问到过这题，我还很傻地说我做过这题，然后就换了一道我不会的......
思路想明白了就很简单，要求跳n级台阶的跳法f(n)，最后一步如果跳1级，跳法是f(n-1)；如果跳2级，跳法是f(n-2)，总跳法就是他们相加。
public int JumpFloor(int target) {
if(target == 1) return 1;
if(target == 2) return 2;
return JumpFloor(target - 1) + JumpFloor(target - 2);
}
9.变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
按照上面一样的思路，只是需要把所有情况累加起来。
public int JumpFloorII(int target) {
if(target == 0 || target == 1) return 1;
int res = 0;
for(int i = 0; i < target; i++){
res += JumpFloorII(i);
}
return res;
}
10.矩形覆盖
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
跟跳台阶相似，f(n) = f(n-1) + f(n-2)。f(n-1)情况是加一块竖矩形，f(n-2)情况是加两块横矩形。
public int RectCover(int target) {
if(target == 0) return 0;
if(target == 1) return 1;
if(target == 2) return 2;
return RectCover(target-1) + RectCover(target-2);
}
11.二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
(n-1) & n 会让从左往右第一个1变为0，一直操作直到整个数为0。
public int NumberOf1(int n) {
int count = 0;
while(n != 0){
count++;
n = (n-1) & n;
}
return count;
}
12.数值的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
关键是考虑到exponent为负的情况。
public double Power(double base, int exponent) {
if(exponent == 0) return 1;
if(exponent < 0){
return 1/base * Power(base,exponent + 1);
}
return base * Power(base,exponent - 1);
}
13.调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
第一个做法是使用一个新数组，遍历原数组按次序把奇数储存在新数组中，再遍历原数组把偶数储存在后面，最后复制新数组给原数组。
public void reOrderArray(int [] array) {
int[] a = new int[array.length];
int j = 0;
for(int elem : array){
if(elem % 2 != 0){
a[j++] = elem;
}
}
for(int elem : array){
if(elem % 2 == 0){
a[j++] = elem;
}
}
for(int i = 0; i < array.length; i++){
array[i] = a[i];
}
}
第二种方法是采用插入排序的思想。
public void reOrderArray(int [] array) {
for(int i = 1; i < array.length; i++){
if(array[i] % 2 != 0){
int odd = array[i];
int j = i - 1;
for(; j >= 0; j--){
if(array[j] % 2 == 0){
array[j+1] = array[j];
}else{
break;
}
}
array[j+1] = odd;
}
}
}
还可以采取冒泡排序的思路，不过差不多啦。
14.链表中倒数第k个结点
输入一个链表，输出该链表中倒数第k个结点。
可以用快慢结点的思想，让快结点先走k步，然后快慢同时走，快结点到头了慢结点也就到倒数第k了。要注意k可没确保是正确的，可能比链表结点数要大，所以在先走k步时就要时刻判null了。
public ListNode FindKthToTail(ListNode head,int k) {
ListNode fast = head;
ListNode slow = head;
for(int i = 0; i < k; i++){
if(fast == null) return null;
fast = fast.next;
}
while(fast != null){
fast = fast.next;
slow = slow.next;
}
return slow;
}
15.反转链表
输入一个链表，反转链表后，输出链表的所有元素。
public ListNode ReverseList(ListNode head) {
if(head == null || head.next == null) return head;
ListNode prev = head;
ListNode curr = head.next;
prev.next = null;
while(curr != null){
ListNode next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
}
ListNode p = prev;
while(p != null){
System.out.println(p.val);
p = p.next;
}
return prev;
}
16.合并两个排序的链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
之前写过iterative版本的，比较冗长，用recursive版本更短更好理解。
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1 == null) return list2;
if(list2 == null) return list1;
ListNode head = null;
if(list1.val < list2.val){
head = list1;
head.next = Merge(list1.next, list2);
}else{
head = list2;
head.next = Merge(list1,list2.next);
}
return head;
}
17.树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
牛客网的定义不是很清楚，我觉得应该再加上两点：1.结构相同且对应位置的值也相同；2.树[1,2]是树[1,2,3]的子结构。
如果参考leetcode上判subtree那道题：
Given two non-empty binary trees s and t, check whether tree t has exactly the same structure and node values with a subtree of s. A subtree of s is a tree consists of a node in s and all of this node's descendants. The tree s could also be considered as a subtree of itself.
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public boolean isSubtree(TreeNode root1, TreeNode root2) {
if(root2 == null || root1 == null) return false;
if(sameTree(root1, root2)) return true;
return isSubtree(root1.left, root2) || isSubtree(root1.right, root2);
}
public boolean sameTree(TreeNode root1, TreeNode root2){
if(root1 == null && root2 == null) return true;
if(root1 != null && root2 != null && root1.val == root2.val) return sameTree(root1.left, root2.left) && sameTree(root1.right, root2.right);
return false;
}
}
如果是牛客网上的思路，应该把判相同的函数改为判子结构函数，当对应位置子结构没了而复结构不一定没了，仍然为真。
public class Solution {
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
if(root2 == null || root1 == null) return false;
return isSubTree(root1, root2) || HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
}
public boolean isSubTree(TreeNode root1, TreeNode root2){
if(root2 == null) return true;
if(root1 == null) return false;
if(root1.val == root2.val) {
return isSubTree(root1.left, root2.left) && isSubTree(root1.right, root2.right);
}
return false;
}
}
18.二叉树的镜像
二叉树里写过不说了。
19.顺时针打印矩阵
构造一个数组step来记录上下左右的单位偏移量，用对应的multiple来记录偏移量数目，count%4作为数组索引。这样让上下左右在代码中都能一视同仁。可是不对，也没调出来结果，先贴在这里吧。
public static ArrayList<Integer> printMatrix(int [][] matrix) {
ArrayList<Integer> list = new ArrayList<Integer>();
if(matrix.length == 0 || matrix[0].length == 0) return list;
int[] step = {1,1,-1,-1}; //right, down, left, up
int[] limit = {matrix[0].length, matrix.length, 0, 0}; //jHigh, iHigh, jLow, iLow
int count = 0;
int i = 0, j = 0;
while(limit[2] < limit[0] || limit[3] < limit[1]){
int[] multiple = {0,0,0,0};
multiple[count]++;
while(i >= limit[3] && i < limit[1] && j >= limit[2] && j < limit[0]){
//System.out.println("i = " + i + ", j = " + j);
list.add(matrix[i][j]);
i += step[1]*multiple[1] + step[3]*multiple[3];
j += step[0]*multiple[0] + step[2]*multiple[2];
}
limit[count%4] -= step[count%4];
count = (count+1) % 4;
}
return list;
}
20.包含Min函数的栈
栈的帖子中写过，笔试题也遇到过。
public class Solution {
Stack<Integer> stack = new Stack<Integer>();
Stack<Integer> minStack = new Stack<Integer>();
public void push(int node) {
stack.push(node);
if(minStack.empty() || node < minStack.peek()) minStack.push(node);
else minStack.push(minStack.peek());
}
public void pop() {
stack.pop();
minStack.pop();
}
public int top() {
return minStack.peek();
}
public int min() {
return minStack.peek();
}
}
21.栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
又是在栈文章里面写过的题，重新写了一遍，简化了一个步骤：可以不用先把popA里面元素Push进去再与popA比较，而是直接比较当前的popA和pushA元素，相等就直接跳过。
public boolean IsPopOrder(int [] pushA,int [] popA) {
Stack<Integer> stack = new Stack<Integer>();
int j = 0;
for(int i = 0; i < pushA.length;i++){
if(popA[j] == pushA[i]){
j++;
}else{
stack.push(pushA[i]);
}
}
while(j < popA.length){
if(stack.pop() != popA[j++]) return false;
}
return true;
}
22.从上往下打印二叉树
层序遍历（广度优先），二叉树里写过的，这次两分钟一次通过！
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
ArrayList<Integer> list = new ArrayList<Integer>();
if(root == null) return list;
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while(queue.peek() != null){
int len = queue.size();
for(int i = 0; i < len; i++){
TreeNode temp = queue.poll();
list.add(temp.val);
if(temp.left != null) queue.offer(temp.left);
if(temp.right != null) queue.offer(temp.right);
}
}
return list;
}
23.二叉搜索树的后续遍历
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
因为是后序遍历，所以最后一个数是根节点。根节点比左子树所有结点大，比右子树所有结点小，所以先找到第一个比根结点大的结点，以此位置区分左子树和右子树，左子树已经保证了都比根小了，再一个个判断右边是不是都比根结点大，如果不是，肯定是false。再递归对左子树和右子树判断。
public class Solution {
public boolean VerifySquenceOfBST(int [] sequence) {
if(sequence.length == 0) return false;
return isPostOrder(sequence, 0, sequence.length - 1);
}
//end inclusive
public boolean isPostOrder(int[] postOrder, int start, int end){
if(start < end){
int root = postOrder[end];
int index = start;
for(; index < end; index++){
if(root < postOrder[index]){
break;
}
}
for(int i = index + 1; i < end; i++){
if(root > postOrder[i]) return false;
}
return isPostOrder(postOrder, start, index - 1) && isPostOrder(postOrder, index, end - 1);
}
return true;
}
}
24.二叉树中和为某一值的路径
输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
用递归解决，临界条件是叶节点刚好等于某值，说明这是一条有效路径，所以开一个新list添加进结果；递归时不断把路径上的点加到list最前面（combine函数）。
public class Solution {
public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
ArrayList<ArrayList<Integer>> l = new ArrayList<ArrayList<Integer>>();
if(root == null) return l;
if(root.val == target && root.left == null && root.right == null){
ArrayList<Integer> temp = new ArrayList<Integer>();
temp.add(root.val);
l.add(temp);
return l;
}
ArrayList<ArrayList<Integer>> left = combine(root.val, FindPath(root.left, target - root.val));
ArrayList<ArrayList<Integer>> right = combine(root.val, FindPath(root.right, target - root.val));
l.addAll(left);
l.addAll(right);
return l;
}
public ArrayList<ArrayList<Integer>> combine(int first, ArrayList<ArrayList<Integer>> l){
for(int i = 0; i < l.size(); i++){
l.get(i).add(0, first);
}
return l;
}
}
25.复杂链表的复制
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
关键是random指向任意一个节点，所以不能按原链表节点的random值新建它。先使用HashMap建立原链表主链（不含random）节点和对应复制的链表结点之间的映射，再遍历链表通过HashMap来确定各节点的random。
/*
public class RandomListNode {
int label;
RandomListNode next = null;
RandomListNode random = null;
RandomListNode(int label) {
this.label = label;
}
}
*/
public RandomListNode Clone(RandomListNode pHead){
if(pHead == null) return null;
HashMap<RandomListNode,RandomListNode> map = new HashMap<RandomListNode,RandomListNode>();
RandomListNode newHead = new RandomListNode(pHead.label);
RandomListNode r = newHead;
RandomListNode p = pHead;
map.put(p,r);
while(p.next != null){
r.next = new RandomListNode(p.next.label);
p = p.next;
r = r.next;
map.put(p,r);
}
p = pHead;
r = newHead;
while(p != null){
r.random = map.get(p.random);
p = p.next;
r = r.next;
}
return newHead;
}
26.二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
函数返回的是链表头结点（最小值），根据二叉搜索树的特点，递归得出右子树的最小值应紧跟在在根结点后。左子树有些不一样，递归得出的是左子树的最小值，而我们应找到左子树最大值，调整指针让它在根结点前。所以再用一个函数求最大值结点。
要注意是先convert后调整指针指向，否则convert的对象是一棵已被破坏的树。
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public TreeNode Convert(TreeNode pRootOfTree) {
TreeNode res = pRootOfTree;
if(pRootOfTree == null || (pRootOfTree.left == null && pRootOfTree.right == null)) return res;
if(pRootOfTree.left != null){
res = Convert(pRootOfTree.left);
TreeNode big = biggest(pRootOfTree.left);
big.right = pRootOfTree;
pRootOfTree.left = big;
}
if(pRootOfTree.right != null){
TreeNode small = Convert(pRootOfTree.right);
pRootOfTree.right = small;
small.left = pRootOfTree;
}
return res;
}
public TreeNode biggest(TreeNode root){
if(root.right == null) return root;
return biggest(root.right);
}
}
27.字符串的排列
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
又是全排列.......注意这次要字典顺序而且结果不重复。
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Collections;
public class Solution {
public ArrayList<String> Permutation(String str) {
if(str == null || str.length() == 0) return new ArrayList<String>();
ArrayList<String> res = new ArrayList(new HashSet(helper(str.toCharArray(),0)));
Collections.sort(res);
return res;
}
public void swap(char[] array, int i, int j){
char temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public ArrayList<String> helper(char[] array, int start){
ArrayList<String> list = new ArrayList<String>();
if(start == array.length - 1){
list.add(String.valueOf(array[start]));
}
for(int i = start; i < array.length; i++){
swap(array,start,i);
ArrayList<String> temp = helper(array, start + 1);
list.addAll(combine(array[start],temp));
swap(array,start,i);
}
return list;
}
public ArrayList<String> combine(char ch, ArrayList<String> list){
for(int i = 0; i < list.size(); i++){
list.set(i, String.valueOf(ch) + list.get(i));
}
return list;
}
}
28.数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
import java.util.HashMap;
import java.util.Map;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
for(int elem: array){
if(map.containsKey(elem)){
int count = map.get(elem);
map.put(elem,map.get(elem) + 1);
}else{
map.put(elem,1);
}
}
for(Map.Entry<Integer,Integer> entry: map.entrySet()){
if(entry.getValue() > array.length / 2) return entry.getKey();
}
return 0;
}
}
29.最小的k个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
冒泡排序的前k次排序即可。算法复杂度O(kn)。
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> list = new ArrayList<Integer>();
if(k > input.length) return list;
for(int i = 0; i < k; i++){
for(int j = input.length - 1; j > i; j--){
if(input[j] < input[j - 1]){
int temp = input[j];
input[j] = input[j - 1];
input[j - 1] = temp;
}
}
list.add(input[i]);
}
return list;
}
31.连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)
32.整数中1出现的次数
求出113的整数中1出现的次数,并算出1001300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数。
脑袋都要想破了，有点点麻烦的一道题。
思路是先统计个位数出现1的次数，再统计十位数出现1的次数......
while循环里每次对一个位数统计，要注意的是quotient2%10计算的是当位数的数字，如果大于1，要加一个位数的满轮次；如果等于1，不满一个位数但有剩余，要单独算出这个extra。
public int NumberOf1Between1AndN_Solution(int n) {
int num = 0;
int quotient1 = -1;
int count = 0;
while(quotient1 != 0){
int dividend2 = (int)Math.pow(10.0,(double)count++);
int dividend1 = 10 * dividend2;
quotient1 = n/dividend1;
int quotient2 = n/dividend2;
int extra = 0;
int extra1 = 0;
if(quotient2%10 == 1){
extra = n % dividend2 + 1;
}else if(quotient2%10 != 0){
extra1 = 1;
}
num += (quotient1 + extra1) * dividend2 + extra;
}
return num;
}
33.把数组排成最小的数
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
就排前排后而言，这些数之间是有相对大小的。对两个数而言，把他们拼接起来，拼在前面更小说明这个数更“小”。Arrays有一个
sort(T[] a, Comparator<? super T> c) 函数，可以通过自定义compare方法来排序a。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class Solution {
public String PrintMinNumber(int [] numbers) {
String s = "";
if(numbers == null || numbers.length == 0) return s;
String[] sArray = new String[numbers.length];
for(int i = 0; i < numbers.length; i++){
sArray[i] = String.valueOf(numbers[i]);
}
Arrays.sort(sArray, new Comparator<String>(){
public int compare(String s1, String s2){
return (s1+s2).compareTo(s2+s1);
}
});
for(String elem: sArray){
s += elem;
}
return s;
}
}