剑指offer(二)

源码如下：

//面试题3 二维数组的查找
class two_demision_find
{
public:
	two_demision_find(int (*tem)[4],int n)
	{
		for(int i=0;i<n;i++)
		{
			vector<int> str;
			for(int j=0;j<4;j++)
			{
				str.push_back(tem[i][j]);
			}
			result.push_back(str);
		}
	}
	bool hadfound(int dest,int n,int m) const
	{
		int i=0;  //i表示行
		int j=m-1;  //j表示列
		while(true)
		{
			if(dest<result[i][j])
			{
				j--;
			}
			else if(dest>result[i][j])
			{
				i++;
			}
			else
				return true;
			if(i>=n||j<0)
				return false;
		}
	}
private:
	vector<vector<int>> result;
};

//面试题4 替换空格  把空格替换为指定的字符串
class replace_space
{
public:
	void start_1(char *str,int size)  //另外开辟内存空间复杂度为O（n），时间复杂度为O（n）;
	{
		vector<char> result;
		for(int i=0;i<size;i++)
		{
			if(str[i]==' ')
			{
				result.push_back('%');
				result.push_back('2');
				result.push_back('0');
			}
			else
				result.push_back(str[i]);
		}
		for(auto i:result)
			cout<<i;
		cout<<endl;
	}
	void start_2(char *str,int size)  //空间复杂度为O（1），时间复杂度为O（n）;
	{
		//先遍历一遍看有几个空格
		int space_num=0;
		for(int i=0;i<size;i++)
		{
			if(str[i]==' ')
				space_num++;
		}
		char *p1=str+size;
		size+=2*space_num;
		char *p2=str+size;

		while(p1!=p2)
		{
			if(*p1==' ')
			{
				*p2--='0';
				*p2--='2';
				*p2--='%';
				p1--;
			}
			else
			{
				*p2--=*p1--;
			}
		}
		cout<<str<<endl;
	}
};

//实现strtok函数
class mystrtok
{
public:
	char* operator()(char *src,const char *delim,char **save_ptr)
	{
		char *token=nullptr;
		if(src==nullptr)
			src=*save_ptr;
		src+=_strspn(src,delim); //第一次src不为空，delim第一个不在s中的位置，_strspn(src,delim)返回0
		if(*src=='\0')
			return NULL;
		token=src;
		///*******??????
		src=_strpbrk(src,delim); //返回最早出现在src中的位置后的字符串，包括自身
		if(src==NULL)
		{
			*save_ptr=_strchr(token,'\0');
		}
		else
		{
			*src='\0';
			*save_ptr=src+1;
		}
		return token;
	}
public:
	//检查delim第一个不在s中的位置
	int _strspn(char *s,const char* delim)    
	{
		if(s==nullptr||delim==nullptr)
			return 0;
		int n=0;
		bool flag=false;
		for(int i=0;i<strlen(s);i++)
		{
			//判断delim的中的字符是否在s中
			for(int j=0;j<strlen(delim);j++)
			{
				if(delim[j]==s[i])
				{
					n++;
					flag=true;
					break;
				}
				
			}
			if(!flag)
				return n;
			flag=false;
		}
		return n;  //返回的是n=0
	}
	//字符串s中首次出现dest的位置
	char *_strchr(char *s,char dest)
	{
		if(s==nullptr||dest==NULL)
			return nullptr;
		int n=0;
		for(int i=0;i<strlen(s);i++)
		{
			if(dest==s[i])
				return s+n;
			else
				n++;
		}
		if(n==strlen(s))
			return NULL;
		else
			return s;
	}
	//检查字符串delim在s中最早出现的位置后的字符串
	char *_strpbrk(char* s,const char* delim)
	{
		if(s==nullptr||delim==nullptr)
			return nullptr;
		int min=0xffff;
		//int n=0;
		for(int i=0;i<strlen(delim);i++)
		{
			for(int j=0;j<strlen(s);j++)
			{
				if(delim[i]==s[j])
				{
					min=j<min?j:min;
				}
			}
		}
		if(min==0xffff)  //没有找到相应的分割字符串
			return NULL;
		else
			return s+min;
	}
};

