【1-5】剑指offer

1. 题目描述

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

class Solution

{

public:

bool Find(vector<vector<int> > array,int target)

{

        //获取迭代器的取值

vector<vector<int> >::iterator ite1 = array.begin();

vector<int>::iterator ite2 = ite1->begin();

//循环寻找所需要的值

for(ite1 = array.begin(); ite1 != array.end();  ite1++)

{

for(ite2 = ite1->begin(); ite2 != ite1->end(); ite2++)

{

//cout<<*ite2<<endl;

if(*ite2 == target)

return true;

}

}

return false;

}

};

 

2. 题目描述

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

 

//length为牛客系统规定字符串输出的最大长度，固定为一个常数

class Solution

{

public:

void replaceSpace(char *str,int length)

{

char *ptemp = (char *)malloc(sizeof(char)*length);

char *source = str;

 

int i = 0;

while(*source != '\0' && i < length)

{

if(*source == ' ')

{

ptemp[i] = '%%';

i++;

if(i > length)

break;

ptemp[i] = '2';

i++;

if(i > length)

break;

ptemp[i] = '0';

i++;

if(i > length)

break;

source++;

}

else

{

ptemp[i] = *source;

source++;

i++;

if(i > length)

break;

}

}

if(i > length)

ptemp[length] = '\0';

else

ptemp[i] = '\0';

 

strcpy(str,ptemp);

 

free(ptemp);

ptemp = NULL;

}

 

};

 

3.题目描述

输入一个链表，从尾到头打印链表每个节点的值。

输入描述:

输入为链表的表头

输出描述:

输出为需要打印的“新链表”的表头

 

class Solution

{

public:

    vector<int> printListFromTailToHead(struct ListNode* head)

{

        //计算链表的长度

struct ListNode* temp = head;

int nListLen = 0;

while(temp != NULL)

{

nListLen++;

temp = temp->next;

}

vector<int> array(nListLen);

int i = nListLen-1;

temp = head;

while(temp != NULL)

{

array[i]=temp->val;

temp = temp->next;

i--;

}

return array;

    }

};

 

 

4. 题目描述

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

#include <iostream>

#include <vector>

using namespace std;

 

//二叉树节点的定义

struct TreeNode

{    

int val;     

TreeNode *left;     

TreeNode *right;

TreeNode(int x) : val(x), left(NULL), right(NULL) {}

};

 

class Solution

{

public:

    struct TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> in)

{

if(pre.size() == 0 || in.size() == 0)

return NULL;

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

int left_child_len = 0;

while(pre[0] != in[left_child_len])

{

left_child_len++;

}

int right_child_len = pre.size() - left_child_len - 1;

if(left_child_len > 0)

{

vector<int> a = vector<int>(pre.begin()+1, pre.begin()+left_child_len+1);

vector<int> b = vector<int>(in.begin(), in.begin()+left_child_len);

root->left = reConstructBinaryTree(a, b);

}

if(right_child_len>0)

{

vector<int> c = vector<int>(pre.begin()+left_child_len+1, pre.end());

vector<int> d = vector<int>(in.begin()+left_child_len+1, in.end());

root->right = reConstructBinaryTree(c, d);

}

return root;

    }

};

 

//前序遍历

void preoder(struct TreeNode *tree)

{

if(tree == NULL)

return;

 

cout<<tree->val<<endl;

preoder(tree->left);

preoder(tree->right);

}

 

//中序遍历

void midorder(struct TreeNode *tree)

{

if(tree == NULL)

return;

midorder(tree->left);

cout<<tree->val<<endl;

midorder(tree->right);

}

 

//后续遍历

void postorder(struct TreeNode *tree)

{

if(tree == NULL)

return;

postorder(tree->left);

postorder(tree->right);

cout<<tree->val<<endl;

}

 

int main()

{

vector<int> pre(8);

vector<int>::iterator ite = pre.begin();

 

for(; ite != pre.end(); ite++)

{

cout<<"Please input pre:";

cin>>*ite;

}

 

vector<int> in(8);

for(ite = in.begin(); ite != in.end(); ite++)

{

cout<<"Please input in:";

cin>>*ite;

}

 

Solution s;

struct TreeNode *tree = s.reConstructBinaryTree(pre, in);

 

//前序遍历

cout<<"--------------------------------------"<<endl;

preoder(tree);

//中序遍历

cout<<"--------------------------------------"<<endl;

midorder(tree);

//后续遍历

cout<<"--------------------------------------"<<endl;

postorder(tree);

return 0;

}

 

5. 题目描述

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

 

class Solution

{

public:

   void push(int node)

   {

        stack1.push(node);

   }

 

   int pop()

   {

        if(stack2.empty())

        {

            while(!stack1.empty())

        {

                stack2.push(stack1.top());

                stack1.pop();

            }

        }

        int p=stack2.top();

        stack2.pop();

        return p;

    }

 

private:

    stack<int> stack1;

    stack<int> stack2;

};