pat考试的板子题，覆盖很多基本数据结构

编程语言 2018-12-02 09:20:47 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zs391077005/article/details/84696954
  1. 快排
int partition(int a[],int left,int right)
{
	int temp=a[left];
	while(left<right&&temp<a[right])
		right--;
	a[left]=a[right];
	while(left<right&&a[left]<=temp)
		left++;
	a[right]=a[left];
	a[left]=temp;
	return left;
}
void quicksort(int a[],int left,int right)
{
	if(left<right)
	{
		int pos=partition(a,left,right);
		quicksort(a,left,pos-1);
		quicksort(a,pos+1,right);
	}
}
  1. 归并排序
//[1,n]
int n;
void mergesort(int a[])
{   //step/2为左边区间元素个数
	for(int step=2;step/2<=n;step*=2)
		for(int i=1;i<=n;i+=step)
			sort(a+i,a+min(i+step,n+1);
}
  1. 二分查找
//[0,n) 找第一个>x
int binarysearch(int a[],int left,int right)
{
	int mid;
	while(left<right)
	{
		mid=(left+right)/2;
		if(a[mid]>x)//根据条件改此
			right=mid;
		else left=mid+1;
	}
	return left;
}

//[0,n-1]
int binarysearch(int a[],int left,int right,int target) {
	int mid;
	while(left<=right) {
		mid = left + (right - left) / 2;
		if(a[mid] == target)
			return mid;
		else if(a[mid] > target)
			right = mid - 1;
		else left = mid + 1;
	}
	return -1;
}
  1. 最大公约
int gcd(int a,int b)
{
	return b==0?a:gcd(b,a%b);
}
  1. 素数判断
bool isprime(int n)
{
	if(n<=1) return false;
	for(int i=2;i*i<=n;i++)
		if(n%i==0)
			return false;
	return true;
}
  1. 堆排序

//大顶堆 [1,n]
const int maxn=100;
int heap[maxn];
void downadjust(int left,int right)
{
	int i=left,j=i*2;
	while(j<=right)
	{
		if(j+1<=right&&heap[j+1]>heap[j])
			j=j+1;
		if(heap[j]>heap[i])
		{
			swap(heap[i],heap[j]);
			i=j;j=2*i;
		}
		else break;
	}
}
void upadjust(int left,int right)
{
	int i=right,j=i/2;
	while(j>=left)
	{
		if(heap[j]<heap[i])
		{
			swap(heap[i],heap[j]);
			i=j;j=i/2;
		}
		else break;
	}
}
//建删 插排
void createheap(int left,int right)
{
	for(int i=n/2;i>=1;i++)
		downadjust(i,n);
}
void deletetop()
{
	heap[1]=heap[n--];
	downadjust(1,n);
}
void insert(int x)
{
	heap[++n]=x;
	upadjust(1,n);
}
void heapsort()
{
	createheap();
	for(int i=n;i>1;i--)
	{
		swap(heap[i],heap[1]);
		upadjust(1,i-1);
	}
}
  1. 并查集
int father[1010];
int findfather(int x)
{
	int a=x;
	while(x!=father[x])
		x=father[x];
	while(a!=father[a])
	{
		int z=a;
		a=father[a];
		father[z]=x;
	}
	return x;
}
void Union(int a,int b)
{
	int faa=findfather(a);
	int fab=findfather(b);
	if(faa!=fab)
		father[faa]=fab;
}
void init()
{
	for(int i=0;i<n;i++)
		father[i]=i;
}
//n个人，每个人k个课，若有相同课在一个社交圈，统计圈子数
//course[课]=人
int  cyclenum()
{
	int course[1010];
	bool isroot[1010];
	int cnt=0;
	fill(course,course+1010,0);
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<k;j++)
		{
			cin>>t;
			if(course[t]==0)
				course[t]=i;
			Union(i,findfather(course[t]));
			
		}
	}
    for(int i=1;i<=n;i++)
	{
		isroot[findfather(i)]++;
	}
	for(int i=1;i<=n;i++)
	{
		if(isroot[i]!=0)
			cnt++;
	}
	return cnt;
}
  1. AVL树
