DS的代码整理(上)

于 2023-04-18 11:13:58 发布
阅读量203 收藏
点赞数
分类专栏： 数据结构 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hackermengzhi/article/details/130217346
版权

OJ上已经把我的账号记录删除了，只有本地还有一些存档，但是我又不记得题目，只有文件名写了是ABCDE，就把代码都发出来吧。
A

#include<iostream>
using namespace std;
template<class T>
void Sort(T a[],int n) {
	int i,j;
	T temp;
	for(i=0; i<n-1; i++)//进行一个冒泡的排序 
		for(j=i+1; j<n; j++)
			if(a[i]>a[j]) {
				temp=a[i];
				a[i]=a[j];
				a[j]=temp;
			}
}
int main(){
	int t,i,j,n;
	char a;
	cin>>t;
	while(t--){
		cin>>a>>n;
		switch(a){		//判断什么类型的数据 
			case 'I':{
				int b[n];
				for(i=0;i<n;i++)
					cin>>b[i];
				Sort(b,n);
				for(i=0;i<n;i++)	
					cout<<b[i]<<" ";
				cout<<endl;
				break;
			}
			case 'C':{
				char b[n];
				for(i=0;i<n;i++)
					cin>>b[i];
				Sort(b,n);
				for(i=0;i<n;i++)	
					cout<<b[i]<<" ";
				cout<<endl;
				break;
			}
			case 'S':{
				string b[n];
				for(i=0;i<n;i++)
					cin>>b[i];
				Sort(b,n);
				for(i=0;i<n;i++)	
					cout<<b[i]<<" ";
				cout<<endl;
				break;
			}
			case 'D':{
				double b[n];
				for(i=0;i<n;i++)
					cin>>b[i];
				Sort(b,n);
				for(i=0;i<n;i++)	
					cout<<b[i]<<" ";
				cout<<endl;
				break;
			}
		}
	}
}

B

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		double yuan;
		int zh;
		queue<char> que;
		stack<char>st;
		cin >> yuan >> zh;
		int zhengshu = int(yuan);
		double xiaoshu = yuan - zhengshu;
		while (zhengshu)
		{
			int k = zhengshu % zh;
			zhengshu /= zh;
			if (k > 9)
				st.push('A' + k - 10);
			else
				st.push(k + '0');
		}
		int tt = 5;
		while (xiaoshu)
		{
			tt--;
			if (tt == 1)break;
			xiaoshu = xiaoshu * zh;
			int k = int(xiaoshu);
			if (k > 9) {
				que.push(k + 'A' - 10);
			}
			else
				que.push(k + '0');
			xiaoshu = xiaoshu - k;
		}
 
 
		if (st.empty())
			cout << "0.";
		else {
			while (!st.empty()) 
			{
				cout << st.top();
				st.pop();
			}
			cout << '.';
		}
 
 
		if (que.empty())
			cout << "000";
		else
		{
			int o = 3;
			while (o--)
			{
				if (que.empty())
					cout << "0";
				else
				{
					cout << que.front();
					que.pop();
				}
			}
 
		}
		cout << endl;
	}
	return 0;
}

C

#include<iostream>
#include<cstring>
using namespace std;
template<class T>
void Sum(T a[],int n) {
	int i,j;
	T temp;
	for(i=0; i<n-1; i++)		//先进行从小到大的排序
		for(j=i+1; j<n; j++)
			if(a[i]>a[j]) {
				temp=a[i];
				a[i]=a[j];
				a[j]=temp;
			}
	T winner=a[0];
	T people=a[0];
	int max_num=0,num=1;	
	for(i=0; i<n; i++) {
		if(people!=a[i+1]) {//变换指针 
			if(num>max_num) {
			max_num=num;
			winner=people;
			}	
			num=1;
			people=a[i+1];
		}else
			num++;
	}
	cout<<winner<<" "<<max_num<<endl;
}
int main() {
	int t,i,j,n;
	char a;
	cin>>t;
	while(t--) {
		cin>>a>>n;
		switch(a) {
			case 'I': {
				int b[n+1]; 	
				for(i=0; i<n; i++)
					cin>>b[i];
				Sum(b,n);
				break;
			}
			case 'C': {
				char b[n+1];
				for(i=0; i<n; i++)
					cin>>b[i];
				Sum(b,n);
				break;
			}
			case 'S': {
				string b[n+1];
				for(i=0; i<n; i++)
					cin>>b[i];
				Sum(b,n);
				break;
			}
		}
	}
}

