数据结构实验2

最新推荐文章于 2021-10-09 18:00:22 发布
最新推荐文章于 2021-10-09 18:00:22 发布
阅读量150 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FEIXIANGDEXINZHE/article/details/105221941
版权 
#include <iostream>
#include<list>
#include<vector>
#include<algorithm>
using namespace std;

template<class T>
struct BTNode
{
public:
	T element;
	BTNode* leftchild;
	BTNode* rightchild;


	BTNode() {leftchild = rightchild = NULL;}
	BTNode(T x, BTNode*a, BTNode*b)
	{
		leftchild = a;
		rightchild = b;
		element = x;
	}
	~BTNode(){};
	BTNode(T x) { element = x; leftchild = NULL; rightchild = NULL; }

	BTNode<T> operator=(BTNode<T> x)
	{
		element = x.element;
		leftchild = x.leftchild;
		rightchild = x.rightchild;
		return *this;
	}
};

template<class T>
class BT
{
public:
	BT() { root = NULL; treesize = 0; trans=0;}
	BT(int num){
		root=NULL;
		treesize=num;
		trans=0;
	}
	~BT() { erase(root); }

	BTNode<T>* myroot() { return root; };
	void initial(int num);
	bool empty()const { return treesize == 0; }
	int size() { return treesize; }
	void preorder(BTNode<T>* t);
	void out_xor(BTNode<T>* t);
	void inorder(BTNode<T>* t);
	void postorder(BTNode<T>* t);
	void levelorder(BTNode<T>* t);
	void fun5();
	void fun6();
	BTNode<T>* find(int node,BTNode<T>* t);

	int calnum(BTNode<T>* t);
	int calhei(BTNode<T>* t);

	void visit(BTNode<T>* t) { cout << t->element << " "; }
	void erase(BTNode<T>* t)
	{
		
		if (t != NULL)
		{
			erase(t->leftchild);
			erase(t->rightchild);
			delete t;
		}
		root = NULL;
		treesize = 0;
	}

	BTNode<T>* root;
	int treesize;
	int ans;
	bool trans;
};
/*-----------------------------------------------------*/

struct treenode
{
	int element;
	int parent;
	vector<int> children;
	
	treenode(){};
	treenode(int ele,int par){element=ele;parent=par;};
	
};

template<class T>
class forest
{
public:
	forest()
	{
		forestsize=0;
		treenum=0;
		fore.resize(5005);	
	};
	~forest()
	{
		from_forest.erase(from_forest.root);
	};
	void initial(int num1,int num2);
	void out_xor(int rootnode);
	void to_bt();
	void construct(BTNode<T>* a,int b);
	void out_test(int);
	void fun1();
	void fun2();
	void fun3();
	void fun4();
	void fun5(){from_forest.fun5();}
	void fun6();
		
	vector<treenode> fore;
	int treeroot[110];//用于保存根节点下标，从而找到根节点； 
	int forestsize;
	int treenum;	
	int ans;
	bool trans;
	BT<T> from_forest;
};
/*-------------------------------------------*/



/*-----------------------------------------------------*/
/*-----------------------------------------------------*/
//类btree的ADT 
template<class T>
class btree
{
public:
	btree() { root = NULL; treesize = 0; trans=0;}
	btree(int num){
		root=NULL;
		treesize=num;
		trans=0;
	}
	~btree() { erase(root); }

	BTNode<T>* myroot() { return root; };
	void initial(int num);
	bool empty()const { return treesize == 0; }
	int size() { return treesize; }
	void preorder(BTNode<T>* t);
	void out_xor(BTNode<T>* t)
	{
		if (t != NULL)
	{
		ans^=(t->element);
		out_xor(t->leftchild);
		out_xor(t->rightchild);
	}
	};
	void inorder(BTNode<T>* t);
	void postorder(BTNode<T>* t);
	void levelorder(BTNode<T>* t);
	void to_forest();
	void construct_for(BTNode<T>*);
	void fun1(){
		from_bt.fun1();
	};
	void fun2()
	{
		from_bt.fun2();
	};
	void fun3()
	{
		from_bt.fun3();
	};
	void fun4()
	{
		to_forest();
	};
	void fun5()
	{
		int pos,father,node;
		cin>>pos>>father>>node;
		BTNode<T>* f=find(father,root);
		BTNode<T>* _node=new BTNode<T>(node);
		if(pos==0)
			f->rightchild=_node;
		else f->leftchild=_node;
		treesize++;
	};
	void fun6()
	{
		if(trans==0)
		{
			ans=0;
			out_xor(root);
			cout<<ans<<endl;
		}
		else if(trans==1)
		{
			from_bt.trans=0;
			from_bt.fun6();		
		}
	};
	BTNode<T>* find(int node,BTNode<T>* t);