struct node {
	int val;
	struct node *left,*right;
};
struct node *leftrotate(struct node *root)
{
	struct node *temp=root->right;
	root->right=temp->left;
	temp->left=root;
	return temp;
}
struct node *rightrotate(struct node *root)
{
	struct node *temp=root->left;
	root->left=temp->right;
	temp->right=root;
	return temp;
}
struct node *leftrightrotate(struct node *root)
{
	root->left=leftrotate(root->left);
	root=rightrotate(root);
	return root;
}
struct node *rightleftrotate(struct node *root)
{
	root->right=rightrotate(root->right);
	root=leftrotate(root);
	return root;
}
int getheight(struct node *root)
{
	if(root==NULL)
		return 0;
	int l=getheight(root->left);
	int r=getheight(root->right);
	return l>r?l+1:r+1;
}
struct node *insert(struct node *root,int val)
{
	if(root==NULL)
	{
		root=new node();
		root->left=root->right=NULL;
		root->val=val;
		return root;
	}
	if(val<root->val)
	{
		root->left =insert(root->left,val);
		int l=getheight(root->left);
		int r=getheight(root->right);
		if(l-r>=2)
		{
			if(val<root->left->val)   //LL
			{
				root=rightrotate(root);
			}
			else root=leftrightrotate(root); //lr
		}
	}
	else{
		root->right=insert(root->right,val);
		int l=getheight(root->left);
		int r=getheight(root->right);
		if(r-l>=2)
		{
			if(val>root->right->val)
			{
				root=leftrotate(root);
			}
			else root=rightleftrotate(root);
		}
	}
	return root;
}
  1. levelOrder
#include<vector>
#include<queue>
using namespace std;
struct node {
	int val;
	struct node *left,*right;
};
vector<int> levelorder(struct node *root)
{
	vector<int> v;
	queue<struct node*> q;
	q.push(root);
	while(!q.empty())
	{
		node *top=q.front();
		v.push_back(top->val);
		q.pop();
		if(top->left!=NULL)
			q.push(top->left);
		if(top->right!=NULL)
			q.push(top->right);
	}
	return v
}
  1. dijkstra
#include<vector>
using namespace std;

//单一解
const int inf=999999999;
int dis[1010],e[1010][1010],pre[1010];
bool visit[1010];
fill(e[0],e[0]+1010*1010,inf);
fill(dis,dis+1010,inf):
fill(visit,visit+1010,false);
int pre[1010];
int st,end;
dis[st]=0;
void dfspre(int v)
{
	if(v==end)
		return;
	cout<<v<<' ';
	dfspre(pre[v]);
}
for(int i=0;i<n;i++)
{
	int u=-1,minn=inf;
	for(int j=0;j<n;j++)
	{
		if(visit[j]==false&&dis[u]<minn)
		{
			minn=dis[u];
			u=j;
		}
	}
	if(u==-1) break;
	visit[u]=true;
	for(int v=0;v<n;v++)
	{
		if(visit[v]==false&&e[u][v]!=inf)
		{
			if(dis[u]+e[u][v]<dis[v])
			{
				dis[v]=dis[u]+e[u][v];
				pre[v]=u;
			}
			else if(dis[u]+e[u][v]==dis[v])
			{
				pre[v]=u;
			}
		}
	}
}
dfspre(end);

//多路径取点个数少的
fill(e[0],e[0]+1010*1010,inf);
fill(dis,dis+1010,in):
fill(visit,visit+1010,false);
dis[st]=0;
vector<int> pre[1010];
vector<int> path,temppath;
int tempcnt=0,mincnt=9999999;
void dfsfrompre(int v)
{
	temppath.push_back(v);
	if(v==st)
	{
		if(temppath.size()<mincnt)
		{
			mincnt=temppath.size();
			path=temppath;
		}
		temppath.pop_back();
		return;
	}
	for(int i=0;i<pre[v].size();i++)
	{
		dfsfrompre(pre[v][i]);
	}
	temppath.pop_back();
}
for(int i=0;i<n;i++)
{
	int u=-1,minn=inf;
	for(int j=0;j<n;j++)
	{
		if(visit[j]==false&&dis[v]<minn)
		{
			u=j;
			minn=dis[v];
		}
	}
	if(u==-1) break;
	visit[u]=true;
	for(int v=0;v<n;v++)
	{
		if(visit[v]==false&&e[u][v]<inf)
		{
			if(dis[u]+e[u][v]<dis[v])
			{
				dis[v]=dis[u]+e[u][v];
				pre[v].clear();
				pre[v].push_back(u);
			}
			else if(dis[u]+e[u][v]==dis[v])
			{
				pre[v].push_back(u);
			}
		}
	}
}
dfsfrompre(end);