列表的D题

#include<iostream>
#include <cstring>
using namespace std;
template<class T>
class List {
	private:
		T p[100];  //定义数组 
		int size;	//数组大小 
	public:
		List(int n1) {
			size=n1;
			for(int i=0; i<n1; i++)
				cin>>p[i];
			for(int i=n1;i<100;i++)
				p[i]=-1;	
		}
		void insert(int a,T num) {		//插入一个元素 
			size++;
			for(int i=size; i>a; i--) {
				p[i]=p[i-1];
			}
			p[a]=num;
		}
		void del(int a) {			//删除一个元素 
			for(int i=a; i<size; i++)
				p[i]=p[i+1];
			size--;
		}
		void print() {
			for(int i=0; i<size; i++)
				cout<<p[i]<<" ";
			cout<<endl;
		}
		~List() {
		}
};
int main() {
	int n;
	cin>>n;
	List<int> L1(n);
	int pos1,num1;
	cin>>pos1>>num1;
	L1.insert(pos1,num1);
	cin>>pos1;
	L1.del(pos1);
	L1.print();
	cin>>n;
	List<float> L2(n);
	float pos2,num2;
	cin>>pos2>>num2;
	L2.insert(pos2,num2);
	cin>>pos2;
	L2.del(pos2);
	L2.print();
}

E

#include<iostream>
#include <cstring>
using namespace std;
template<class T>
class Matrix {
	private:
		T** a;
		int m,n;
	public:
		Matrix(int _m,int _n):
			m(_m),n(_n){
				a=new T*[m];
				for(int i=0;i<m;i++){
					a[i]=new T[n];
				}
				for(int i=0;i<m;i++)
					for(int j=0;j<n;j++){
						cin>>a[i][j];
					}
			}
			void transport() {	
			T **temp;
			int i, j,t;
			temp=new T*[n]; 	 
			for(i=0; i<n; i++) {
				temp[i]=new T[m];   
			}
			for(i=0; i<m; i++)
				for(j=0; j<n; j++)
					temp[j][i]=a[i][j];
			a=new T*[n];  	
			for(i=0; i<n; i++) {
				a[i]=new T[m];    
			}
			t=m;
			m=n;
			n=t;
			for (i=0; i<m; i++)
				for (j=0; j<n; j++)
					a[i][j]=temp[i][j];
			delete temp;
		}
		void print(){
			for(int i=0;i<m;i++){
				for(int j=0;j<n;j++)
					cout<<a[i][j]<<" ";
				cout<<endl;
			}
		}
		~Matrix() {
			if(a!=NULL)
				delete a;
		}		
};
int main(){
	int t,m,n;
	cin>>t;
	char a;
	while(t--){
		cin>>a>>m>>n;
		switch(a){		//判断什么类型的数据 
			case 'I':{
				Matrix<int> M1(m,n);
				M1.transport();
				M1.print();
				break;
			}
			case 'C':{
				Matrix<char> M2(m,n);
				M2.transport();
				M2.print();
				break;
			}
			case 'D':{
				Matrix<double> M3(m,n);
				M3.transport();
				M3.print();
				break;
			}
		
		}
	}
}

AVL.cpp

#include <iostream>
using namespace std;

#define LH +1
#define EH 0
#define RH -1

typedef struct BSTNode
{
	int data;
	int bf;
	struct BSTNode* lchild, * rchild;
}BSTNode, * BSTree;

void R_Rotate(BSTree& p)
{
	BSTree lc;

	lc = p->lchild;
	p->lchild = lc->rchild;
	lc->rchild = p;
	p = lc;

	return;
}

