剑指offer题目合集：

题目描述

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

 

注意事项：递归时注意特殊情况，输入为一个空指针，率先判断head是否为空！

class Solution {
public:
    vector<int> Q;
    vector<int> printListFromTailToHead(ListNode* head) {
        if(head == NULL) return Q;
		if(head->next == NULL)
		{
			Q.push_back(head->val);
			return Q;
		}
		printListFromTailToHead(head->next);
		Q.push_back(head->val);
		return Q;
    }
};

题目描述

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

 

注意事项：可以少定义数组，精简为重

class Solution {
public:
	void replaceSpace(char *str,int length) {
    int count_tmp = 0; 
    for(int i=0;i<length;i++)
    {
        if(str[i]==' ')
        {
            count_tmp ++;
        }
    }
        for(int i = length-1;i >= 0;i--)
        {
            if(str[i]==' ')
            {
                count_tmp--;
                str[i+2*count_tmp] = '%';str[i+2*count_tmp+1]='2';str[i+2*count_tmp+2]='0';
                
            }
            else
            {
                str[i+count_tmp*2] = str[i];
            }
        }
        return;
	}
};

题目描述

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

 

方法一（fail，可能内存使用太多，不满足题目要求）

最暴力的思路，两个栈一个负责进，一个负责出。进的时候把元素都压到a栈里去，出的时候把a栈里的元素都弹出并且反压到b里面去，负责出栈的b则可以直接弹出。

class Solution
{
public:
    void push(int node) {
        if(stack1.empty()&&stack2.empty())
        {
            stack1.push(node);
        }
        else if(stack1.empty())
        {
            int a;
            while(!stack2.empty())
            {
                a = stack2.top();
                stack2.pop();
                stack1.push(a);
            }
            stack1.push(node);
        }
        else
        {
            stack1.push(node);
        }
    }

    int pop() {
        int res;
        if(stack2.empty())
        {
            while(!stack1.empty())
            {
                int a;
                a = stack1.top();
                stack2.push(a);
            }
            res = stack2.top();
            stack2.pop();
            return res;
        }
        else if(stack1.empty())
        {
            res = stack2.top();stack2.pop();
            return res;
        }
        return res;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

方法二（AC）

进队列直接放进a里，出队列如果b中的元素为空，则将所有a中的元素弹出并压倒b中，并弹出b的第一个作为return的值，如果b非空，则直接弹出b的一个元素作为return值即可。

class Solution
{
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
        if(stack2.empty())
        {
            while(!stack1.empty())
            {
                int a = stack1.top();
                stack1.pop();
                stack2.push(a);
            }
        }
        int res = stack2.top();
        stack2.pop();
        return res;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

方法一（自己想的）

根据该旋转数组的特性，前面的各个数应该是按照顺序排列的，依次从头开始遍历，如果遇到后一个数小于前一个数的情况，则该数字应为数组中最小的元素。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        for(int i = 0;i<rotateArray.size()-1;i++)
        {
            if(rotateArray[i]>rotateArray[i+1])
                return rotateArray[i+1];
        }
        return 0;
    }
};

方法二：（二分法）

可以使用二分法，如果

(1)array[mid] < array[right]表示mid到right处于后递增序列中，left到mid或者mid可能是最小值。right = mid；

(2)array[mid] > array[right]表示left到mid处于前递增序列中，mid以上可能是最小值。left = mid+1；

(3)array[mid] == array[right]这种情况高位高位只能递减判断。right = right-1；

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size() == 0)
            return 0;
        int left = 0,right = rotateArray.size()-1;
        while(left<right)							//注意此处的判断条件 
        {
            int mid = left+(right-left)/2;
            if(rotateArray[mid]<rotateArray[right])
            {
                right = mid;
            }
            else if(rotateArray[mid] == rotateArray[right])
            {
                right = right-1;
            }
            else
            {
                left = mid+1;
            }
        }
        return rotateArray[left];
    }
};