数据结构编程问题（三）

于 2022-07-12 11:45:36 发布
阅读量168 收藏
点赞数
文章标签： 数据结构 算法 链表 散列表 图搜索算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XLYcmy/article/details/125739758
版权

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

文章目录

前言

继续

一、问题

1.链表
2.暴力法
3.查找数据
4.索引表
5.矩阵乘法
6.求取最大值
7.容器相关问题
8.符号重载
9.平衡树
10.子列

二、代码

1-5

代码如下：

1.#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;
struct node
{
	int data;
	node*next;
};
node*Insert(node*head,node*p)
{
	node*p1,*p2=NULL;
	if(head==NULL)
	{
		head=p;
		p->next=NULL;
		return(head);
	}
	p1=head;
	while((p->data)>(p1->data)&&p1->next!=NULL)
	{
		p2=p1;
		p1=p1->next;
	}
	if((p->data)<=(p1->data))
	{
		p->next=p1;
		if(head==p1) head=p;
		else p2->next=p;
	}
	else
	{
		p1->next=p;
		p->next=NULL;
	}
	return(head);
}
node*sortcreate(void)
{
	node*p,*head=NULL;
	srand(time(0));
	int a=rand();
	int m;
	cout<<"请您输入希望链表的长度："<<endl;
	cin>>m;
	while(m>0)
	{
		p=new node;
		p->data=a;
		head=Insert(head,p);
		a=rand();
		m--;
	}
	return(head);
}
node*addup(node*La,node*Lb)
{
	node*Lc=((La->data)<=(Lb->data))?La:Lb;
	node*pc=Lc;
	node*pa=La->next;
	node*pb=Lb;
	node*p;
	while(pa&&pb)
	{
		if(pa->data<=pb->data)
		{
			if(pa->data<pb->data)
			{
				pc->next=pa;
				pc=pa;
				pa=pa->next;
			}
			else
			{
				pc->next=pa;
				pc=pa;
				pa=pa->next;
				p=pb;
				pb=pb->next;
				delete p;
			}
		}
		else
		{
			pc->next=pb;
			pc=pb;
			pb=pb->next;
		}
	}
		pc->next=pa?pa:pb;
		return(Lc);
}
void free(node*head)
{
	node*p;
	while(head)
	{
		p=head;
		head=head->next;
		delete p;
	}
}
void show(node*head)
{
	int i=0;
	node*p=head;
	while(p)
	{
		if(i%5==0) cout<<'\n';
		cout<<p->data<<'\t';
		i++;
		p=p->next;
	}
	cout<<endl;
}
int main()
{
	node*La,*Lb,*Lc;
	La=sortcreate();
	Lb=sortcreate();
	cout<<"La数据为：";
	show(La);
	cout<<"Lb数据为：";
	show(Lb);
	Lc=addup(La,Lb);
	cout<<"Lc数据为：";
	show(Lc);
	free(Lc);
	return 0;
}
2.#include<iostream>
using namespace std;
#define N 50 
int index(char S[N],char T[N],int pos)
{
	int i=pos,j=0;
	int m=strlen(S),n=strlen(T);
	while(i<m&&j<n)
	{
		if(S[i]==T[j]){++i;++j;}
		else{i=i-j+2;j=1;}
	}
	if(j>=n)
		return i-n;
	else return 0;
}
int main()
{
	char S[N]={"xbcdabcdabxabasyu"},T[N]={"bcd"};
	int pos=0;
	pos=index(S,T,pos);
	cout<<"位次是："<<pos<<endl;
	return 0;
}
3.#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;
}
4.#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;
}
5.#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;
}

6-10

代码如下：

6.#include<iostream>
using namespace std;