void L_Rotate(BSTree& p)
{
	BSTree rc;
	rc = p->rchild;
	p->rchild = rc->lchild;
	rc->lchild = p;
	p = rc;

	return;
}
void LeftBalance(BSTree& T)
{
	//瀵规寚閽圱鎵€鑷磋妭鐐逛负鏍圭殑浜屽弶鏍戜綔骞宠　鏃嬭浆澶勭悊
	BSTree lc;
	lc = T->lchild;
	//妫€鏌鑺傜偣鐨勫乏瀛╁瓙锛屾牴鎹叾骞宠　鍥犲瓙鍒ゆ柇鏄彸鏃嬭繕鏄乏鍙冲弻鏃?
	switch (lc->bf)
	{
		//宸﹀瀛愮殑骞宠　鍥犲瓙涓?锛屽钩琛″洜瀛愭槸鐩寸嚎锛屽彸鏃?
	case LH:
		T->bf = EH;
		lc->bf = EH;
		R_Rotate(T);
		break;
		//宸﹀瀛愬钩琛″洜瀛愪负-1锛屽钩琛″洜瀛愪负鎶樼嚎锛屽乏鍙冲弻鏃?
	case RH:
		BSTree rd;
		rd = lc->rchild;
		//淇敼T鑺傜偣鍜屽叾宸﹀瀛愮殑骞宠　鍥犲瓙
		switch (rd->bf)
		{
		case LH:
			T->bf = RH;
			lc->bf = EH;
			break;
		case EH:
			T->bf = lc->bf = EH;
			break;
		case RH:
			lc->bf = LH;
			T->bf = EH;
			break;
		}
		rd->bf = EH;
		L_Rotate(T->lchild);
		R_Rotate(T);
	}
}
void RightBalance(BSTree& T)
{
	//瀵规寚閽圱鎵€鑷磋妭鐐逛负鏍圭殑浜屽弶鏍戜綔骞宠　鏃嬭浆澶勭悊
	BSTree rc;

	rc = T->rchild;
	//妫€鏌鑺傜偣鐨勫彸瀛╁瓙锛屾牴鎹叾骞宠　鍥犲瓙鍒ゆ柇鏄乏鏃嬭繕鏄彸宸﹀弻鏃?
	switch (rc->bf)
	{
		//鍙冲瀛愮殑骞宠　鍥犲瓙涓?1锛屽钩琛″洜瀛愭槸鐩寸嚎锛屽乏鏃?
	case RH:
		T->bf = EH;
		rc->bf = EH;
		L_Rotate(T);
		break;
		//鍙冲瀛愬钩琛″洜瀛愪负-1锛屽钩琛″洜瀛愪负鎶樼嚎锛屽彸宸﹀弻鏃?
	case LH:
		BSTree ld;
		ld = rc->lchild;
		//淇敼T鑺傜偣鍜屽叾鍙冲瀛愮殑骞宠　鍥犲瓙
		switch (ld->bf)
		{
		case LH:
			T->bf = EH;
			rc->bf = RH;
			break;
		case EH:
			T->bf = rc->bf = EH;
			break;
		case RH:
			T->bf = LH;
			rc->bf = EH;
			break;
		}
		ld->bf = EH;
		R_Rotate(T->rchild);
		L_Rotate(T);
	}
}