//最短路径下，点权最大的
const int inf=999999999;
int dis[1010],e[1010][1010],pre[1010],weight[1010],w[1010][1010];
bool visit[1010];
fill(e[0],e[0]+1010*1010,inf);
fill(dis,dis+1010,inf):
fill(visit,visit+1010,false);
dis[st]=0;
int pre[1010];
for(int i=0;i<n;i++)
{
	int u=-1;minn=inf;
	for(int j=0;j<n;j++)
	{
		if(visit[i]==false&&dis[u]<minn)
		{
			minn=dis[u];
			u=j;
		}
	}
	if(u==-1) break;
	visit[u]=true;
	for(int v=0;v<n;v++)
	{
		if(visit[v]==false&&e[u][v]<inf)
		{
			if(dis[u]+e[u][v]<dis[v])
			{
				dis[v]=dis[u]+e[u][v];
				weight[v]=weight[u]+w[u][v];
				pre[v]=u;
			}
			else if(dis[u]+e[u][v]==dis[v]&&weight[u]+w[u][v]>weight[v])
			{
				weight[v]=weight[u]+w[u][v];
				pre[v]=u;
				
			}
		}
	}
}
  1. sort
//pre+post in?
#include<vector>
using namespace std;

int pre[1010],post[1010];
vector<int> in;
void setin(int prel,int prer,int postl,int postr)
{
	int i=prel+1;
	while(i<=prer&&pre[i]!=post[postr-1])
	if(prel==prer)
	{
		in.push_back(pre[prel]);
		return;
	}
	if(pre[prel]==post[postr])
	{
		if(i-prel>1)
		{
			setin(prel+1,i-1,postl,postl+i-prel-2);
			in.push_back(post[postr]);
			setin(i,prer,postl+i-prel-2+1 ,postr-1);
		}
		else
		{
			in.push_back(post[postr]);
			setin(i,prer,postl+i-prel-2+1 ,postr-1);
		}
	}
}

//post+in level?
int post[1010],in[1010];
vector<int> level;
void getlevel(int inl,int inr,int postl,int postr,int index)
{
	int i=inl;
	while(i<=inr&&in[i]!=post[postr])
		i++;
	if(inl>inr) return;
	level[index]=post[postr];
	getlevel(inl,i-1,postl,i-1-inl+postl,index*2+1);
	getlevel(i+1,inr,i-inl+postl,index*2+2);
}

//pre+in level?
int pre[1010],in[1010];
int level[1010];
void getlevel(int prel,int prer,int inl,int inr,int index)
{
	if(prel>prer) return ;
	int i=inl;
	while(i<inr&&pre[prel]!=in[i]) i++;
	level[index]=pre[prel];
	getlevel(prel+1,i-inl-1-prel-1 ,inl,i-1,2*index+1);
	getlevel(i-prel-1-inl,prer,i+1,inr,2*index+2);
}

//pre+in post?
int pre[1010],in[1010];
vector<int> post;
void postorder(int prel,int prer,int inl,int inr)
{
	int i=prel+1;
	while(i<=prer&&in[i]!=pre[prel])
		i++;
	postorder(prel+1,inl-i-prel ,inl,i-1);
	postorder(inl-i-prel+1,prer,i+1,inr);
	post.push_back(pre[prel]);
}

//in+post zigzag?

# include<queue>
using namespace std;
int in[1010],post[1010],tree[1010][2];
vector<int> result;
struct node{
	int index,depth;
	node(){}
	node(int _index,int _depth) {index=_index;depth=_depth;}
};
void dfs(int &index,int inl,int inr,int postl,int postr)
{
	if(inl>inr) return;
	index=postr;
	int i=inl;
	while(i<=inr&&in[i]!=post[postr]) i++;
	dfs(tree[index][0],inl,i-1,postl,i-1-inl+postl);
	dfs(tree[index][1],i+1,inr,i-1-inl+postl+1,postr-1);
}
void bfs()
{
	queue<node> q;
	q.push(node{root,0});
	while(!q.empty())
	{
		node *top=q.front();
		q.pop();
		result[temp.depth].push_back(post[temp.index]);
		if(tree[temp.index][0]!=0)
			q.push(node(tree[temp.index][0],temp.depth+1));
		if(tree[temp.index][1]!=0)
			q.push(node(tree[temp.index][1],temp.depth+1));
	}
}
  1. AOE
