牛客剑指offer 1~10题解

最新推荐文章于 2022-07-20 09:50:27 发布

原创最新推荐文章于 2022-07-20 09:50:27 发布 · 203 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

剑指offer 专栏收录该内容

1 篇文章

订阅专栏

本文提供了一系列经典的编程问题及其解决方案，包括二维数组查找、字符串处理、链表操作、二叉树构造等，涵盖了数据结构和算法的基本知识点。

每道题目能满足要求运行完所有测试例子，但并不追求最优解，只供参考，不解之处可以留言一起交流，共勉，加油！

1.二维数组中的查找

题目描述

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

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if(array.size() == 0 || array[0].size() == 0)
            return false;
        int Count = array[0].size();
        for(int i =0;i<array.size();i++)
        {
            if(array[i][Count-1] > target)
            {
                for(int j = 0;j<Count;j++)
                {
                    if(array[i][j] == target)
                        return true;
                    continue;
                }
            }
            else if(array[i][Count-1] == target)
                return true;
            continue;
        }
        return false;
    }
};

2.替换空格

题目描述

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

class Solution {
public:
    void replaceSpace(char *str,int length) 
    {
        if (str == nullptr)
			return;
        
		int size = strlen(str) + 1;
		int spaceSize = 0;

		for (int i = 0; i<size;i++)
		{
			if (str[i] == ' ')
				spaceSize++;
		}
		if (size+2*spaceSize> length)
			return;

		for (int i = size - 1; i>-1; i--)
		{
			if (str[i] == ' ')
			{
				int len = strlen(str + i) + 1;
				moveTwo(str + i, len);
				str[i] = '%';
				str[i + 1] = '2';
				str[i + 2] = '0';
			}
			else
				continue;
		}
	}
    //内存集体向右移两个字节 并置\0前两个字节
    void moveTwo(char* str,int length)
    {
        for(int i = length-1;i > -1;i--)
        {
            int before = i;
            int after = i+2;
            str[after] = str[before];
        }
        str[0] = str[1] = ' ';
    }
};

3.从尾到头打印链表

题目描述

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

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        if(!head)
            return vector<int>();
        stack<int> Stack;
        while(head)
        {
            Stack.push(head->val);
            head = head->next;
        }
        vector<int> result;
        int size = Stack.size();
		for (int i = 0; i<size; i++)
		{
			result.push_back(Stack.top());
			Stack.pop();
		}
        return result;
    }
};

4.重建二叉树

题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin) {
		int kB = 0;
		int kE = pre.size() - 1;
		int k2B = 0;
		int k2E = vin.size() - 1;
		//TreeNode* result = Tree(pre, vin, nullptr,kB, kE, k2B, k2E);
		TreeNode* result = Tree(pre,vin);
		return result;
	}
    TreeNode* Tree(vector<int> pre, vector<int> vin) {
		if (pre.empty() || vin.empty())
			return nullptr;

		TreeNode* root = new TreeNode(pre[0]);

		int pos =  Pos(vin, pre[0]); //pos 不为pre size
		//int leftLen = pos;
		//int rightLen = vin.size() - pos -1;

		vector<int> p1;
		vector<int> v1;
		for (int i = 0; i < pos;i++)
		{
			p1.push_back(pre[i+1]);
			v1.push_back(vin[i]);
		}
		root->left = Tree(p1,v1);
	
		vector<int> p2;
		vector<int> v2;
		for (int i = pos +1; i < vin.size();i++)
		{
			p2.push_back(pre[i]);
			v2.push_back(vin[i]);
		}
		root->right = Tree(p2,v2);
		return root;
	}
    int Pos(vector<int>& pre,int target)
	{
		int result = 0;
		for (auto i = 0; i < pre.size();i++)
		{
			if (target == pre[i])
				return result;
			result++;
		}
		return result;
	}
};

5.用两个栈实现队列

题目描述

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

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

    int pop() {
        int front = -1;
        while(!stack1.empty())
        {
            int tmp = stack1.top();
            stack1.pop();
            stack2.push(tmp);
        }
       front = stack2.top();
        stack2.pop();
       while(!stack2.empty())
       {
           int tmp = stack2.top();
           stack2.pop();
           stack1.push(tmp);
       }
        return front;
    }

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

6.旋转数组的最小数字

题目描述

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

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

7.斐波那契数列

题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

n<=39

class Solution {
public:
    /*
    int Fibonacci(int n) {
        if(n <= 0)
            return 0;
        if(n == 1 || n == 2)
            return 1;
        return Fibonacci(n-1)+Fibonacci(n-2);
    }
    */
    int Fibonacci(int n) {
        if(n <= 0)
            return 0;
        if(n == 1 || n == 2)
            return 1;
        int result = 0;
        int ppre = 1;
        int pre = 1;
        for(int i = 3;i<=n;i++)
        {
            result = ppre+pre;
            ppre = pre;
            pre = result;
        }
        return result;
    }
};

8.跳台阶

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

class Solution {
public:
    int jumpFloor(int number) {
        if(number == 0 || number == 1)
            return 1;
        if(number == 2)
            return 2;
        int result = 0;
        int ppre = 1;
        int pre = 2;
        for(int i = 3;i<=number;++i)
        {
            result = ppre+pre;
            ppre = pre;
            pre = result;
        }
        return result;
    }
};

9.变态跳台阶

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

class Solution {
public:
    int jumpFloorII(int number) {
        if(number == 0)
            return 1;
        if(number == 1)
            return 1;
        if(number == 2)
            return 2;
        int result = 0;
        for(int i = 0;i<number;i++)
        {
            result += jumpFloorII(number-i-1);
        }
        return result;
    }
};

10.矩形覆盖

题目描述

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

class Solution {
public:
    int rectCover(int number) {
        if(number == 0)
            return 0;
        if(number==1)
            return 1;
        if(number == 2)
            return 2;
        return rectCover(number-2)+rectCover(number-1);
    }
};