	int calnum(BTNode<T>* t);
	int calhei(BTNode<T>* t);

	void visit(BTNode<T>* t) { cout << t->element << " "; }
	void erase(BTNode<T>* t)
	{
		
		if (t != NULL)
		{
			erase(t->leftchild);
			erase(t->rightchild);
			delete t;
		}
		root = NULL;
		treesize = 0;
	}

	BTNode<T>* root;
	int treesize;
	int ans;
	bool trans;
	forest<int> from_bt;
};
/*-----------------------------------------------------*/
/*-----------------------------------------------------*/

template<class T>
void btree<T>::levelorder(BTNode<T>* t)
{
	list<BTNode<T>* > q;
	while (t != NULL)
	{
		BT<T>::visit(t);
		if (t->leftchild != NULL)
			q.push_back(t->leftchild);
		if (t->rightchild != NULL)
			q.push_back(t->rightchild);

		if (!q.empty())
			t = q.front();
		else return;
		q.pop_front();
	}
}

template<class T>
BTNode<T>* btree<T>::find(int node,BTNode<T>* t)
{
	list<BTNode<T>* > q;
	while (t != NULL)
	{
		if(t->element==node)
		return t;
		if (t->leftchild != NULL)
			q.push_back(t->leftchild);
		if (t->rightchild != NULL)
			q.push_back(t->rightchild);

		if (!q.empty())
			t = q.front();
		else return NULL;
		q.pop_front();
	}
}

template<class T>
void btree<T>::initial(int num)
{
	cout<<"请输入二叉树中各初始节点："<<endl;
	treesize = num;
	trans=0;
	int node_root;
	cin>>node_root;
	BTNode<T> **temp = new BTNode<T>*[treesize+1];
	for (int i = 1; i <= treesize; ++i)
		temp[i] = new BTNode<T>(i);
	root = temp[node_root];

	int A, left, right;
	for (int j = 1; j <= treesize; ++j)
	{
		cin >> A>> left >> right;
		if (left != -1)
			temp[j]->leftchild = temp[left];
		else temp[j]->leftchild = NULL;
		if (right != -1)
			temp[j]->rightchild = temp[right];
		else temp[j]->rightchild = NULL;
	}
	delete []temp;
	cout<<"二叉树初始完毕！"<<endl;
}

template<class T>
void btree<T>::to_forest()
{
	trans=1;
	vector<BTNode<T>*> root_node;
	BTNode<T>* t=root,*x=NULL;
	from_bt.treenum=0;
	while(t!=NULL)
	{
		root_node.push_back(t);
		from_bt.treeroot[from_bt.treenum++]=t->element;
		x=t;
		t=t->rightchild;
		x->rightchild=NULL;
	}
	//依次将每棵二叉树转化为树
	for(int i=0;i<from_bt.treenum;++i)
	{
		//cout<<"TEST: ";
		//cout<<root_node[i]->element<<endl;
		construct_for(root_node[i]);
		//cout<<"???"<<endl;
		//from_bt.out_test(from_bt.treeroot[i]);
	} 
		
}

template<class T>
void btree<T>::construct_for(BTNode<T> * rtmp)
{
	if(rtmp==NULL)return;
	BTNode<T> *x=rtmp->leftchild;
	from_bt.fore[rtmp->element].element=rtmp->element;
	if(x!=NULL)
	{
		//cout<<"x此时："<<x->element<<endl;
		from_bt.fore[rtmp->element].children.push_back(x->element);
		from_bt.fore[x->element].parent=rtmp->element;		
		from_bt.fore[x->element].element=x->element;		
		BTNode<T> *r=x->rightchild;
		while(r!=NULL)
		{
			//cout<<"r此时："<<r->element<<endl;
			from_bt.fore[rtmp->element].element=rtmp->element;
			from_bt.fore[rtmp->element].children.push_back(r->element);
			from_bt.fore[r->element].element=r->element;
			from_bt.fore[r->element].parent=rtmp->element;
			r=r->rightchild;
		}
	}
	construct_for(x);
	construct_for(rtmp->rightchild);
}