#include<fstream>
#include <cstdio>
#include <iostream>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<string>
#include<cmath>
#include<stack>
#include<queue>
using namespace std;
struct edge{
	int v,w;
	edge(){}
	edge(int _v,int _w){v=_v;w=_w}
};
const int maxn=9999999;
vector<edge> g[maxn];
vector<int> activity[maxn];
int indegree[maxn]={0};
int n,m,indegreeorigin[maxn]={0};
int ve[maxn],vl[maxn];
stack<int> toporder;
bool topologicalsort()
{
	queue<int> q;
	for(int i=0;i<n;i++)
	{
		if(indegree[i]==0)
			q.push(i);
	}
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		toporder.push(u);
		for(int i=0;i<g[u].size();i++)
		{
			int v=g[u][i].v;
			indegree[v]--;
			if(indegree[v]==0)
			{
				q.push(u);
			}
			if(ve[u]+g[u][i].w>ve[v])
			{
				ve[v]=ve[u]+g[u][i].w;
			}
		}
	}
	if(toporder.size()==n)
		return true;
	else return false;
}
int criticalpath()
{
	memset(ve,0,sizeof(ve));
	if(topologicalsort()==false)
		return -1;
	int maxlength=0;
	for(int i=0;i<n;i++)
	{
		if(maxlength<ve[i])
			maxlength=ve[i];
	}
	fill(vl,vl+1010,maxlength);
	while(!toporder.empty())
	{
		int u=toporder.top();
		toporder.pop();
		for(int i=0;i<g[u].size();i++)
		{
			int v=g[u][i].v;
			if(vl[v]-g[u][i].w<vl[u])
				vl[u]=vl[v]-g[u][i].w;
		}
	}
	for(int u=0;u<n;u++)
	{
		for(int i=0;i<g[u].size();i++)
		{
			int v=g[u][i].v,w=g[u][i].w;
			int e=ve[u],l=vl[v]-w;
			if(e==l) 
				activity[u].push_back(v);
		}
	}
	return maxlength;
}
vector<int> cpath;
void printcriticalpath(int u)
{
	if(activity[u].size()==0)
	{
		cpath.push_back(u);
		for(int i=0;i<cpath.size();i++)
		{
			printf("%d",cpath[i]);
		}
		cpath.pop_back();
		return;
	}
	cpath.push_back(u);
	sort(activity[u].begin(),activity[u].end());
	for(int i=0;i<activity[u].size();i++)
		printcriticalpath(activity[u][i]);
	cpath.pop_back();
}

int main()
{
	cin>>n>>m;
	for(int i=0;i<m;i++)
	{
		int u,v,w;
		cin>>u>>v>>w;
		g[u].push_back(edge(u,v));
		indegree[v]++;
		indegreeorigin[v]++;
	}
	int criticaltime=criticalpath();
	if(criticaltime==-1)
		cout<<"NO"<<endl;
	else
	{
		cout<<"YES"<<endl;
		for(int i=0;i<n;i++)
		{
			if(indegreeorigin[i]==0&&activity[i].size()!=0)
				printfcriticalpath(i);
		}
	}
#ifdef _DEBUG
	system("pause");
#endif	


	return 0;
	
}
  1. bst
//BST树，已知前序求后序
const int maxn=1010;
vector<int> post;
int pre[maxn];
void getpost(int prel,int prer)
{
	if(prel>prer) return ;
	int i=prel+1,j=prer;
	while(i<=prer&&pre[i]<pre[prer]) i++;
	while(j>prel&&pre[j]>=pre[prel]) j--;
	if(i-j!=1) return;
	getpost(prel+1,j);
	getpost(i,prer);
	post.push_back(pre[prel]);
}
//如果post.size()==n 是bst树

//bst中序从小到大, 求层序
vector<int> in,level;
void levelorder(int inl,int inr,int index)
{
	if(inl>inr) return;
	int n=inr-inl+1;
	int l=log(n+1)/log(2);//高-1
	int leave=n-(pow(2,l)-1);
	int root=inl+pow(2,l-1)-1+min(leave,pow(2,l-1));
	level[index]=in[root];
	levelorder(inl,root-1,2*index+1);
	levelorder(root+1,inr,2*index+2);
}

14.肿瘤那个

struct node{
	int x,y,z;
};
int m,n,l;
int X[6]={1,0,0,-1,0,0};
int Y[6]={0,1,0,0,-1,0};
int Z[6]={0,0,1,0,0,-1};
bool visit[1300][130][80];
int arr[1300][130][80];
bool judge(int x,int y,int z)
{
	if(x<0||y<0||z<0||x>=m||y>=n||z>=l)
		return false;
	if(arr[x][y][z]==0||visit[x][y][z]==true)
		return false;
	return true;
}
int bfs(int x,int y,int z)
{
	int cnt=0;
	node temp;
	temp.x=x;temp.y=y;temp.z=z;
	queue<node> q;
	q.push(temp);
	visit[x][y][z]=true;
	while(!q.empty())
	{
		node top=q.front();
		q.pop();
		cnt++;
		for(int i=0;i<6;i++)
		{
			int tx=temp.x+X[i];
			int ty=temp.y+Y[i];
			int tz=temp.z+Z[i];
			if(judge(tx,ty,tz))
			{
				visit[tx][ty][tz]=true;
				temp.x=tx;temp.y=ty;
				temp.z=tz;
				q.push(temp);
			}
		}
	}
	if(cnt>=t)
		return cnt;
	else return 0;
}
  1. 地铁题