int InsertAVL(BSTree& T, int e, bool& taller)
{
	if (!T)
	{
		T = (BSTree)malloc(sizeof(BSTNode));
		T->data = e;
		T->lchild = NULL;
		T->rchild = NULL;
		T->bf = EH;
		taller = true;
	}
	else
	{
		//鏍戜腑宸插瓨鍦ㄥ拰e鐩稿悓鐨勮妭鐐癸紝杩斿洖0
		if (T->data == e)
		{
			taller = false;
			return 0;
		}
		//缁х画鍦ㄥ乏瀛愭爲涓悳绱?
		if (T->data > e)
		{
			//璇存槑閫掑綊鎻掑叆澶辫触浜?
			if (!InsertAVL(T->lchild, e, taller))
			{
				taller = false;
				return 0;
			}
			//鍒拌繖閲岃鏄庢彃鍏ユ垚鍔燂紝鍒ゆ柇骞宠　鍥犲瓙
			if (taller)
			{
				switch (T->bf)
				{
					//鍘熸湰宸﹀瓙鏍戞瘮鍙冲瓙鏍戦珮锛屽啀鎻掑叆浠ュ悗锛屽钩琛″洜瀛愬彉涓?锛屾鏃堕渶瑕佸仛宸﹀钩琛″鐞?
				case LH:
					LeftBalance(T);
					taller = false;
					break;
					//鍘熸湰宸﹀彸瀛愭爲,绛夐珮锛岀幇鍥犲乏瀛愭爲澧為珮鑰屼娇鏍戝楂?
				case EH:
					taller = true;
					T->bf = LH;
					break;
					//鍘熸湰鍙冲瓙鏍戞瘮宸﹀瓙鏍戦珮锛岀幇鍦ㄥ乏鍙冲瓙鏍戠櫥楂?
				case RH:
					taller = false;
					T->bf = EH;
					break;
				}
			}
		}
		//缁х画鍦ㄥ彸瀛愭爲涓悳绱?
		else
		{
			if (!InsertAVL(T->rchild, e, taller))
			{
				taller = false;
				return 0;
			}
			//鍒拌繖閲岃鏄庢彃鍏ユ垚鍔燂紝鍒ゆ柇骞宠　鍥犲瓙
			if (taller)
			{
				switch (T->bf)
				{
					//鍘熸湰宸﹀瓙鏍戞瘮鍙冲瓙鏍戦珮锛屾彃鍏ヤ互鍚庯紝宸﹀彸绛夐珮
				case LH:
					T->bf = EH;
					taller = false;
					break;
					//鍘熸湰绛夐珮锛屾彃鍏ヤ互鍚庯紝鍙冲瓙鏍戠瓑楂?
				case EH:
					T->bf = RH;
					taller = true;
					break;
					//鍘熸湰鍙冲瓙鏍戦珮锛屾彃鍏ヤ互鍚庯紝骞宠　鍥犲瓙鍙樹负-2锛岄渶瑕佸仛鍙冲钩琛″鐞?
				case RH:
					RightBalance(T);
					taller = false;
					break;
				}
			}
		}
	}

	return 1;
}

//涓簭閬嶅巻
void InorderTraversal(BSTree node)
{
	if (!node)
	{
		return;
	}
	else
	{
		InorderTraversal(node->lchild);
		cout << node->data << ':' << node->bf << ' ';
		InorderTraversal(node->rchild);
	}
	return;
}

int main(void)
{
	//flag鐢ㄤ簬鍒ゆ柇鏄惁鎻掑叆鎴愬姛锛宼ure涓烘垚鍔?false涓哄け璐?
	int t;
	cin >> t;
	while (t--)
	{
		// 鏋勫缓浜屽弶骞宠　鏍戯紝骞跺湪鎻掑叆鍏冪礌鏃跺仛骞宠　澶勭悊 
		int n, elem;
		cin >> n;
		BSTree T = NULL;
		bool flag = false;
		while (n--)
		{
			cin >> elem;
			InsertAVL(T,elem,flag);
		}
		InorderTraversal(T);
		cout << endl;
	}
	system("pause");
	return 0;
}

快排.cpp

#include<iostream>
using namespace std;

 
void quick_sort(int arr[],int l,int r,int n)
{
	if(l < r)
	{
		int i = l, j = r, x = arr[l];
		//在区间内使基准数左边为小，右边为大 
		while(i < j)
		{
			//从右向左找到第一个小于x的数 
			while(i < j && arr[j] >= x)
				j--;
			
			if(i < j)
				arr[i++] = arr[j];
				
			//从左向右找到第一个大于x的数 
			while(i < j && arr[i] < x)
				i++;
				
			if(i < j)
				arr[j--] = arr[i];
		}
		//更新基准数位置 
		arr[i] = x;
		cout << x << " " << i+1 << endl;
		//二分再调用 
		quick_sort(arr,l,i-1,n);
		quick_sort(arr,i+1,r,n);
	}
	else if(l == r){
		cout << arr[l] << " " << l+1 << endl;
	}
}


 
 int main()
 {
 	int t;
 	cin >> t;
 	while(t--)
 	{
 		int n;
 		cin >> n;
 		int *arr = new int[n];
 		for(int i = 0; i < n; i++) cin >> arr[i];
 		
 		quick_sort(arr,0,n-1,n);
		 cout << endl;
	 } 
	 return 0;
 }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

谁的BUG最难改

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值