数据结构的相关编程问题

最新推荐文章于 2024-09-18 13:33:45 发布
最新推荐文章于 2024-09-18 13:33:45 发布
阅读量190 收藏
点赞数
文章标签： 数据结构 c++ 算法 深度优先 广度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XLYcmy/article/details/125739021
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

本文是一些之前对数据结构的问题编程

一、设计到的问题

1.矩阵的转置
2.矩阵的乘法
3.简单的生成树
4.中序遍历和后序遍历
5.前序遍历生成树
6.线索化二叉树
7.索引顺序表的查找
8.折半查找
9.平衡树
10.图的深度优先遍历

二、相关代码

1-5

代码如下：

1.#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;
int main()
{
	srand(time(0));
	int n=rand()%21,i,j;
	while(n<5)
		n=rand()%21;
	int**A;
	A=new int*[n];
	for(i=0;i<n;i++)
		A[i]=new int[n];
	cout<<"该三对角阵行数与列数为："<<n<<'\n'<<"请您输入数据:";
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			if(j>i-2&&j<i+2)
				cin>>A[i][j];
			else A[i][j]=rand();
		}
	}
	cout<<"原矩阵为："<<endl;
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			cout<<A[i][j]<<'\t';
		}
		cout<<endl;
	}
	int*b=new int[3*20-2];
	int k=0;
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{	
			if(j>i-2&&j<i+2)
			{
				b[k]=A[i][j];
				k++;
			}
		}
	}
	cout<<"请您输入想要查找的数据行数与列数：";
	cin>>i>>j;
	cout<<'\n'<<"数据为："<<b[i*2+j]<<endl;
	int **B;
	B=new int*[n];
	for(i=0;i<n;i++)
		B[i]=new int[n];
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			if(j>i-2&&j<i+2)
				B[i][j]=b[2*i+j];
			else B[i][j]=0;
		}
	}
	cout<<"还原矩阵为："<<endl;
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			cout<<B[i][j]<<'\t';
		}
		cout<<endl;
	}
	delete []b;
	for(i=0;i<n;i++)
	{
		delete []A[i];
		delete []B[i];
	}
	delete []A;
	delete []B;
	return 0;
}
2.#include<iostream>
using namespace std;
#define MAX 100
struct trimple
{
	int i,j;
	int e;
};
struct jz
{
	trimple data[MAX+1];
	int rpos[MAX+1];
	int mu,nu,tu;
};
void RPOS(jz&T)
{
	int num[MAX+1];
	int row;
	if(T.tu)
	{
		for(row=1;row<=T.mu;++row)
			num[row]=0;
		for(int t=1;t<=T.tu;++t)
			++num[T.data[t].i];
		T.rpos[1]=1;
		for(row=2;row<=T.mu;++row)
			T.rpos[row]=T.rpos[row-1]+num[row-1];
	}
}
bool cheng(jz M,jz N,jz&Q)
{
 	if(M.nu!=N.mu) return false;
	Q.mu=M.mu;
	Q.nu=N.nu;
	Q.tu=0;
	int ctemp[MAX+1]={0};
	int tp,brow,ccol,t,arow;
	if(M.tu*N.tu!=0)
	{
		for(arow=1;arow<=M.mu;++arow)
		{
			for(ccol=1;ccol<=Q.nu;++ccol)
				ctemp[ccol]=0;
			Q.rpos[arow]=Q.tu+1;
			if(arow<M.mu) tp=M.rpos[arow+1];
			else tp=M.tu+1;
			for(int p=M.rpos[arow];p<tp;++p)
			{
				brow=M.data[p].j;
				if(brow<N.mu) t=N.rpos[brow+1];
				else t=N.tu+1;
				for(int q=N.rpos[brow];q<t;++q)
				{
					ccol=N.data[q].j;
					ctemp[ccol]+=M.data[p].e*N.data[q].e;
				}
			}
			for(ccol=1;ccol<=Q.nu;++ccol)
			{
				if(ctemp[ccol])
				{
					if(++Q.tu>MAX) return false;
				    Q.data[Q.tu].e=ctemp[ccol];
				    Q.data[Q.tu].i=arow;
				    Q.data[Q.tu].j=ccol;
				}
			}
		}
	}
	return true;
}
void output(jz T)
{
	if(T.tu)
	{
		int t=1;
		for(int row=1;row<T.mu+1;row++)
		{
			for(int col=1;col<T.nu+1;col++)
			{
				if(T.data[t].i==row&&T.data[t].j==col)
				{
					cout<<T.data[t].e<<'\t';
					t++;
				}
				else cout<<0<<'\t';
			}
			cout<<'\n';
		}
	}
}
int main()
{
	jz M,N,Q;
	int t;
	M.tu=4;
	N.tu=4;
	M.mu=3;
	M.nu=4;
	N.mu=4;
	N.nu=2;
	for(t=1;t<M.tu+1;t++)
		cin>>M.data[t].e>>M.data[t].i>>M.data[t].j;
	for(t=1;t<N.tu+1;t++)
		cin>>N.data[t].e>>N.data[t].i>>N.data[t].j;
	cout<<"原始矩阵为："<<endl;
	output(M);
	output(N);
	RPOS(M);
	RPOS(N);
	if(cheng(M,N,Q))
	{
		cout<<"结果矩阵为："<<endl;
		output(Q);
	}
	else cout<<"数据有误！"<<endl;
	return 0;
}
3.#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;
void produce(int*p,int n)
{
	srand(time(0));
	int i=1,m=rand()%25;
	while(i<=n)
	{
		p[i]=m;
		i++;
		m=rand()%25;
	}
}
void output(int*p,int n)
{
	for(int i=1;i<=n;i++)
		cout<<p[i]<<endl;
}
int father(int k,int n)
{
	int j;
	if(k==1) return 0;
	if(k<=n)
	{
		j=k/2;
		return j;
	}
	if(k>n) return -1;
}
int rightchild(int k,int n)
{
	int j=2*k+1;
	if(j>n||j<=1)
		return 0;
	if(j<=n)
		return j;
}
int main()
{
	srand(time(0));
	int n=rand()%50;
	cout<<n<<endl;
	int*p=new int[n+1];
	produce(p,n);
	int k,j;
	cout<<"请输入下标值：";
	cin>>k;
	j=father(k,n);
	if(j==0) cout<<"No parents!"<<endl;
	else 
	{
		if(j<0) cout<<"输入数据有误！"<<endl;
		else cout<<"Its father is:"<<' '<<j<<endl;
	}
	j=rightchild(k,n);
	if(j) cout<<"Its rightchild is: "<<j<<endl;
	else cout<<"输入数据有误！"<<endl;
	output(p,n);
	delete []p;
	return 0;
}
4.#include<iostream>
using namespace std;
struct tree
{
	char data;
	tree*left;
	tree*right;
};
void visit(tree*root)
{
	cout<<root->data;
}
void produce(tree*&T)
{
	char ch;
	cin>>ch;
	T=new tree;
	if(ch=='@') T=NULL;
	else
	{
		T->data=ch;
		produce(T->left);
		produce(T->right);
	}
}
void inorder(tree*T)
{
	if(T)
	{
		inorder(T->left);
		visit(T);
		inorder(T->right);
	}
}
void postorder(tree*T)
{
	if(T)
	{
		postorder(T->left);
		postorder(T->right);
		visit(T);
	}
}
int Find(char*array,int size,char v)
{
	for(int i=0;i<size;i++)
	{
		if(array[i]==v)
		{
			return i;
		}
	}
	return -1;
}
tree*inproduce(char*postorder,char inorder[],int size)
{
	if(size<=0) return NULL;
	int rootvalue=postorder[size-1];
	int r=Find(inorder,size,rootvalue);
	tree*head=new tree;
	head->data=postorder[size-1];
	head->left=inproduce(postorder,inorder,r);
	head->right=inproduce(postorder+r,inorder+r+1,size-1-r);
	return head;
}
int main()
{
	tree*root=NULL;
	tree*head=NULL;
	cout<<"请您输入数据：";
	produce(root);
	cout<<"该树为：";
	inorder(root);
	cout<<endl;
	postorder(root);
	cout<<endl;
	cout<<"请输入数据数目：";
	int size;
	cin>>size;
	char*arry=new char[size+1];
	char*post=new char[size+1];
	cout<<"请您输入中序排列：";
	for(int i=0;i<size;i++)
		cin>>arry[i];
	cout<<"请您输入后续排列：";
	for(int j=0;j<size;j++)
		cin>>post[j];
	head=inproduce(post,arry,size);
	inorder(head);
	cout<<endl;
	postorder(head);
	cout<<endl;
	delete []arry;
	delete []post;
	return 0;//ABC@@DE@G@@F@@@
5.#include<iostream>
#include<stack>
using namespace std;
enum TAG {L,R};
struct tree
{
	char data;
	tree*left;
	tree*right;
};
struct wtree
{
	tree*ptr;
	TAG tag;
};
void visit(tree*root)
{
	cout<<root->data;
}
void produce(tree*&T)
{
	char ch;
	cin>>ch;
	T=new tree;
	if(ch=='@') T=NULL;
	else
	{
		T->data=ch;
		produce(T->left);
		produce(T->right);
	}
}
void postorder(tree*T)
{
	stack<wtree> S;
	wtree w;
	tree*p=T;
	do
	{
		while(p!=NULL)
		{
			w.ptr=p;
			w.tag=L;
			S.push(w);
			p=p->left;
		}
		int flag=1;
		while(flag&&!S.empty())
		{
			w=S.top();
			S.pop();
			p=w.ptr;
			switch(w.tag)
			{
			case L:w.tag=R;S.push(w);flag=0;p=p->right;break;
			case R:visit(p);break;
			}
		}
	}while(!S.empty());
}
int main()
{
	tree*root=NULL;
	cout<<"请您输入数据：";
	produce(root);
	cout<<"该树为：";
	postorder(root);
	cout<<endl;
	return 0;//ABC@@DE@G@@F@@@
}

6-10

代码如下：

6.#include<iostream>
using namespace std;
struct tree
{
	char data;
	tree*left;
	tree*right;
	bool ltag;
	bool rtag;
};
void visit(tree*root)
{
	cout<<root->data;
}
void produce(tree*&T)
{
	char ch;
	cin>>ch;
	T=new tree;
	if(ch=='@') T=NULL;
	else
	{
		T->data=ch;
		T->ltag=false;
		T->rtag=false;
		produce(T->left);
		produce(T->right);
	}
}
void inorder(tree*T)
{
	if(T)
	{
		inorder(T->left);
		visit(T);
		inorder(T->right);
	}
}
void createIn(tree*current,tree*&pre)
{
	if(current==NULL)
		return;
	createIn(current->left,pre);
	if(current->left==NULL)
	{
		current->left=pre;current->ltag=true;
	}
	if(pre!=NULL&&pre->right==NULL)
	{
		pre->right=current;
		pre->rtag=true;
	}
	pre=current;
	createIn(current->right,pre);
}
void createIn(tree*root)
{
	tree*pre=NULL;
	if(root!=NULL)
	{
		createIn(root,pre);
		pre->right=NULL;
		pre->rtag=true;
	}
}
tree* front(tree*current)
{
	tree*p=current;
	while(!(p->ltag))
		p=p->left;
	return p;
}
tree* next(tree*current)
{
	tree*p=current;
	if(p->rtag)
		return p->right;
	else
	{
		p=p->right;
		return front(p);
	}
}
void inordersearch(tree*T)
{
	tree*p;
	for(p=front(T);p!=NULL;p=next(p))
		visit(p);
}
int main()
{
	tree*root=NULL;
	cout<<"请您输入数据：";
	produce(root);
	cout<<"该树为：";
	inorder(root);
	cout<<endl;
	createIn(root);
	cout<<"利用线索化二叉树的方式输出：";
	inordersearch(root);
	cout<<endl;
	return 0;//ABC@@DE@G@@F@@@
}
7.#include<iostream>
using namespace std;
struct excel
{
	int max;
	int address;
};
void produce(int p[],int k,excel*&ST)
{
	int n=p[0]/k;
	ST=new excel[n+2];
	int i,j;
	int m;
	for(i=1;i<=n;i++)
	{
		m=p[k*(i-1)+1];
		if(i==n)
		{
			for(j=k*(i-1)+1;j<=p[0];j++)
				if(m<p[j]) m=p[j];
		}
		else
		{
			for(j=k*(i-1)+1;j<=i*k;j++)
				if(m<p[j]) m=p[j];
		}
		ST[i].max=m;
		ST[i].address=k*(i-1)+1;
	}
	ST[0].max=n;
	ST[i].max=-1;
}
int findelem(excel*ST,int p[],int n)
{
	int i,j;
	int r=ST[0].max;
	for(i=1;i<=r;i++)
	{
		if(ST[i].max>=n)
			break;
	}
	if(i>r)
		return 0;
	if(ST[i+1].max!=-1)
	{
		int t=ST[i+1].address;
		for(j=ST[i].address;j<t;j++)
			if(p[j]==n) return j;
		return 0;
	}
	else
	{
		for(j=ST[i].address;j<=p[0];j++)
			if(p[j]==n) return j;
		return 0;
	}
}
int main()
{
	excel*ST;
	int p[50];
	int n,k;
	cout<<"请输入数据个数：";
	cin>>n;
	p[0]=n;
	cout<<'\n'<<"请输入希望的索引表步长：";
	cin>>k;
	int i;
	cout<<"请按照指定格式输入数据：";
	for(i=1;i<=n;i++)
		cin>>p[i];
	produce(p,k,ST);
	do
	{
		cout<<"请输入想要查找的数据：";
		cin>>n;
		i=findelem(ST,p,n);
		if(i==0)
			cout<<"不存在这样的数据。"<<endl;
		else
			cout<<"您查找的数据所在位数为："<<i<<endl;
		cout<<"请您输入‘1’继续或者输入‘0’结束。"<<endl;
		cin>>i;
	}while(i);
	return 0;
}
8.#include<iostream>
using namespace std;
int findelem(int p[],int n)
{
	int low,mid,high;
	high=p[0];
	low=1;
	while(low<=high)
	{
		mid=(low+high)/2;
		if(p[mid]==n) return mid;
		if(p[mid]>n)
		{
			high=mid-1;
			continue;
		}
		if(p[mid]<n)
		{
			low=mid+1;
			continue;
		}
	}
	return 0;
}
int main()
{
	int p[20];
	int m;
	cout<<"请输入数据个数：";
	cin>>m;
	p[0]=m;
	int i;
	cout<<"请输入数据：";
	for(i=1;i<=m;i++)
		cin>>p[i];
	cout<<"请输入想要查找的数据：";
	cin>>m;
	i=findelem(p,m);
	if(i==0)
		cout<<"没有所查找的数据。"<<endl;
	else
		cout<<"查找的数据下标为："<<i<<endl;
	return 0;
}
9.#include<iostream>
using namespace std;
#define LH 1
#define EH 0
#define RH -1
struct sorttree
{
	int data;
	int be;
	sorttree*left,*right;
};
void rightturn(sorttree*&p)
{
	sorttree*lc=p->left;
	p->left=lc->right;
	lc->right=p;
	p=lc;
}
void leftturn(sorttree*&p)
{
	sorttree*rc=p->right;
	p->right=rc->left;
	rc->left=p;
	p=rc;
}
void isequal(int e,sorttree*T,bool&ifequal)
{
	if(T)
	{
		isequal(e,T->left,ifequal);
		if(T->data==e)
			ifequal=true;
		isequal(e,T->right,ifequal);
	}
}
void leftbalance(sorttree*&T)
{
	sorttree*lc=T->left;
	sorttree*rd;
	switch(lc->be)
	{
	case LH:
		T->be=lc->be=EH;
		rightturn(T);break;
	case RH:
		rd=lc->right;
		switch(rd->be)
		{
		case LH:T->be=RH;lc->be=EH;break;
		case EH:T->be=lc->be=EH;break;
		case RH:T->be=EH;lc->be=LH;break;
		}
		rd->be=EH;
		leftturn(T->left);
		rightturn(T);
	}
}
void rightbalance(sorttree*&T)
{
	sorttree*rd=T->right;
	sorttree*lc;
	switch(rd->be)
	{
	case RH:
		T->be=rd->be=EH;
		leftturn(T);break;
	case LH:
		lc=rd->left;
		switch(lc->be)
		{
		case LH:T->be=EH;rd->be=RH;break;
		case EH:T->be=rd->be=EH;break;
		case RH:T->be=LH;rd->be=EH;break;
		}
		lc->be=EH;
		rightturn(T->right);
		leftturn(T);
	}
}
int insert(sorttree*&T,int e,bool&higher)
{
	if(!T)
	{
		T=new sorttree;
		T->data=e;
		T->left=T->right=NULL;
		T->be=EH;
		higher=true;
	}
	else
	{
		bool ifequal=false;
		isequal(e,T,ifequal);
		if(ifequal)
		{
			higher=false;
			return 0;
		}
		ifequal=false;
		if(e>T->data)
		{
			isequal(e,T->right,ifequal);
		    if(!ifequal)
			{
				if(!insert(T->right,e,higher)) return 0;
			    if(higher)
				{
					switch(T->be)
					{
					case LH:T->be=EH;higher=false;break;
				    case EH:T->be=RH;higher=true;break;
				    case RH:rightbalance(T);higher=false;break;
					}
				}
			}
			else
			{
				if(!insert(T,e,higher)) return 0;
				if(higher)
				{
					switch(T->be)
					{
					case LH:leftbalance(T);higher=false;break;
				    case EH:T->be=LH;higher=true;break;
				    case RH:T->be=EH;higher=false;break;
					}
				}
			}
		}
		else
		{
			isequal(e,T->left,ifequal);
			if(!ifequal)
			{
				if(!insert(T->left,e,higher)) return 0;
				if(higher)
				{
					switch(T->be)
					{
					case LH:leftbalance(T);higher=false;break;
				    case EH:T->be=LH;higher=true;break;
				    case RH:T->be=EH;higher=false;break;
					}
				}
			}
			else
			{
				if(!insert(T,e,higher)) return 0;
			    if(higher)
				{
					switch(T->be)
					{
					case LH:T->be=EH;higher=false;break;
				    case EH:T->be=RH;higher=true;break;
				    case RH:rightbalance(T);higher=false;break;
					}
				} 
			}
		}
	}
	return 1;
}
void visit(sorttree*root)
{
	cout<<root->data<<'\t'<<root->be<<endl;
}
void inorder(sorttree*T)
{
	if(T)
	{
		inorder(T->left);
		visit(T);
		inorder(T->right);
	}
}
void shanchu(sorttree*T)
{
	if(T)
	{
		shanchu(T->left);
		shanchu(T->right);
		delete T;
	}
}
int main()
{
	sorttree*T=NULL;
	int i,n,k;
	bool higher;
	cout<<"请您输入数据个数：";
	cin>>n;
	for(i=0;i<n;i++)
	{
		cin>>k;
		insert(T,k,higher);
	}
	inorder(T);
	shanchu(T);
	return 0;
}
10.#include<iostream>
#include<stack>
#include<cstdlib>
#include<ctime>
using namespace std;
struct Arcnode
{
	int j;
	Arcnode*next;
	int i;
};
struct Vnode
{
	int elem;
	int data;
	Arcnode*first;
};
struct Graph
{

	Vnode*v;
	int length;
};
void depthorder(Graph g)
{
	int n=g.length;
	int*visit=new int[n];
	int i;
	for(i=0;i<n;i++)
		visit[i]=0;
	stack<Vnode> s;
	Vnode*v=g.v;
	Vnode e;
	Arcnode*a;
	s.push(v[0]);
	visit[0]=1;
	while(!s.empty())
	{
		e=s.top();
		s.pop();
		cout<<e.data<<'\t';
		a=e.first;
		while(a!=NULL)
		{
			i=a->j;
			if(visit[i]==0)
			{
				s.push(v[i]);
				visit[i]=1;
			}
			a=a->next;
		}
	}
	delete []visit;
}		
void adjlist(int*p,int a[][20],int n,Vnode*v)
{
	int i,j;
	Arcnode*r,*c;
	bool flag=true;
	for(i=0;i<n;i++)
	{
		v[i].elem=i;
		v[i].data=p[i];
		v[i].first=NULL;
	}
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			if(a[i][j]==1&&flag)
			{
				r=new Arcnode;
				r->i=i;
				r->j=j;
				r->next=NULL;
				v[i].first=r;
				flag=false;
			}
			else
			{
				if(a[i][j]==1&&!flag)
				{
					r=new Arcnode;
					r->i=i;
					r->j=j;
					r->next=NULL;
					c=v[i].first;
					while(c->next!=NULL)
						c=c->next;
					c->next=r;
				}
			}
		}
		flag=true;
	}
}
void matrix(int*p,int a[][20],int n)
{
	srand(time(0));
	int i,j;
	for(i=0;i<n;i++)
		for(j=i+1;j<n;j++)
			a[i][j]=rand()%2;
	for(i=0;i<n;i++)
		for(j=0;j<i;j++)
			a[i][j]=a[j][i];
	for(i=0;i<n;i++)
		a[i][i]=0;
}//随机生成一个图
void vipmatrix(int*p,int a[][20],int n)
{
	srand(time(0));
	int i,j;
	bool flag;
	for(i=0;i<n;i++)
	{
		flag=false;
		for(j=i+1;j<n;j++)
		{
			a[i][j]=rand()%2;
			if(a[i][j]==1) flag=true;
		}
		if(!flag)
			a[i][n-1]=1;
	}	
	for(i=0;i<n;i++)
		for(j=0;j<i;j++)
			a[i][j]=a[j][i];
	for(i=0;i<n;i++)
		a[i][i]=0;
}//生成一颗连通图
int main()
{
	srand(time(0));
	int n=rand()%20;
	int *p=new int[n];
	int i,j;
	for(i=0;i<n;i++)
		p[i]=rand()%200;
	cout<<"该图的元素为：";
	for(i=0;i<n;i++)
		cout<<p[i]<<'\t';
	cout<<endl;
	int a[20][20];
	matrix(p,a,n);//这是随机生成一个图，如果想要生成连通图，就改为：vipmatrix(p,a,n);
	cout<<"该图的邻接矩阵为："<<endl;
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
			cout<<a[i][j]<<'\t';
		cout<<endl;
	}
	Vnode*v=new Vnode[n];
	adjlist(p,a,n,v);
	cout<<"链接表为："<<endl;
	Arcnode*r,*c;
	for(i=0;i<n;i++)
	{
		cout<<i<<":"<<v[i].data<<'\t';
		r=v[i].first;
		if(r)
		{
			while(r->next!=NULL)
			{
				cout<<r->j<<"->";
				r=r->next;
			}
		    cout<<r->j<<endl;
		}
		else
			cout<<endl;
	}
	Graph g;
	g.v=v;
	g.length=n;
	cout<<"该图的深度优先遍历为：";
	depthorder(g);
	delete []p;
	for(i=0;i<n;i++)
	{
		r=v[i].first;
		while(r)
		{
			c=r;
			r=r->next;
			delete c;
		}
	}
	delete []v;
	return 0;
}

