2021/2/5

今天偷了个懒，一天下来就刷了一道题，然后就一直玩手机今天就把今天刷的题和前天学习的所有排序记录一下
1
.
这个题，很明显就是要用并查集求出分支数，不过增加了理解难度，我的理解就是，这就是对0到9这几个数进行合并，当一个人的令牌包含那几个数，我们就把那几个数给合并在一起，这样如果有人的令牌有和他相同的数字，也就会通过那个相同的数字而合并到一起，这样这题就解法就是通过令牌对0到9这几个数字进行排序。
AC代码

#include<stdio.h>
int a[10],b[10];//a数组用来记录并查集，b数组我们用到来记录最后的根的个数
char c[1005];//c数组用来保存他们的令牌
int t,n,num;
void init()
{
	for(int i=0;i<10;i++)
	a[i]=i;
	for(int i=0;i<10;i++)
	b[i]=-1;//-1表示这个数没有出现过，下标代表数
}
int find(int x)
{
	if(a[x]==x)
	return x;
	return a[x]=find(a[x]);
}
void join(int x,int y)
{
	x=find(x);
	y=find(y);
	if(x==y)
	return;
	a[y]=x;
}
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		num=0;
		init();
		scanf("%d",&n);
		while(n--)
		{
			scanf("%s",c);
			int x=c[0]-'0';
			b[x]=0;
			for(int i=1;c[i];i++)
			{
				int y=c[i]-'0';
				b[y]=0;//0表示这个数出现过了
				join(x,y);//对每个令牌进行合并
			}
		}
		for(int i=0;i<10;i++)
		{
			int temp=find(a[i]);//遍历每一个数，找出根
			if(b[temp]==0)//如果这个数出现过，我们就记录
			b[temp]=1;
		}
		for(int i=0;i<10;i++)
		if(b[i]==1) num++;//把最后根的数量记录，就是答案
		printf("%d\n",num);
	}
}

下面就对前天学习的各种排序记录一下
1.插入排序
这个排序的思想是，我们以次找某一个数应该待的位置，在我们找的过程中找过得数后移或者前移，如果从后面第一个数开始找，那么以次和前面的进行比较，比较过得往后移，当找到合数的位置的时候，就插入

//最好的情况o（n），最坏O（n的平方） 
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int n;
	printf("请输入需要排序的个数\n");
	scanf("%d",&n);
	int *a=(int*)malloc(sizeof(int)*n);
	int i,j;
	for(i=0;i<n;i++)
	scanf("%d",&a[i]);
	for(i=1;i<n;i++)
	{//我们先从前2个开始，然后递增
		int temp=a[i];//最后一个的值
		for(j=i-1;j>=0;j--)//和前面的开始比较
		{
			if(temp<a[j])
			a[j+1]=a[j];
			else break;//这个排的是升序，当temp》的时候就代表找到位置了
		}
		a[j+1]=temp;//这时候的位置是比他小的后一个
	}
	for(i=0;i<n;i++)
	printf("%d ",a[i]);
}

2.shell排序
这个排序是插入排序的升华，他的思想就是，先以某一个步长的对数组进行排序，然后步长减一直到1，这样的好处就是越到后面需要交换的次数也就越少。

//shell思想，把要排序的序列先以增量为步长从头到尾进行排序，并且增量最后为1；
//空间代价O（1），时间代价以除 2递减，代价为O（n的平方），找到合适的增量可以接近O（n）
//hibbard增量序列（2的k次方-1,2的k-1次方减一，，，，，7,3，1，）
//shell（3）和上面那个可以达到O（n的1.5次方） 
#include<stdio.h>
void shellsort(int a[],int n,int zl)
{
	int i,j;
	for(i=zl;i<n;i+=zl)//从子序列第二个开始往前比 
	{
		for(j=i;j>=zl;j-=zl)//因为下面有j-zl所以j只要到zl就可以了，否则越界 
		if(a[j-zl]>a[j]) //如果后面大于前面则交换 
		{
			int t;
			t=a[j];
			a[j]=a[j-zl];
			a[j-zl]=t;
		}
		else break;	
	}
}
int main()
{
	int n; 
	printf("请输入要排序的个数\n");
	scanf("%d",&n);
	int i,j,a[n];	
	for(i=0;i<n;i++)
	scanf("%d",&a[i]);
	for(i=n/2;i>0;i/=2)//i表示增量，该程序除以2递减，当我们不能确定增量是否会到1的时候要加一句，增量为1 的 插入排序 
	{
		for(j=0;j<i;j++)//分别对i个子序列进行插入排序， 
		shellsort(&a[j],n-j,i);//传a【i】的地址，子序列长度为n-i 
		//shellsort（a，n，1）扫尾语句 
	}
	for(i=0;i<n;i++)
	printf("%d ",a[i]);
}

