编程笔记二

4.重建二叉树

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M

• 解法思路：
  1.前序找根节点；
  2.通过根节点将中序分割为左子树和右子树；
  3.重复操作。

class Solution {
public:
	TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin) {
		if (pre.empty())
			return NULL;

		TreeNode *bTree;
		vector<int> pre_left, pre_right, vin_left, vin_right;

		bTree = new TreeNode(pre[0]);

		vector<int>::iterator rootIndx = find(vin.begin(), vin.end(),pre[0]);
		vector<int>::iterator it = vin.begin();
		int dis = distance(it, rootIndx);

		pre_left.assign(pre.begin() + 1, pre.begin() + dis + 1);
		pre_right.assign(pre.begin() + dis + 1, pre.end());
		vin_left.assign(vin.begin(), vin.begin() + dis);
		vin_right.assign(vin.begin() + dis + 1, vin.end());

		bTree->left = reConstructBinaryTree(pre_left, vin_left);
		bTree->right = reConstructBinaryTree(pre_right, vin_right);

		return bTree;
	}
	
};

运行时间：12ms
占用内存：512k

5.利用栈实现队列

题目：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M

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

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

		reData = stack2.top();
		stack2.pop();

		return reData;
	}

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

运行时间：4ms
占用内存：476k

6.旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
时间限制：C/C++ 3秒，其他语言6秒 空间限制：C/C++ 32M，其他语言64M

• 解法一（暴力求解）：
• 解法思路：
  由于子序列均符合非递减排序的规律，因此，不符合该规律的元素便是最小数字。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.empty())
        return 0;
        int min = rotateArray[0];
        for(auto it = rotateArray.begin(); it != rotateArray.end(); it++)
        {
            if (min > *it)
            {
                min = *it;
                break;
            }
        }
        return min;
    }
};

时间复杂度：$O(n)$
空间复杂度：$O(1)$

运行时间：34ms
占用内存：504k

• 解法二（二分查找）：
• 解法思路：
  1.由于子序列均符合非递减排序的规律，因此，不符合该规律的元素便是最小数字。
  2.二分查找的变种，由于没有具体的值，那么就根据mid和low、high比较缩小范围。左右子序列为非递减，且左子序列最小值 >= 右子序列的最大值，因此:
  (1).arr[mid] > arr[low] :最小值所在子序列[mid,high]。
  (2) arr[mid] < arr[low]:说明mid在右子非递减序列上，或arr[mid] == arr[low]。因此，比较arr[mid]和arr[high]:
     (a).arr[mid] > arr[low] & arr[mid] < arr[high]: 最小值所在子序列[low,high]。否则最小值在连续相等的值中间，因此low++缩小范围。

时间复杂度：$O(logn)$
空间复杂度：$O(1)$

class Solution {
public:
	int minNumberInRotateArray(vector<int> rotateArray) {
		if (rotateArray.empty())
			return 0;
		int len = rotateArray.size();
		int low = 0, mid, high = len - 1;

		while (low < high)
		{
			mid = (low + high) / 2;
			if (rotateArray[low] < rotateArray[high])
				return rotateArray[low];

			if (rotateArray[low] < rotateArray[mid])
			{
				low = mid;
			}
			else if (rotateArray[mid] < rotateArray[high])
				high = mid;
			else
				low++;
		}
		return rotateArray[low];
	}
};

运行时间：34ms
占用内存：588k

7.旋转数组的最小数字

题目描述:大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。n<=39
时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M

class Solution {
public:
    int Fibonacci(int n) {
        if (n < 1)
            return 0;
        if (n == 1 || n == 2)
            return 1;
        
        int add_1 = 1,add_2 = 1,sum = 0;
        
        for (int i = 2; i < n; i++)
        {
            sum = add_1 + add_2;
            add_1 = add_2;
            add_2 = sum;
        }
        return sum;
    }
};

运行时间：4ms
占用内存：496k