总结

本期十个问题：
1.矩阵的转置
2.矩阵的乘法
3.简单的生成树
4.中序遍历和后序遍历
5.前序遍历生成树
6.线索化二叉树
7.索引顺序表的查找
8.折半查找
9.平衡树
10.图的深度优先遍历

XLYcmy
关注
写数据结构代码遇到的一些小问题（更新中）
phoebe
10-17 1433
1.for(int i = 0, i 原因：c99中是不能在for语句中声明的，codeblocks严格按照C99标准，这种语法在codeblocks中用C++写才不会出现错误。 2.如果定义了模板，需要在每个函数前都加template ，不能只写一次，否则会报错说DataType不能作为返回值之类的。
数据结构几道编程题
eyyeyyeyy11的博客
08-09 710
先将其中一个链表的链头按到另一个链表的尾部，如果他们有交集则会构成一个环，题目等价于找链表中的环的起始结点。找到后将链表还原。 一.两个长链表求交点（考虑环） public ListNode getIntersectionNode(ListNode headA, ListNode headB) { if (headA == null || headB == nul
数据结构难题
SSnTi的博客
12-24 659
瑞格课内实验实验二——8568（用队列打印杨辉三角） #include<stdio.h> #include<malloc.h> #include<stdlib.h> #define MAXQSIZE 200 typedef int QElemType; typedef struct { QElemType *base; int front; int rear; }SqQueue; void InitQueue(SqQueue *Q){
数据结构代码题总结-------Day06
brotherand的博客
10-11 4149
数据结构代码题总结 题目01 已知两个链表A和B分别表示两个集合，其元素递增有序排列，编制函数求A和B的交集，并存放在A链表中 题目分析： 求A和B的交集，与求A和B的公共元素不同 并存在在A链表中，-----代表着不可以再申请一个链表的存储空间 与不破坏A和B的结构节点不相同，这里不可以再申请一个新的链表空间。 存放在A链表中表示只可以在A链表上修改 算法思路图解 结合以上的算法图解，对其算法思路进行概述： 设置两个扫描指针p和q，进行对A和B链表的扫描进行操作，同时对其进行p和q所指向节
编程知识+技术开发+数据结构体系概述，如何学习数据结构课程
06-12
数据结构+编程知识+技术开发+数据结构体系概述，如何学习数据结构课程；数据结构+编程知识+技术开发+数据结构体系概述，如何学习数据结构课程；数据结构+编程知识+技术开发+数据结构体系概述，如何学习数据结构课程...
栈与队列：数据结构在编程中的实用应用
06-23
在计算机科学中，栈（Stack）和队列（Queue）是两种基础且重要的数据结构，它们在编程中有着广泛的应用。本文将深入探讨栈和队列的概念、特性以及在不同编程场景下的应用实例，揭示这两种数据结构在软件开发中的关键...
数据结构编程实验 王建德
06-20
acm指导老师王建德编写的 ，非常值得看，不过不太适合初学数据结构的同学
算法、数据结构和编程面试示例 - Java - 下载.zip
09-15
《算法、数据结构和编程面试Java实战指南》 在当今的IT行业中，算法、数据结构以及编程能力是衡量一个程序员专业水平的重要标准，特别是在求职面试中，这些技能的掌握程度往往直接影响到面试的成功与否。本资源包...
编程数据结构和算法讲解书
04-10
在编程领域，数据结构和算法是核心组成部分，它们是解决问题和设计高效程序的基础。这本书《编程数据结构和算法讲解》显然旨在深入解析这两个关键概念，帮助读者提升编程技能。 数据结构是组织和存储数据的方式，它...
数据结构与算法重难点100道
using namespace 数学工具构造器;
02-17 1528
文章目录1. 两数之和3. 无重复字符的最长子串2. 两数相加5. 最长回文子串42. 接雨水206. 反转链表4. 寻找两个正序数组的中位数21. 合并两个有序链表15. 三数之和146. LRU 缓存机制 1. 两数之和 class Solution { public: vector<int> twoSum(vector<int> &nums, int target) { map<int, int> sub2ix; fo
数据结构与算法（Java版） | 就让我们来看看几个实际编程中遇到的问题吧！
李阿昀的博客
02-14 714
上一讲，我给大家简单介绍了一下数据结构，以及数据结构与算法之间的关系，照理来说，接下来我就应该要给大家详细介绍线性结构和非线性结构了，但是在此之前，我决定还是先带着大家看几个实际编程中遇到的问题，看完之后咱们再说。
1.数据结构与算法相关问题与解决技巧
weixin_41207499的博客
10-08 966
一. 分割字符串问题 已知字符串"ab;cd|efg|hi,jk1|mn\topq;rst,uvw\txyz", 其中的',' ';' '|' '\t' 都是分割符，如何处理? 方法1、 连续使用str.split s = "ab;cd|efg|hi,jk1|mn\topq;rst,uvw\txyz" def my_split(s, seps): res = [s] fo...
数据结构常见问题系列(二)
zhf的博客
11-06 1661
文章目录1. 常用数据结构2. 什么是链表、队列、栈3. 什么是树（平衡二叉树、二叉排序树、B树、B+树、R树、红黑树） 1. 常用数据结构 1). 数组：顺序存储，随机访问。 链表：链表存储，顺序访问。 2). 栈：分为栈顶和栈底，遵循先进后出的原则。 3). 队列： 先进先出原则(类比成排队一样)。 4). 树：二叉树、平衡二叉树、大、小顶堆等。 5). 图：最短路径，关键路径。 2. 什么是链表、队列、栈 链表：   当需要存储多个相同数据类型的时候，可以使用数组存储，数组可以通过下标直
数据结构编程题
weixin_43482612的博客
03-21 5686
考研数据结构编程题（附完整代码）1、给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5，3，2，3}中未出现的最小正整数是1；数组{1，2，3}中未出现的最小正整数是4。要求： 1、给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5，3，2，3}中未出现的最小正整数是1；数组{1，2，3}中未出现的最小正整数是4。要求： （1）给出算法的基本设计思想。 要求在时间上尽可能高
数据结构经典代码题（从小白开始）
m0_58323186的博客
11-12 2340
2.对长度为n的顺序表L,编写一个时间复杂度为O（n）,空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的元素。算法思想：遍历顺序表，用k记录顺序表中值为x的个数，让其中元素不等于x的向前移动k个单位量。解题思路：第一个元素不重复，依次遍历顺序表，如果值相同就保留下来，如果值不相同就删除。1.设计一个高效算法，将顺序表L的所有元素逆置，要求算法空间复杂度为常数级。算法思想：依次将顺序表L前半部分的元素与顺序表后半部分的元素进行交换。
树——数据结构
b19839356939的博客
09-18 624
树、数据结构、树的定义、树的概念、树的应用、结点
数据结构二
m0_73504072的博客
09-17 939
在64位得计ge算机下 共32个字节long 是占8个字节 但是32位得情况下24个字节 long 占4个字节但是所以可以分配在 char得内存地址中 ，所以占8个字节 而char占8个字节 而 double占8个字节24个字节。在计算机是这样存储得但计算机时小段存储所以在存储书记时低地址存在高位 而低地址存在低位 所以 存储方式应该是 0x 00050003。12 char被分配4个内存 short被分配到 x1 而float分配4个字节而x4则分配4个字节。④按照学生的分数进行排序。
【高级数据结构】并查集
最新发布
Antonio915的博客
09-18 1166
前面讲解了并查集的基本应用—一处理集合问题。在这些基本应用中,点之间只有简单的归属关系,而没有权值。如果在点之间加上权值,并查集的应用会更广泛。如果读者联想到树这种数据结构,会发现并查集实际上是在维护若干棵树。并查集的合并和查询优化,实际上是在改变树的形状,把原来“细长”的,操作低效的大量“小树”,变为“粗短”的、操作高效的少量“大树”。如果在原来的“小树”上,点之间有权值,那么经过并查集的优化变成“大树”后,这些权值的操作也变得高效了。定义一个权值数组dd[]d,把节点iii。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值