加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
思路解析：

非9加1.	return

是9置0,  继续循环

如果+1后digits[0] = 0,则插入1在最前面，return。
class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        for i in range(len(digits)):
            if digits[len(digits)-i-1] != 9:
                digits[len(digits)-i-1] += 1
                return digits
            else:
                digits[len(digits)-i-1] = 0
                if digits[0] == 0:
                    digits.insert(0, 1)
                    return digits

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]

输出: [1,2,4]

解释: 输入数组表示数字 123。

示例 2:

输入: [4,3,2,1]

输出: [4,3,2,2]

解释: 输入数组表示数字 4321。

解法：

主要可以分为三种情况：

末位无进位，则末位加一即可，因为末位无进位，前面也不可能产生进位，比如 16 => 17
	
末位有进位，在中间位置进位停止， 539 => 540
	
末位有进位，并且一直进位到最前方导致结果多出一位， 999 => 1000
使用迭代器解决：

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        for(auto iter = digits.end()-1;iter >= digits.begin();iter--)
        {
            *iter = *iter +1;
            if(*iter == 10)
            {
                *iter = 0;
                if(iter == digits.begin())
                {
                    digits.insert(iter,1);
                }
            }
            else
                break;
        }
        return digits;
    }
};

使用索引解决：

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        for(int i = digits.size()-1;i>=0;i--)
        {
            if(digits[i] == 9)
            {
                digits[i] = 0;
            }
            else 
            {
                digits[i] += 1;
                break;
            }
        }
        if(digits[0] == 0)
        {
            digits.push_back(0);
            digits[0] = 1;
        }
        return digits;
    }
};

这两种性能差不多。

 题目:  有一个用int数组表示的数字 digits, 求digits 加一运算后的int数组？
例如 ：digits ={1,0}  , 加一运算后就是 {1,1};  digits= {9,9}, 加一运算后就是{1，0，0}
思路：一般情况下，直接使用digits[digits.length-1]++,就可以了，但是如果末尾是9的话，必须给这个数字前一位加1，最麻烦就是第一位也是9，那么这个数组长度就需要加一了，所以，只要设置一个boolean型来监控当前这位是否超过9。
 
public int[] plusOne(int[] digits) {
		if (digits.length < 1)
			return digits;
		boolean flag = false;  //判断当前是否超过9；
		int index = digits.length - 1;
		int i = digits[index] + 1;
		digits[index]++;
		if (i >= 10) {
			flag = true;
			digits[index] = digits[index] - 10;
		} else {
			
			return digits;
		}
		for (int j = index - 1; j > -1; j--) {

			int k = ++digits[j];
			if (k < 10) {
				flag = false;
				break;
			} else {
				digits[j] -= 10;
			}

		}
		if (flag) {
			int[] newdigits = new int[digits.length + 1];
			newdigits[0] = 1; //超过第一位9的话，需要前面进一位。
			for (int k = 0; k < digits.length; k++) {
				newdigits[k + 1] = digits[k];
			}
			return newdigits;
		}

		return digits;
	}
 

描述
给定一个非负数，表示一个数字数组，在该数的基础上+1，返回一个新的数组。

该数字按照数位高低进行排列，最高位的数在列表的最前面。

您在真实的面试中是否遇到过这个题？  
样例
给定 [1,2,3] 表示 123, 返回 [1,2,4].

给定 [9,9,9] 表示 999, 返回 [1,0,0,0].
题目链接
分析
直接在原数组上面操作，时间复杂度为O(n)，空间复杂度为O(1)
程序

class Solution {
public:
	/**
	* @param digits: a number represented as an array of digits
	* @return: the result
	*/
	vector<int> plusOne(vector<int> &digits) {
		// write your code here
		int size = digits.size();
		int index = size - 1;//从最后一位开始算
		while(index >= 0){
		    if(++digits[index] == 10){//当前数+1等于10，则赋值为0，index-1
		        digits[index--] = 0;
		    }
		    else{//不需要进位，则直接退出
		        break;
		    }
		}
		if(index == -1)//面对999，这种情况，由于上面已经赋值为0，只需头部插1
		    digits.insert(digits.begin(), 1);
		return digits;

	}
};