3.选择排序
这个排序呢，就是我们先找出最小的，再找出第2小的，在找的过程中我们再把它们放到合适的位置。

//时间浮渣度O（n的平方），不稳定 
#include<stdio.h>
int main()
{
	int n;
	printf("请输入要排序数的个数\n");
	scanf("%d",&n);
	int a[n],i,j;
	for(i=0;i<n;i++)
	scanf("%d",&a[i]);
	for(i=0;i<n-1;i++)
	{
		int min=i;//先假设最小的就是第一个
		for(j=i+1;j<n;j++)
		{
			if(a[min]>a[j])
			min=j;//找出小的
		}
		if(min!=i)//如果小的下标发生了改变
		{
			int t=a[min];
			a[min]=a[i];
			a[i]=t;
		}
	}
	for(i=0;i<n;i++)
	printf("%d ",a[i]);	
} 

4,.堆排序
这个排序可以说是很好理解了，他就是利用了堆和优先队列，当升序的时候就是最小堆，降序就是最大堆

//堆排序，利用最小或者最大推辅助排序
//键堆O(n)
//删除堆顶O（longn）
//时间代价O（nlogn） 
#include<stdio.h>
int rear,dl[1000];
void push(int temp)
{
	rear++;
	int index=rear;
	while(index>1)
	{
		int p=index/2;
		if(temp<dl[p])
		dl[index]=dl[p];
		else break;
		index=p;
	}
	dl[index]=temp;
}
int pop()
{
	int result=dl[1];
	int x=dl[rear];
	rear--;
	int index=1;
	while(2*index<=rear)
	{
		int l=2*index;
		int min=l;
		if(l+1<=rear&&dl[l]>dl[l+1])
		min=l+1;
		if(x<=dl[min])
		break;
		dl[index]=dl[min];
		index=min;
	}
	dl[index]=x;
	return result;
}
int main()
{
	int n;
	printf("请输入要排序的元素个数\n");
	scanf("%d",&n);
	int i,j,a[n];
	for(i=0;i<n;i++)
	{
		int temp;
		scanf("%d",&temp);
		push(temp);
	}
	for(i=0;i<n;i++)
	a[i]=pop();
	for(i=0;i<n;i++)
	printf("%d ",a[i]);
}

下面就是交换排序，也就是冒泡排序和快速排序
5.冒泡排序
这个算法的思想就是，每一次我们把极值往前或者往后冒

//稳定
//O（n的平方） 
#include<stdio.h>
int main()
{
	int n;
	printf("请输入需要排序的数量\n");
	scanf("%d",&n);
	int a[n];
	int i,j;
	for(i=0;i<n;i++)
	scanf("%d",&a[i]);
	for(i=0;i<n-1;i++)//要进行n-1次冒泡
	{	int flag=1;
		for(j=n-1;j>i;j--)//从最后开始往前面冒，把小的冒到前面
		if(a[j]<a[j-1])
		{
			int t=a[j];
			a[j]=a[j-1];
			a[j-1]=t;
			flag=0;
		}
		if(flag)//当有一次没有进行交换，那么就已经有序
		break;
	}	
	for(i=0;i<n;i++)
	printf("%d ",a[i]);
} 

6.快速排序
快排是很普及，很好用的一种排序，他的思想就是先找一个轴值，然后轴值左边的比轴值小，右边的比轴值大，这样轴值就到了合适的位置，然后对左右子串继续这种操作