vector<int> path,temppath;
int line[10000][10000],visit[10000];
int transfercnt(vector<int> a)
{
	int cnt=-1,preline=0;
	for(int i=1;i<a.size();i++)
	{
		if(line[a[i-1]][a[i]]!=preline)
			cnt++;
	}
	return cnt;
}
void dfs(int node, int end,int cnt.int &mincnt,int &mintransfer)
{
	if(node==end&&cnt<mincnt||cnt==mincnt&&transfercnt(temppath)<mintransfer)
	{
		mincnt=cnt;
		mintransfer=transfercnt(temppath);
		path=temppath;
	}
	if(node==end) return;
	for(int i=0;i<v[node].size();i++)
	{
		if(visit[v[node][i]==0)
		{
			visit[v[node][i]]=1;
			temppath.push_back(v[node][i]);
			dfs(v[node][i],end,cnt+1,mincnt,mintransfer);
			visit[v[node][i]]=0;
			temppath.pop_back();
		}
	}
}
  1. 运算符重载，达到set排序目的
struct node{
	int value,cnt;
	node(int a,int b){value=a;cnt=b;}
	bool operator < (const node &a) const{
		return cnt!=a.cnt?cnt>a.cnt:value<a.value;
	}
}
//cnt从大到小，value从小到大
set<node> s;
s.insert(node(value,cnt));
//cnt用book[]记录
  1. 层序+中序 求先和中
#include<fstream>
#include <cstdio>
#include <iostream>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<string>
#include<cmath>
#include<stack>
#include<queue>
using namespace std;
const int maxn=50;
const int inf=0x3ffffffff;
struct node 
{
	int data, left,right;
}Node[maxn];
int in[maxn];
vector<int> pre,post;
int num=0;
int newNode(int x)
{
	Node[num].data=x;
	Node[num].left=-1;
	Node[num].right=-1;
	return num++;
}
int create(vector<int> level,int inl,int inr)
{
	if(level.size()==0)
		return -1;
	int root=newNode(level[0]);//root层序根
	int k=inl;
	while(k<=inr&&in[k]!=level[0]) k++;
	//k中序根
	vector<int> levelleft,levelright;
	for(int i=1;i<level.size();i++)
	{
		bool isleft=false;
		for(int j=inl;j<k;j++)
		{
			if(level[i]==in[j])
			{
				isleft=true;
				break;
			}
		}
		if(isleft) levelleft.push_back(level[i]);
		else levelright.push_back(level[i]);
	}
	Node[root].left=create(levelleft,inl,k-1);
	Node[root].right=create(levelright,k+1,inr);
	return root;
}
void preorder(int root)
{
	if(root==-1)
		return ;
	pre.push_back(Node[root].data);
	preorder(Node[root].left);
	preorder(Node[root].right);
}
void postorder(int root)
{
	if(root==-1)
		return;
	post.push_back(Node[root].data);
	postorder(Node[root].left);
	postorder(Node[root].right);
}
int main()
{
	vector<int> level;
	int n,temp;
	for(int i=0;i<n;i++)
	{
		cin>>temp;
		level.push_back(temp);
	}
	for(int i=0;i<n;i++)
	{
		scanf("%d",&in[i]);
	}
	int root=create(level,0,n-1);
	preorder(root);
	postorder(root);
#ifdef _DEBUG
	system("pause");
#endif	


	return 0;
	
}

猜你喜欢

转载自blog.csdn.net/zs391077005/article/details/84696954
今日推荐
周排行
联发科MT6139射频处理器工作原理分析
LeetCode-191. 位1的个数
kubernetes中挂载glusterfs并使用
MetricBeat（win/linux）部署 系统CPU内存等资源情况监控
京东，想说爱你，并不容易！
CSS文本笔录
标题栏和状态栏同色
[校内互测]20170402
#3194. 去月球
gitlab学习(7)---gitlab数据恢复
每日归档
更多
2024-06-15(0)
2024-06-14(0)
2024-06-13(0)
2024-06-12(0)
2024-06-11(0)
2024-06-10(0)
2024-06-09(0)
2024-06-08(0)
2024-06-07(0)
2024-06-06(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022