template<class T>
void BT<T>::preorder(BTNode<T>* t)
{
	if (t != NULL)
	{
		visit(t);
		preorder(t->leftchild);
		preorder(t->rightchild);
	}
}

template<class T>
void BT<T>::out_xor(BTNode<T>* t)
{
	if (t != NULL)
	{
		ans^=(t->element);
		out_xor(t->leftchild);
		out_xor(t->rightchild);
	}
}

template<class T>
void BT<T>::inorder(BTNode<T>* t)
{	if (t != NULL)
	{
		inorder(t->leftchild);
		BT<T>::visit(t);
		inorder(t->rightchild);
	}
}

template<class T>
void BT<T>::postorder(BTNode<T>* t)
{
	if (t != NULL)
	{
		postorder(t->leftchild);
		postorder(t->rightchild);
		BT<T>::visit(t);
	}
}

template<class T>
void BT<T>::levelorder(BTNode<T>* t)
{
	list<BTNode<T>* > q;
	while (t != NULL)
	{
		BT<T>::visit(t);
		if (t->leftchild != NULL)
			q.push_back(t->leftchild);
		if (t->rightchild != NULL)
			q.push_back(t->rightchild);

		if (!q.empty())
			t = q.front();
		else return;
		q.pop_front();
	}
}

template<class T>
BTNode<T>* BT<T>::find(int node,BTNode<T>* t)
{
	list<BTNode<T>* > q;
	while (t != NULL)
	{
		if(t->element==node)
		return t;
		if (t->leftchild != NULL)
			q.push_back(t->leftchild);
		if (t->rightchild != NULL)
			q.push_back(t->rightchild);

		if (!q.empty())
			t = q.front();
		else return NULL;
		q.pop_front();
	}
}

template<class T>
void BT<T>::initial(int num)
{
	treesize = num;
	trans=0;
	int node_root;
	cin>>node_root;
	BTNode<T> **temp = new BTNode<T>*[treesize+1];
	for (int i = 1; i <= treesize; ++i)
		temp[i] = new BTNode<T>(i);
	root = temp[node_root];

	int A, left, right;
	for (int j = 1; j <= treesize; ++j)
	{
		cin >> A>> left >> right;
		if (left != -1)
			temp[j]->leftchild = temp[left];
		else temp[j]->leftchild = NULL;
		if (right != -1)
			temp[j]->rightchild = temp[right];
		else temp[j]->rightchild = NULL;
	}
	delete[]temp;
}

template<class T>
void BT<T>::fun5()
{
	int pos,father,node;
	cin>>pos>>father>>node;
	BTNode<T>* f=find(father,root);
	BTNode<T>* _node=new BTNode<T>(node);
	if(pos==0)
		f->leftchild=_node;
	else f->rightchild=_node;
		treesize++;
}

template<class T>
void BT<T>::fun6()
{
	if(trans==0)
	{
		ans=0;
		out_xor(root);
		cout<<ans<<endl;
	}
}



/*---------------------------------------------------------------------------*/
template<class T>
void forest<T>::initial(int num1,int num2)
{
	cout<<"请输入森林中各棵树初始的根节点："<<endl;
	trans=0;
	treenum=num1;
	forestsize=num2;
	int rootx;
	for(int i=0;i<treenum;++i)
	{
		cin>>rootx;
		treeroot[i]=rootx;	
		fore[rootx].element=rootx;
		fore[rootx].parent=-1;	
	}
	int A,B,nodex;
	for(int i=0;i<forestsize;++i)
	{
		cin>>A>>B;
		for(int k=0;k<B;++k)
		{
			cin>>nodex;
			fore[nodex].element=nodex;
			fore[A].children.push_back(nodex);
			fore[nodex].parent=A;
		}
	}
	cout<<"森林已经初始化完毕！"<<endl<<endl; 
}