//选择轴值
//将序列划分为2个子序列，使得左边小于轴值，右边大于轴值
//对左右进行递归
//分治的思想
//划分，求解子问题（子问题不重叠），综合解 
#include<stdio.h>
void swap(int a[],int x,int y)//进行交换 
{
	int t;
	t=a[x];
	a[x]=a[y];
	a[y]=t;
}
int zhi(int a[],int left,int right)
{
	int mid=a[right];//把轴值保存在一个变量 ，因为在上次的时候我们把轴值赋值到了最右边的位置 
	while(left!=right) //现在left往右走，right往左走 
	{
		while(a[left]<=mid&&left<right)//因为我们把轴值赋值到了最右边所以，我们先从左边开始，找到比轴值大的，并且放到轴值得位置 
		left++;
		if(left<right)//代表找到了大值 
		{
		a[right]=a[left];//大值放到轴值哪里 
		right--;//right往前走一个 
		}
		while(a[right]>=mid&&right>left)//从右边开始找，找出比轴值小的 
		right--;
		if(left<right)//代表找到了小值 
		{
		a[left]=a[right];//把小值放到上次找到大值得位置，因为大值那个位置空了 
		left++;//left往前走 
		}
	}
	a[left]=mid;//因为上一次right的值已经赋值到其他位置，就为空了，所以当left==right的时候，这个下标就是轴值应该待的下标 
	return left;
}
void qsort(int a[],int left,int right)
{
	if(left>=right)//当我划分的子数组只有1个或者空后，就已经是有序的了 
	return;
	int mid=(left+right)/2;//确定轴值的下标 
	swap(a,mid,right);//把轴值和数组最后一个数交换位置 
	mid=zhi(a,left,right);//对左右22 个子数组进行治，即把比轴值大的放右边，小的放左边 ，并且返回最后治好的轴职下标 
	qsort(a,left,mid-1); //这样轴值已经确定那么继续递归它的左右数组 
	qsort(a,mid+1,right);	
}
int main()
{
	printf("请输入要排序数的个数\n");
	int n;
	scanf("%d",&n);
	int i,a[n];
	for(i=0;i<n;i++)
	scanf("%d",&a[i]);
	qsort(a,0,n-1);//进行快排，因为我们要选出一个轴值，所以我们要把开始下标和结束下标传过去 
	for(i=0;i<n;i++)
	printf("%d ",a[i]);
}

7.归并排序
这个算法的思想就是对2个有序的数组进行合并，合并成一个有序的

//归并思想
//先将待排序的序列划分为2个子序列，并且2个子序列进行排序
//有序子序列合并 
//空间代价o（n），时间复杂度是固定的，O（nlogn） 
#include<stdio.h>
void merge(int a[],int b[],int left,int mid,int right)
{
	int i;
	for(i=left;i<=right;i++)
	b[i]=a[i];//先将左右子序列赋值到中间数组。因为我要输出本来的数组 
	i=left;//i赋值一个左子序列的开始下标，因为我们合并的时候，序列的位置不变 
	int index1=left,index2=mid+1;//index1为左序列的起始下标，index2为右序列的起始下标 
	while(index1<=mid&&index2<=right)//左右进行合并，index不能超过mid，index2不能超过right 
	if(b[index1]<=b[index2])//如果左子列的比右子列的小那么就直接辅助给a 
	a[i++]=b[index1++];
	else a[i++]=b[index2++];
	while(index1<=mid)//判断左子序列有无合并完 
	a[i++]=b[index1++];
	while(index2<=right)//判断右子序列有无合并完 
	a[i++]=b[index2++];
}
void mergesort(int a[],int b[],int left,int right)
{
	if(left>=right)//当子序列只有一个或者0个的时候就已经有序了 
	return;
	int mid=(left+right)/2;//获取中间的下标 
	mergesort(a,b,left,mid);//递归划分左子序列 
	mergesort(a,b,mid+1,right);//递归划分右子序列 
	merge(a,b,left,mid,right);//对左右进行合并 
}
int main()
{
	int n;
	printf("请输入要插入的数据个数\n");
	scanf("%d",&n);
	int i,a[n],b[n];
	for(i=0;i<n;i++)
	scanf("%d",&a[i]);
	mergesort(a,b,0,n-1); 
	for(i=0;i<n;i++)
	printf("%d ",a[i]);
}