//面试题6： 重建二叉树
struct List_Node
{
	char data;
	List_Node *left_child;
	List_Node *right_child;
};
class Recreate_Tree
{
public:
	void start(char* pre_order,char* in_order,int length)
	{
		if(pre_order==NULL||in_order==NULL||length<=0)
			return ;
		List_Node *head=create_tree(pre_order,pre_order+length-1,in_order,in_order+length-1);
		back_order(head);
	}
	List_Node* create_tree(char *pre_start,char *pre_end,char *in_start,char *in_end)
	{
		List_Node *root=new List_Node;
		root->data=*pre_start;
		root->left_child=NULL;
		root->right_child=NULL;
		if(pre_start==pre_end)
		{
			if(in_start==in_end&&*pre_start==*in_start)
			{
				return root;
			}
			else
				throw exception("错误");
		}
		int in_num=0;
		while(*(in_start+in_num)!=*pre_start&&(in_start+in_num)<=in_end)
			in_num++;
		if((in_start+in_num)==in_end&&*(in_start+in_num)!=*in_end)
			throw exception("not found element in in_order");
		if(in_num>0)  //开始这个条件考虑错误
			root->left_child=create_tree(pre_start+1,pre_start+in_num,in_start,in_start+in_num-1);

		if(in_num<pre_end-pre_start)
			root->right_child=create_tree(pre_start+in_num+1,pre_end,in_start+in_num+1,in_end);

		return root;
	}

	void back_order(List_Node *head)
	{
		if(head==nullptr)
			return;
		back_order(head->left_child);
		back_order(head->right_child);
		cout<<head->data<<" ";
	}
};

//两个队实现一个栈
class queue_stack
{
public:
	void start()
	{
		while(true)
		{
			cout<<"1、插入		2、出栈		0、退出"<<endl;
			short choose=0;
			int num=0;
			cin>>choose;
			switch(choose)
			{
			case 0:
				exit(0);
			case 1:
				cin>>num;
				q1.push(num);
				break;
			case 2:
				if(q1.empty())
				{
					cout<<"没有更多元素了，请插入元素或退出！"<<endl;
					break;
				}
				else
				{
					while(q1.size()!=1)
					{
						q2.push(q1.front());
						q1.pop();
					}
					cout<<q1.front()<<endl;
					q1.pop();
					//把q2中的元素还原到q1中
					while(!q2.empty())
					{
						q1.push(q2.front());
						q2.pop();
					}
				}
				break;
			default:
				cout<<"No that choose!"<<endl;
				break;
			}
		}
	}
private:
	queue<int> q1;
	queue<int> q2;
};

//面试题15：删除倒数第k个结点的相关题目:输出链表中间元素
class middle_List
{
public:
	void start(int *list,int n)
	{
		if(list==NULL||n<=0)
			return;
		int p1=0;
		int p2=0;
		while(p2+2<=(n-1))
		{
			p1+=1;
			p2+=2;
		}
		cout<<list[p1]<<endl;
	}
};
//中兴机试题：页面置换算法
class test
{
public:
	float waitingTimeSJF(int *requestTimes, int *durations, int n)
	{
		int cpu_time = 0;
		float wait_time = 0;
		vector<int> vec_flag(n,0);
		vector<int> vec_ready(n,0);

		int vec_ready_n = 0;
		int cur = 0;
		int next = 0;
		int min = 101;
		for (int i = 0; i<n; i++)
		{
			wait_time = wait_time + (cpu_time - requestTimes[cur]);
			cpu_time += durations[cur];
			vec_flag[cur] = 1;   //把已完成任务标记
			vec_ready_n = 0; //已经运行完的任务的个数
			for (int j = 0; j<n; j++)
			{
				if (vec_flag[j] == 0 && requestTimes[j] <= cpu_time) //找出已经请求了的任务
				{
					vec_ready[vec_ready_n++] = j;
				}
			}
			min = 65535;
			for (int k = 0; k<vec_ready_n; k++)//找出执行时间最短的程序
			{
				if (durations[vec_ready[k]]<min)
				{
					min = durations[vec_ready[k]];
					next = vec_ready[k];
				}
			}
			cur = next;
		}
		return (wait_time / n);
	}
};