template<class T>
void forest<T>::fun1()
{
	int father,node;
		forestsize++;
		cin>>father>>node;
		if(father==-1)
		{
			fore[node].element=node;
			fore[node].parent=-1;
			treeroot[treenum++]=node;
		}
		else
		{
			fore[father].children.push_back(node);
			fore[node].element=node;
			fore[node].parent=father;
		}
}

template<class T>
void forest<T>::fun2()
{
	forestsize--;
	int father,node;
			cin>>father>>node;
			if(father==-1)
			{
				//删除根节点
				 for(int i=0;i<fore[node].children.size();++i)
				 {
				 	int curnode=fore[node].children[i];
				 	fore[curnode].parent=-1;
				 	treeroot[treenum++]=curnode;		 	
				 }
				 //将根节点从treeroot数组中删除
				 int mark=0;
				 for( mark=0;mark<treenum;++mark)
				 	if(treeroot[mark]==node)break;
				treenum--;
				for(int i=mark;i<treenum;++i)
				treeroot[i]=treeroot[i+1];
				fore[node].children.clear(); 
			}
			else
			{
				for(int i=0;i<fore[node].children.size();++i)
				 {
				 	int curnode=fore[node].children[i];
				 	fore[curnode].parent=-1;
				 	treeroot[treenum++]=curnode;		 	
				 }
				 //将node从father的孩子中删除
				 vector<int>::iterator ia;
				 ia=find(fore[father].children.begin(),fore[father].children.end(),node);
				 fore[father].children.erase(ia);
			}
}
template<class T>
void forest<T>::fun3()
{
	int a,b;
	cin>>a>>b;
	fore[b].parent=a;
	fore[a].children.push_back(b);
	int i=0;
	for(i=0;i<treenum;++i)
		if(treeroot[i]==b)break;
	treenum--;
	for(int k=i;k<treenum;++k)
		treeroot[k]=treeroot[k+1];
}

template<class T>
void forest<T>::fun4()
{
		to_bt();
}

template<class T>
void forest<T>::fun6()
{
	//升序输出每棵树各元素的异或值
	if(trans==0)
	{
		sort(treeroot,treeroot+treenum);
		for(int i=0;i<treenum;++i)
		{
			ans=0;
			out_xor(treeroot[i]);
			cout<<ans<<" ";
		}
		cout<<endl;	
	}
	else
	{
		from_forest.ans=0;
		from_forest.out_xor(from_forest.root);
		cout<<from_forest.ans<<endl;
	}
}

template<class T>
void forest<T>::to_bt()
{
	trans=1;
	//将所有节点排序
	for(int i=1;i<=forestsize;++i)
		sort(fore[i].children.begin(),fore[i].children.end()); 
	for(int i=0;i<treenum;++i)
		{
			vector<int> v;//存放所有不止一个孩子的节点
			v.clear();
			list<int> l;
			l.clear();
			//层次遍历寻找所有孩子多于1个的节点
			l.push_back(treeroot[i]);		
			while(!l.empty())
			{
				int f=l.front();
				if(fore[f].children.size()>1)v.push_back(f);
				for(int g=0;g<fore[f].children.size();g++)
				l.push_back(fore[f].children[g]);
				l.pop_front();
			} 

			//从最后一个元素开始处理
			for(int j=v.size()-1;j>=0;--j)
			{
				for(int h=0;h<fore[v[j]].children.size()-1;++h)
				{
					int curbro=fore[v[j]].children[h];
					int curbro2=fore[v[j]].children[h+1];
					fore[curbro].children.push_back(curbro2);
					fore[curbro2].parent=curbro;
				}
				vector<int>::iterator ie=fore[v[j]].children.begin()+1;
				fore[v[j]].children.erase(ie,fore[v[j]].children.end());
				} 
		} 	
		sort(treeroot,treeroot+treenum);
			 BTNode<T>* allbt[treenum];
			 //遍历每一棵树进行构造
			 for(int i=0;i<treenum;++i)
			 {
			 	allbt[i]=new BTNode<T>(treeroot[i]);
			 	construct(allbt[i],treeroot[i]);
			 } 
			 //合并所有的二叉树
			 for(int i=0;i<treenum-1;++i)
			 allbt[i]->rightchild=allbt[i+1];
			 from_forest.root=allbt[0]; 	 			 			  
}

