每天几道编程题

1.在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

/*
这个二维数组是有序的从左向右看递增，从上到下递增
从左下角开始查询，比他大的右移，比它小的上移
*/
class Solution {
public:
    bool Find(int target, vector<vector<int> > array) 
    {
        int row = array.size();   //行数
        int col = array.size();   //列数
        //从左下角开始寻找
        int i = 0;
        int j = 0;
        for( i = row - 1,j =0;i >= 0 && j < col;)
        {
            if( target == array[i][j])
            {
                return true;
            }
            if( target < array[i][j])
            {
                i --;
            }
            if( target > array[i][j])
            {
                j ++;
            }
        }
        return false;
    }
};

2.请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

class Solution {
public:
    void replaceSpace(char *str, int length) {
        if (str ==NULL || length <= 0)
            return;
        int origi_len = 0;
        int spacenum = 0;
        for (int i = 0; str[i] != '\0'; i++)
        {
            origi_len++;
            if (str[i] == ' ')
                spacenum++;
        }
        int new_len = origi_len + spacenum * 2;
        int p = origi_len;
        int q = new_len;
        while (q >= 0)
        {
            if (str[p] == ' ')
            {
                str[q--] = '0';
                str[q--] = '2';
                str[q--] = '%';
            }
            else
                str[q--] = str[p];
            p--;
        }
    }
};

3.输入一个链表，从尾到头打印链表每个节点的值。
（1）

//插入数据到链表
struct ListNode
{
    int value;
    ListNode *next;
};

void AddToTail(ListNode **head,int val)
{
    ListNode *temp = new ListNode();
    temp->next = NULL;
    temp->value = val;
    if( *head == NULL)
    {
        *head = temp;
    }
    else
    {
        ListNode *node = *head;
        while( node->next != NULL)
        {
            node = node->next;
        }
        node->next = temp;
    }
}
//从尾到头打印链表
void Print(ListNode *head)
{
    if( head == NULL)
    {
        return ;
    }
    stack<ListNode *> stack;
    ListNode *node = head;
    while( node != NULL)
    {
        stack.push(node);
        node = node->next;
    }
    while( !stack.empty())
    {
        node = stack.top();
        cout<<node->value<<" ";
        stack.pop();
    }
}

（2）

class Solution {
public:
    vector<int> printListFromTailToHead(struct ListNode* head) {
//利用栈的逆序输出特性        
        stack<int> stack;
        vector<int> vector;
        struct ListNode *p = head;
        if (head != NULL) {
            stack.push(p->val);
            while((p=p->next) != NULL) {
                stack.push(p->val);
            }
            while(!stack.empty()) {
                vector.push_back(stack.top());
                stack.pop();
            }
        }
        return vector;
    }

};