//面试题16：翻转链表
struct List
{
	int data;
	List *next;
};

class My_List
{
public:
	List* create_List()
	{
		List *head=new List;
		head->data=-1;
		head->next=NULL;

		int data=0;
		List *tem=head;
		while(cin>>data)
		{
			if(data<0)
				return head->next;
			List *node=new List;
			node->data=data;
			node->next=NULL;
			tem->next=node;
			tem=tem->next;
		}
		return head->next;
	}

	List* reverseList(List* head)
	{
		if(head==NULL)
		  return NULL;
		List *pre=NULL;
		List *pnode=head;
		List *pnext=pnode->next;
		while(pnode->next!=NULL)
		{
			pnode->next=pre;
			pre=pnode;
			pnode=pnext;
			pnext=pnext->next;
		}
		pnode->next=pre;
		return pnode;
	}
	void print(List *head)
	{
		while(head!=NULL)
		{
			cout<<head->data<<"-->";
			head=head->next;
		}
		cout<<"NULL"<<endl;
	}
};

//面试题20 ：顺时针打印矩阵
class clock_print
{
public:
	void start(int str[][1],int n,int m)
	{
		int x_start=0,x_end=n-1;
		int y_start=0,y_end=m-1;

		while(x_start<=x_end||y_start<=y_end)
		{
			//左到右打印
			if(y_start<=y_end)
			{
				for(int i=y_start;i<=y_end;i++)
				{
					cout<<str[x_start][i]<<" ";
				}
			}
			x_start++;

			//从上到下打印
			if(x_start<=x_end)
			{
				for(int i=x_start;i<=x_end;i++)
				{
					cout<<str[i][y_end]<<" ";
				}
			}
			y_end--;

			//从右到左打印
			if(y_end>=y_start)
			{
				for(int i=y_end;i>=y_start;i--)
				{
					cout<<str[x_end][i]<<" ";
				}
			}
			x_end--;

			//从下往上打印
			if(x_end>=x_start)
			{
				for(int i=x_end;i>=x_start;i--)
					cout<<str[i][y_start]<<" ";
			}
			y_start++;
		}

	}
};

//面试题 22：栈的压入弹出序列
#include <stack>
class Stack_push
{
public:
	bool is_pop(vector<int> push_stack,vector<int> pop_stack)
	{
		if(push_stack.empty()||pop_stack.empty()||pop_stack.size()!=push_stack.size())
			return false;
		int i=0,j=0;
		stack<int> tem;
		while(j<pop_stack.size())
		{
			while(tem.empty()||tem.top()!=pop_stack[j])
			{
				if(i>=push_stack.size())
					break;
				tem.push(push_stack[i]);
				i++;
			}
			if(tem.top()!=pop_stack[j])
				break;
			tem.pop();
			j++;
		}
		if(tem.empty()&&j==pop_stack.size())
			return true;
		return false;
	}
};

//面试题 24：判断一个序列是否是搜索二叉树的后序遍历
class Is_Backorder
{
public:
	bool start(int *seq,int num)
	{
		if(seq==nullptr||num<=0)
			return true;
		int i=0,j=0;
		int root=seq[num-1];
		for(;i<num-1;i++)
		{
			if(seq[i]>root)
				break;
		}
		j=i;
		for(;j<num-1;j++)
		{
			if(seq[j]<root)
				return false;
		}

		return start(seq,i)&&start(seq+i,num-i-1);
	}
};