int main()
{
	int max=0;
	int a[4]={1,2,3,4};
	for(int i=0;i<4;i++)
	{
		if(max<a[i])
			max=a[i];
		cout<<a[i];
	}
	return 0;
}
7.#include<iostream>
using namespace std;
template <typename T>
class CValue
{
	T a[5];
public:
	CValue(T b[5])
	{
		for(int i=0;i<5;i++)
			a[i]=b[i];
	}
	friend T max(CValue<T> m);
	friend T min(CValue<T> m);
};
T max(CValue<T> m)
{
	T max=m.a[0];
	for(int i=0;i<5;i++)
	{
		if(max<m.a[i]) max=m.a[i];
	}
	return max;
}
T min(CValue<T> m)
{
	T min=m.a[0];
	for(int i=0;i<5;i++)
	{
		if(min>m.a[i]) min=m.a[i];
	}
	return min;
}
int main()
{
	int a1[5]={0},i=0;
	float a2[5]={0};
	double a3[5]={0};
	for(i=0;i<5;i++)
		cin>>a1[i];
	for(i=0;i<5;i++)
		cin>>a2[i];
	for(i=0;i<5;i++)
		cin>>a3[i];
	CValue<int>c1(a1);
	CValue<float>c2(a2);
	CValue<double>c3(a3);
	cout<<max(c1)<<'\t'<<min(c1)<<'\n'<<max(c2)<<'\t'<<min(c2)<<'\n'<<max(c3)<<'\t'<<min(c3)<<endl;
	return 0;
}
8.#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<memory>
#include<cstdlib>
using namespace std;
struct Review
{
	string title;
	int rating;
	int price;
};
bool operator<(const shared_ptr<Review>&r1,const shared_ptr<Review>&r2)
{
	if(r1->title<r2->title)
		return true;
	else if(r1->title==r2->title&&r1->rating<r2->rating)
		return true;
	else
		return false;
}
bool worseThan(const shared_ptr<Review>&r1,const shared_ptr<Review>&r2)
{
	if(r1->rating<r2->rating)
		return true;
	else
		return false;
}
bool betterThan(const shared_ptr<Review> &r1, const shared_ptr<Review> &r2)
{
	if (r1->rating > r2->rating)
		return true;
	else
		return false;
}
bool worseThanP(const shared_ptr<Review> &r1, const shared_ptr<Review> &r2)
{
	if (r1->price < r2->price)
		return true;
	else
		return false;
}
bool betterThanP(const shared_ptr<Review> &r1, const shared_ptr<Review> &r2)
{
	if (r1->price > r2->price)
		return true;
	else
		return false;
}
bool FillReview(shared_ptr<Review>&rr)
{
	cout<<"Enter book title(quit to quit):";
	getline(cin,rr.title);
	if(rr->title=="quit")
		return false;
	cout<<"Enter book rating:";
	cin>>rr->rating;
	if(!cin)
		return false;
	while(cin.get()!='\n')
		continue;
	return true;
}
void ShowReview(const shared_ptr<Review>&rr)
{
	cout<<rr->rating<<"\t"<<rr->title<<'\t'<<rr->price<<endl;
}
shared_ptr<Review> make_Review()
{
	return shared_ptr<Review>(new Review);
}
int main()
{
	vector<shared_ptr<Review>>books;
	shared_ptr<Review> temp(new Review);
	while(FillReview(temp))
	{
		books.push_back(temp);
        temp=make_Review();	
	}
	if(books.size()>0)
	{
		vector<shared_ptr<Review>> sbook(books);
		cout << "Thank you. You entered the following:\n"<< books.size() << " ratings:\n" << "Rating\tBook\tPrice\n";
		for_each(books.begin(), books.end(), ShowReview);
		char ch;
		cout << "Enter measures of sort:\no to old";
		cout << "t to title, r to down rating,\nR to up rating"<<"p to down price,P to up price, f(F) to shuffle,\nq to quit:";
		cin >> ch;
		while (tolower(ch) != 'q')
		{
			switch (ch)
			{
			case'o':
				cout << "Not Sort:\nRating\tBook\tPrice\n";
				for_each(books.begin(), books.end(), ShowReview);
				break;
			case't':
				sort(sbook.begin(), sbook.end());
				cout << "Sorted by title:\nRating\tBook\tPrice\n";
				for_each(sbook.begin(), sbook.end(), ShowReview);
				break;
			case'r':
				sort(sbook.begin(), sbook.end(), worseThan);
				cout << "Sorted by  down rating:\nRating\tBook\tPrice\n";
				for_each(sbook.begin(), sbook.end(), ShowReview);
				break;
			case'R':
				sort(sbook.begin(), sbook.end(), betterThan);
				cout << "Sorted by  up rating:\nRating\tBook\tPrice\n";
				for_each(sbook.begin(), sbook.end(), ShowReview);
				break;
			case'p':
				sort(sbook.begin(), sbook.end(), worseThanP);
				cout << "Sorted by down price:\nRating\tBook\tPrice\n";
				for_each(sbook.begin(), sbook.end(), ShowReview);
				break;
			case'P':
				sort(sbook.begin(), sbook.end(), betterThanP);
				cout << "Sorted by up price:\nRating\tBook\tPrice\n";
				for_each(sbook.begin(), sbook.end(), ShowReview);
				break;
			case'F':
			case'f':
				random_shuffle(sbook.begin(), sbook.end());
				cout << "After shuffling:\nRating\tBook\n";
				for_each(sbook.begin(), sbook.end(), ShowReview);
				break;
			default:
				cout << "Error input!Input again!";
				break;
			}
			cout << "Enter the next measures:\no to old";
			cout << "t to title, r to down rating,\nR to up rating"
				"p to down price,P to up price, q to quit:";
			cin >> ch;	
		}
	}
	else
		cout << "No entries. ";
	cout<<"Bye.\n";
	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>
using namespace std;
#define N 50 
int index(char S[N],char T[N],int pos)
{
	int i=pos,j=0;
	int m=strlen(S),n=strlen(T);
	while(i<m&&j<n)
	{
		if(S[i]==T[j]){++i;++j;}
		else{i=i-j+2;j=1;}
	}
	if(j>=n)
		return i-n;
	else return 0;
}
int main()
{
	char S[N]={"xbcdabcdabxabasyu"},T[N]={"bcd"};
	int pos=0;
	pos=index(S,T,pos);
	cout<<"位次是："<<pos<<endl;
	return 0;
}

总结

敬请期待第四篇

XLYcmy
关注
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
【数据结构与算法】拓扑排序问题C语言实现
「 刘一哥与GIS的故事」
03-10 2315
拓扑排序是有向无环图的一种应用，在实际生活中用的很多。 比如GIS专业的课程设计，许多课程需要前置课程要求，也就是说没上过A课程、则不可能直接去学B课程，画个图表就是： 同理，我们教材中的范例：穿衣服的过程也是一个拓扑排序问题，如下表： 有关这个拓扑排序的模型构造以及解法、我们的教材有着十分详尽的描述，这里不再叙述，我们主要要解决的就是：如何编程： 从教材P194图7.33到图7.34，我们可知该问题的求解过程是： 1 寻找入度为0的顶点、标记它们并进栈； 2 出栈、然后删除该顶点； 3 返回到.
C/C++知识点总结
LilyZJ的博客
10-18 1228
C++笔试知识点总结（语法及常用函数）输入输出C++中的new/deletevector 输入输出 (1) 第一行输入两个整数M，N；接下来M行分别输入2个数，最后一行输入N个数（由于输入行数，个数都确定，用循环很好处理） (2)循环输入多行 while(cin>>m>>n){ } (3)输入一行数字，数字间以空格分隔 #include<sstream> in.........
一篇文章快速搞懂C++生成随机数
Running Snail
03-09 929
使用rand()函数 头文件<stdlib.h> 如果你只要产生随机数而不需要设定范围的话，你只要用rand()就可以了：rand()会返回一随机数值, 范围在0至RAND_MAX 间。 RAND_MAX定义在stdlib.h, 其值为2147483647。 #include <iostream> #include <cstdlib> using namespa...
数据结构链表合并c语言实现,链表实现多项式的合并
weixin_33526828的博客
05-21 325
已结贴√问题点数：20回复次数：4 链表实现多项式的合并#include #include //the definiton of listtypedef struct node{int xs;int zs;node *next;}lb;typedef lb* lbx ;//the creation of list (tail insert with head node)lbx create(v...
数据结构自学笔记 第二章
qq_51408591的博客
08-25 714
文章目录数据结构第二章部分笔记顺序表和链表的比较链式存储结构的优点链式存储结构的缺点线性表的应用线性表的合并有序表的合并顺序表实现用链表实现 数据结构第二章部分笔记 顺序表和链表的比较 链式存储结构的优点 1.结点空间可以动态申请和释放 2.插入和删除时不需要移动数据元素，只需要改变指针 链式存储结构的缺点 1.存储密度小，每个结点的指针域需额外占用存储空间。 **存储密度：结点数据本身占用的空间/**结点占用的空间总量 2.非随机存取，要沿着指针链查找到某一结点，增加了算法复杂度。 线性表的应用 线性表的
C++代码笔记
longTT_TT的博客
03-08 4403
猜数字游戏 系统随机生成一个1到100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或过小，如果猜对恭喜玩家胜利，并且退出游戏。 错解： #include<iostream> #include<cstdlib> using namespace std; int main() { int num = rand() %100+1;//生成0-100的随机数 int a=0; cout << "请输入猜测的数字: "<<endl; cin >&
数据结构经典编程习题
03-23
这个压缩包“数据结构经典编程习题”提供了学习数据结构过程中可能会遇到的一些典型问题及其解决方案，是提升编程能力和深入理解数据结构的有效资源。 在数据结构的学习中，我们通常会接触到以下几个主要的知识点：...
数据结构编程题（不断更新）
WangQYoho的博客
09-27 6658
记录一些数据结构的编程题好题： 1、计算二叉树深度 public class Solution { public int TreeDepth(TreeNode pRoot) { return pRoot == null ? 0 : Math.max(TreeDepth(pRoot.left), TreeDepth(pRoot.right)) + 1; } }递归
【数据结构中时间复杂度的问题】编程求x^y 最后三位数表示的整数（java）
m0_67463447的博客
03-15 1777
编程求x ^y 最后三位数表示的整数。 输入格式: 输入不超过最大整数的两个数x、y 输出格式: 输出x^y最后三位数 import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int m = sc.nextInt(); int n = sc.nextInt();
c语言中next和prior连在一起,数据结构（C语言版）课后习题答案
weixin_29291573的博客
05-19 1219
第2章 线性表1．选择题(1)顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是( )。A．110 B．108 C．100 D．120答案：B解释：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。(2)在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是( )。 A．访问第i...
数据结构一小时复习（严蔚敏版）
lryl1218的专栏
06-24 2149
基础基础！ 一、绪论 1。数据结构是计算机程序设计的重要理论技术基础。为了编写一个好的程序，九须分析待处理的对象的特性以及各处理对象之间存在的关系。2。计算机解决具体问题的步骤：从具体问题抽象数学模型，设计一个解模型的算法，编程，测试，调整达标。3。数据结构是介于数学，计算机硬件，计算机软件三者之间的一门核心课程。4。数据是对客观事物的符号表示，所有能输入到计算机中并被告计算机程序处理的符号总称。
iostream如何被qing_dao_boy正确打开
qing_dao_boy的博客
01-09 281
如果你看了这个文章，你才能直接编译以后我的博客的文件 接下来，是iostream在2020/1/9的改法，你应该将你的iostream一样改一下 // Standard iostream objects -*- C++ -*- // Copyright (C) 1997-2013 Free Software Foundation, Inc. // // This file is part of ...
对链表的操作（数据结构线性表算法设计练习）
diaobin0154的博客
10-05 1025
/*1.有一个单链表（不同结点的数据域值可能相同），其头指针为head，编写一个函数计算数据域为x的结点个数*/ #include <iostream> #include <cstdio> using namespace std; struct node{ int data; struct node *next; }; struct node...
单链表的合并【去重】
有梦的博客
09-20 1668
//-------2个有序单链表的合并------ void Mergelist_L(LinkList &LA,LinkList &LB,LinkList &LC) { pa=LA->next;pb=LB->next; LC=LA; LinkList pc=LC; while(pa&&pb) { if(pa->datadata) { pc->next=pa; p
卡时技巧（时间卡常技巧）
alobjgo278266549的博客
01-31 881
#include<ctime> #include<cstdlib> #include<iostream> using namespace std; double t; const double CLOCKS_PER_SECOND=((clock_t)1000);//定义常量 void dfs() { cout<<1; if...
将两个非递减的有序链表合并为一个非递增的有序链表
热门推荐
强强强子的博客
10-11 2万+
将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。 void MergeList(LinkList& La, LinkList& Lb, LinkList& Lc, ) {//合并链表La和Lb，合并后的新表使用头指针Lc指向 pa=La->next; pb=Lb->next; //pa和p
数据结构 作业答案 第2章 线性表
HKD_WCY的博客
06-14 1万+
第2章 线性表 1．选择题 （1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ ）。 A．110 B．108 C．100 D．120 答案：B 答案解析：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。 （2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（ ）。 A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） B．在第i个结点后插入一个新结点（1
Python编程：数据结构与算法解析
7. **案例研究和应用**：可能包含实际问题的案例，展示如何运用数据结构和算法来解决这些问题，从而提升读者的编程和问题解决能力。 通过阅读和学习这本书，读者不仅可以掌握数据结构与算法的基本概念，还能学会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值