CareerCup

public ListNode plusOne(ListNode head) {
        if(head == null) return head;
        
        ListNode newHead = reverse(head);
        head = newHead;
        int sum = 1;
        while(head != null)
        {
            sum += head.val;
            head.val = sum%10;
            sum/=10;
            if(sum==0 || head.next == null)
                break;
            head = head.next;
        }
        if(sum > 0)
        {
            head.next = new ListNode(sum);
        }
        return reverse(newHead);
    }
    
    private ListNode reverse(ListNode head)
    {
        ListNode newHead = null, t;
        while(head != null)
        {
            t = head;
            head = head.next;
            t.next = newHead;
            newHead = t;
        }
        return newHead;
    }

I assume it's a singly linked list, and the head place has greater value than the tail place.
Looks like the requirement of O(1) space doesn't leave a lot of choice.

#include <iostream>

using namespace std;

class Node {
	public:
		Node(int val)
		{
			val_ = val;
			next_ = NULL;
		}
		int val_;
		Node *next_;
};

Node *AddDigit(Node *head, int digit)
{
	int size = 0;
	for (Node *n = head; n != NULL; n = n->next_) {
		++size;
	}
	int carry = digit;
	for (int i = size; i > 0 && carry != 0; --i) {
		Node *n = head;
		for (int j = 0; j < i - 1; ++j) {
			n = n->next_;
		}
		int sum = n->val_ + carry;
		n->val_ = sum % 10;
		carry = sum >= 10 ? 1 : 0;
	}
	if (carry != 0) {
		Node *new_head = new Node(carry);
		new_head->next_ = head;
		head = new_head;
	}
	return head;
}

void Print(Node *head)
{
	for (Node *n = head; n != NULL; n = n->next_) {
		cout << n->val_ << ", ";
	}
	cout << "\n";
}

int main()
{
	Node *head = NULL;
	for (int i = 0; i < 100; ++i) {
		head = AddDigit(head, 1);
		Print(head);
	}
    return 0;
}

Node *temp = root;
while(temp->next){
temp= temp -> next;
}
if(!((temp->next->val+k)/10)){
temp->next->val = temp->next->val+k;
}
else{
temp->val = temp->val + (temp->next->val+k)/10;
temp->next->val = (temp->next->val+k)%10;
}