template<class T>
void forest<T>::construct(BTNode<T> *roottmp,int nodetmp)
{
	for(int i=0;i<fore[nodetmp].children.size();++i)
	{
		if(i==0)
		{
			roottmp->leftchild=new BTNode<T>(fore[nodetmp].children[0]);
			construct(roottmp->leftchild,fore[nodetmp].children[0]);
		}
		else if(i==1)
		{
			roottmp->rightchild=new BTNode<T>(fore[nodetmp].children[1]);
			construct(roottmp->rightchild,fore[nodetmp].children[1]);
		}
	}
}
template<class T>
void forest<T>::out_xor(int rootnode)
{
	ans^=rootnode;
	for(int i=0;i<fore[rootnode].children.size();++i)
		out_xor(fore[rootnode].children[i]);
}

template<class T>
void forest<T>::out_test(int rootnode)
{
	cout<<rootnode<<" ";
	for(int i=0;i<fore[rootnode].children.size();++i)
		out_test(fore[rootnode].children[i]);
}

int main()
{
	cout<<"请选择初始化ADT的类型（输入0表示初始化森林，输入1表示初始化二叉树）："<<endl;
	int K,M,N,Q,flag;
	cin>>K;
	if(K==1)
	{
		cout<<"您已经选择初始化二叉树，请输入1表示一棵树："<<endl;
		cin>>M;
		cout<<"请输入初始化二叉树中节点的数目："<<endl;
		cin>>N; 
		btree<int> x;
		x.initial(N);
		cout<<"接下来您可以对二叉树/森立进行操作，各操作表示如下："<<endl;
		cout<<"1 father node"<<"--------表示为森林中树的结点 father "
		<<"插入一个孩子结点 node "<<endl;
		cout<<"2 father node"<<"--------表示删除森林中的结点 node , "
		<<"其中 father 是 node 的父亲结点"<<endl;
		cout<<"3 a      b   "<<"--------表示在森林中的根结点 a, b 间插入一条边, "
		<<"其中 a 为 b 结点的父亲。"<<endl;
		cout<<"4 "<<"-------------------将该森林转换为二叉树"<<endl;
		cout<<"5 pos father node "<<"---表示为二叉树的 father 结点插入一个孩子 node"<<endl;
		cout<<"6 "<<"-------------------显示森林/二叉树。"<<endl<<endl;
		cout<<"您需要输入操作的数量："<<endl; 	
		int Q;
		cin >> Q;
		for(int i=0;i<Q;++i)
		{
			cout<<"请输入操作："; 
			cin>>flag;
			switch(flag)
			{
				case 1:cout<<"------>------>操作1成功！"; x.fun1();cout<<endl<<endl;break;
				case 2:cout<<"------>------>操作2成功！"; x.fun2();cout<<endl<<endl;break;
				case 3:cout<<"------>------>操作3成功！"; x.fun3();cout<<endl<<endl;break;
				case 4:cout<<"------>------>操作4成功！"; x.fun4();cout<<endl<<endl;break;
				case 5:cout<<"------>------>操作5成功！"; x.fun5();cout<<endl<<endl;break;
				case 6:cout<<"------>------>操作6成功！"; x.fun6();cout<<endl<<endl;break;				
			}
		}
	}
	else
	{
		cout<<"您已经选择初始化森林，请输入森林中树的数目："<<endl;
		cin>>M;
		cout<<"您已经选择初始化"<<M<<"棵树，请输入初始化节点的数目："<<endl;
		cin>>N; 
		forest<int> y;
		y.initial(M,N);
		cout<<"接下来您可以对二叉树/森林进行操作，各操作表示如下："<<endl;
		cout<<"1 father node"<<"--------表示为森林中树的结点 father "
		<<"插入一个孩子结点 node "<<endl;
		cout<<"2 father node"<<"--------表示删除森林中的结点 node , "
		<<"其中 father 是 node 的父亲结点"<<endl;
		cout<<"3 a      b   "<<"--------表示在森林中的根结点 a, b 间插入一条边, "
		<<"其中 a 为 b 结点的父亲。"<<endl;
		cout<<"4 "<<"-------------------将该森林转换为二叉树"<<endl;
		cout<<"5 pos father node "<<"---表示为二叉树的 father 结点插入一个孩子 node"<<endl;
		cout<<"6 "<<"-------------------显示森林/二叉树。"<<endl<<endl;
		cout<<"您需要输入操作的数量："<<endl; 
		cin>>Q;
		for(int i=0;i<Q;++i)
		{
			cout<<"请输入操作："; 
			cin>>flag;
			switch(flag)
			{
				case 1:	cout<<"------>------>操作1成功！";y.fun1();cout<<endl<<endl;break;
				case 2: cout<<"------>------>操作2成功！";y.fun2();cout<<endl<<endl;break;
				case 3: cout<<"------>------>操作3成功！";y.fun3();cout<<endl<<endl;break;
				case 4: cout<<"------>------>操作4成功！";y.fun4();cout<<endl<<endl;break;
				case 5: cout<<"------>------>操作5成功！";y.fun5();cout<<endl<<endl;break;
				case 6: cout<<"------>------>操作6成功！"
				<<"显示如下：";y.fun6();cout<<endl;break;				
			}
		}
	}

	return 0;
}
QiaoSu001
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验二
打工人的博客
06-08 919
一、实验目的 1、线性表的链表实现：遍历、查找、插入、删除、翻转 2、栈的链式存储结构实现：入栈、出栈 3、队列的链式存储结构的实现：入队、出队 4、线性表、栈和队列的应用实现 二、使用仪器、器材 微机一台 操作系统：WinXP 编程软件：C++ 三、实验内容及原理 利用二叉树的二叉链式存储结构设计并实现各种操作算法。 1、二叉树的基本操作算法实现 (1) 利用二叉树字符串“A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”创建二叉树的二叉链式存储结构； (2) 输出该二叉树； (
数据结构专题-05 二叉树2
u014421914的博客
03-05 70
example https://pintia.cn/problem-sets/994805342720868352/problems/994805365537882112 #include <iostream> #include <queue> #define maxSize 10 using namespace std; typedef struct BTNode { int left = -1; int right = -1; }BTNode; void arr2B
数据结构实践——B-树的基本操作
weixin_33834628的博客
11-29 443
本文是针对[数据结构基础系列(8)：查找]的实践。 【项目 - B-树的基本操作】 实现B-树的基本操作。基于序列{4, 9, 0, 1, 8, 6, 3, 5, 2, 7}完成测试。 （1）创建对应的3阶B-树b，用括号法输出b树。 （2）从b中分别删除关键字为8和1的节点，用括号法输出删除节点后的b树。 [参考解答] #...
数据结构 实验2——表达式求值
热门推荐
m0_57587757的博客
10-09 1万+
一、实验名称：表达式求值 二、实验学时：6学时 三、实验目的 1.理解栈的结构特点和基本操作特性； 2.掌握利用栈实现表达式求值算法。 四、实验内容(步骤) 输入一个算术表达式(以“=”结束)，求其值。要求表达式以“=”结束，操作数为多位实数，对错误表达式要进行检测。 1.设置两个栈：optr算符栈和opnd操作数栈。初始置opnd为空栈；起始符“=”为optr的栈底元素； 2.自左向右扫描表达式中的每个字符c： 1)若c为操作数，则进opnd栈； 2)若c为算符，则让optr栈的栈顶元
数据结构实验2_数据结构实验2_
09-29
在这个名为“数据结构实验2”的项目中，我们将深入研究一系列关键概念和技术，这些内容通常包括数组、链表、栈、队列、树以及图等基本数据结构的实现和应用。 实验2可能涵盖以下主题： 1. **栈（Stack）**：栈是一...
数据结构试验2-栈和队列实验报告含源码
03-08
在这个"数据结构试验2-栈和队列实验报告含源码"中，我们将深入探讨两个基本且至关重要的数据结构——栈和队列。 栈（Stack）是一种后进先出（LIFO，Last In First Out）的数据结构。想象一个堆叠的盘子，最后一个放...
湖南大学数据结构实验2-游戏.zip
03-08
在湖南大学的数据结构实验2中，学生们通过游戏的形式来深入理解数据结构的概念和应用。这个实验可能旨在让学生们在实践中体验和掌握各种数据结构，如数组、链表、栈、队列、树和图等，以及它们在解决问题时的关键...
东北大学数据结构实验2欧洲旅行
06-24
在“东北大学数据结构实验2欧洲旅行”中，学生被要求设计并实现一个基于铁路系统的程序，名为"RailSystem.cpp"。这个实验的核心是利用数据结构来模拟火车旅行的复杂情况，让学生深入理解和应用计算机科学中的核心...
数据结构实验2 资源： file.txt
04-02
数据结构实验2 资源： file.txt
my share source
08-15
my share source
毕业设计asp.net学生评教系统-qkrp源码含文档工具包
08-15
毕业设计asp.net学生评教系统-qkrp源码含文档工具包 asp.net，数据库sqlserver，开发工具用Microsoft Visual Studio 管理员登录 学生管理 添加 管理 教师管理 添加 管理 学院管理员 添加 管理 教务管理 得分统计 考核统计 意见汇总 包含：源码、数据库脚本、论文、环境工具包（在说明文档中）
Autologging-0.4.0-py2.py3-none-any.whl.zip
08-15
Autologging-0.4.0-py2.py3-none-any.whl.zip
基于springboot的抗疫物资管理系统 源码+数据库（毕业设计）
08-15
基于Vue.js和SpringBoot的抗疫物资管理系统是一个高效、易用的物资管理解决方案，它分为管理后台和用户网页端，支持管理员和普通用户两种角色。系统主要功能包括物资分类、物资信息管理、物资出入库记录、物资资讯发布和公告管理模块。管理员可以通过后台对物资进行分类、添加、编辑和删除，同时对物资的出入库进行详细记录，确保物资的准确性和可追溯性。普通用户可以在网页端查看物资信息、资讯和公告，了解抗疫物资的最新动态。整个系统采用前后端分离的架构，前端使用Vue.js进行开发，后端使用SpringBoot框架，保证了系统的稳定性和可扩展性。 录屏：https://www.bilibili.com/video/BV17K421x7hn 教程：https://space.bilibili.com/417412814/channel/collectiondetail?sid=2242844
用于MATLAB的神经网络工具箱(英文版)
08-15
本资料主要聚焦于神经网络工具的介绍与应用。详细阐述了各类神经网络模型的原理和架构，如多层感知机、卷积神经网络等。还涵盖了相关工具的使用方法，包括数据准备、模型训练的流程与技巧。通过丰富的实例，展示如何运用这些工具解决实际问题，如预测、分类等。同时，对模型的评估指标和优化策略也有所涉及，帮助读者掌握有效利用神经网络工具进行开发和研究的核心要点。
全球各国-经济距离数据2005-2022.xlsx
08-15
特点：今年全新，手工精心整理，放心引用，数据来自权威，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 课程引用: 经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理 ## 数据指标说明 全球各国经济制度距离数据，旨在衡量国家在经济制度方面的相似性或差异性。该数据覆盖183个国家，包括两种主要的测算结果。各国经济制度距离数据可为研究者提供了一个框架，帮助大家更好地了解国家之间的经济环境差异。 数据名称：全球183个国家世界各国经济制度距离-各国经济环境差异 数据年份：2005-2022年 数据格式：Excel
基于长短期记忆网络的时间序列预测Matlab源码+数据集+界面截图+博客预览(一键运行，课程设计/期末大作业
最新发布
08-15
<项目介绍> https://blog.csdn.net/m0_73728511/article/details/141227582 运行main.m文件一键出图超级简单 实现平台：Matlab，中文注释非常清晰，非常适合新手小白上手。 程序均以调试好，按照示例数据修改格式，替换数据集即可运行，数据集为excel。 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的大作业，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
JavaScript集合.zip
08-15
JavaScript集合.zip
美赛 社区团购系统 java springboot
08-15
美赛 社区团购系统 java springboot
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值