多种排序算法求中位数

最新推荐文章于 2023-01-17 18:56:54 发布
_4444yl
最新推荐文章于 2023-01-17 18:56:54 发布
阅读量1.6k
点赞数 1
分类专栏：算法编程
本文链接：https://blog.csdn.net/yangliu_w/article/details/73140675
版权
算法编程专栏收录该内容
31 篇文章 4 订阅
订阅专栏
给一列无序数组，求出中位数并给出算法的时间复杂度。

/*
File name:求中位数.cpp
Author:杨柳
Date:2017/5/25
IDE:DEV-c++ 
思想：把无序数组排好序，取出中间的元素
*/

#include<stdio.h>
#include<iostream>
using namespace std;
#define MAX 100
int array[MAX],arr[MAX];
int result=0;//保存中位数 

//简单选择排序 
int selectsort(int array[],int n){
	int temp,j,k;	//设置临时变量 
	for(int i=0;i<n;i++){  //n-1趟 
		j=i;	//记录最小元素的位置 
		for(k=i+1;k<n;k++){
			if(array[j]>array[k])
				j=k;
				temp=array[i];
				array[i]=array[j];
				array[j]=temp;
		}
	}
	if(n%2==0){		//	若数组有奇数个元素，中位数是array[(n-1)/2]
		result=((array[n/2-1]+array[n/2])/2);
		return result;
	}
	else{			//若数组有偶数个元素，中位数为array[n/2-1]和array[n/2]两个数的平均值
		result=array[(n-1)/2];
		return result;
	}
}

//直接插入排序
int insertsort(int array[],int n){
	for(int i=1;i<n;i++){
			int temp;//设置临时变量存放待插入的记录
		 	temp=array[i];		
		 	for(int k=i-1;k>=0&&temp<array[k];k--){	//待插入一次与前面数据一次 
		 		array[k+1]=array[k]; 
				 array[k+1]=temp;
			 } 
		 	
	}
	if(n%2==0){		//	若数组有奇数个元素，中位数是array[(n-1)/2]
		result=((array[n/2-1]+array[n/2])/2);
		return result;
	}
	else{			//若数组有偶数个元素，中位数为array[n/2-1]和array[n/2]两个数的平均值
		result=array[(n-1)/2];
		return result;
	}
} 
//希尔排序求中位数
int  shellsort(int array[],int arr[],int n,int m) {
	int h,k,j,v;
	for(int i=0;i<m;i++){
		h=arr[i];//选取增量
		for(k=h;k<n;k++){
			j=array[k];
			for(v=k-h;v>=0&&j<array[v];v=v-h){
				array[v+h]=array[v];
				array[v+h]=j;
			}
		} 
	}


	if(n%2==0){		//	若数组有奇数个元素，中位数是array[(n-1)/2]
		result=((array[n/2-1]+array[n/2])/2);
		return result;
	}
	else{			//若数组有偶数个元素，中位数为array[n/2-1]和array[n/2]两个数的平均值
		result=array[(n-1)/2];
		return result;
	}
}

//冒泡排序求中位数
int bubblesort(int array[],int n){
	int temp,change=true;  //设置标志以便进入循环 
	for(int i=1;i<n&&change;i++){   //n-1趟 
		change=false;//第i趟设置交换标志false，这时没有交换记录，已经有序，结束 
		for(int j=0;j<n-i;j++){
			if(array[j]>array[j+1]){  //若逆序交换 
				temp=array[j];
				array[j]=array[j+1];
				array[j+1]=temp;
				change=true;
			}
		}
		
	}
	
	if(n%2==0){		//	若数组有奇数个元素，中位数是array[(n-1)/2]
		result=((array[n/2-1]+array[n/2])/2);
		return result;
	}
	else{			//若数组有偶数个元素，中位数为array[n/2-1]和array[n/2]两个数的平均值
		result=array[(n-1)/2];
		return result;
	}
} 

//快速排序求中位数
int  quicksort(int array[],int min,int max){
	int high,low;
	if(min<max){
		low=min;
		high=max;
		int temp=array[low];  
		while(low!=high){
			while(low<high&&array[high]>temp){ //从右向左 
				high--;
			}
			if(low<high)
				array[low++]=array[high];  //比 array[low]小，交换 
			while(low<high&&array[low]<=temp){ //从左向右 
				low++;
			}
			if(low<high){
				array[high--]=array[low];  //交换 
			}
			}
	array[low]=temp;		
	quicksort(array,min,low-1);
	quicksort(array,high+1,max);
		}
	if((max+1)%2==0){		//	若数组有奇数个元素，中位数是array[(n-1)/2]
		result=((array[(max+1)/2-1]+array[(max+1)/2])/2);
		return result;
	}
	else{			//若数组有偶数个元素，中位数为array[n/2-1]和array[n/2]两个数的平均值
		result=array[(max)/2];
		return result;
	}	
		
}

//调整为堆
void shift(int array[],int s,int n){
	int q,t;
	t=array[s];
	while((q=2*s+1)<n){ //有左孩子 
		if(q<n-1&&array[q]<array[q+1])
			q++;
		if(t<array[q]){
			array[(q-1)/2]=array[q];
			s=q;
		} 
		else
			break;
	}
	array[(q-1)/2]=t;  //t放在最后一个位置 
} 

//堆排序求中位数
int heapsort(int array[],int n){
	int s,t;
	s=(n-1)/2;
	while(s>=0){
		shift(array,s,n);
		s--;
	}
	s=n-1;
	while(s>0){  //交换结点 
		t=array[0];
		array[0]=array[s];
		array[s]=t;
		shift(array,0,s);
		s--;
	}
	if(n%2==0){		//	若数组有奇数个元素，中位数是array[(n-1)/2]
		result=((array[n/2-1]+array[n/2])/2);
		return result;
	}
	else{			//若数组有偶数个元素，中位数为array[n/2-1]和array[n/2]两个数的平均值
		result=array[(n-1)/2];
		return result;
	}
} 

//合并两个有序序列 
void merge(int array[],int p,int q,int r){
	int n1,n2;
	n1=q-p+1;
	n2=r-q+1; 
	int arr1[n1+1],arr2[n2];
    for(int i=0;i!=n1;++i){
    	arr1[i]=array[i+p];
    
	}
		arr1[n1]=2000000;
	for(int j=0;j!=n2-1;++j){
		arr2[j]=array[q+j+1];
	}
		arr2[n2-1]=200000;
		int i=0,j=0;
	for( int k=p;k!=r+1;++k){
		if(arr1[i]>arr2[j]){
			array[k]=arr2[j];
		    ++j;
		}
		else{
			array[k]=arr1[i];
			++i;
		}
	}
}
//归并排序求中位数
void mergesort(int array[],int p,int r){
	if(p<r){
		int q=(p+r)/2;
		mergesort(array,p,q);
		mergesort(array,q+1,r);
		merge(array,p,q,r);
	}
			
} 
 
int midiumnumber(int array[],int n){
		cout<<endl<<endl<<"1----------简单选择排序求中位数(O(n^2))"<<endl;
		cout<<"2----------直接插入排序求中位数(O(n^2))---------"<<endl;
		cout<<"3----------希尔排序求中位数(O(nlog2^n))---------"<<endl;
		cout<<"4----------冒泡排序求中位数(O(n^2))-------------"<<endl;
		cout<<"5----------快速排序求中位数(O(nlog2^n))---------"<<endl;
		cout<<"6----------堆排序求中位数(O(nlog2^n))-----------"<<endl;
		cout<<"7----------归并求中位数(O(nlog2^n))-----------"<<endl;
		cout<<"请选择1-7："<<endl; 
		int select;
		cin>>select;
		switch(select){
			case 7:
				cout<<"这列无序数组的中位数为："<<endl;
			    mergesort(array,0,n-1);
			    	if(n%2==0){		//	若数组有奇数个元素，中位数是array[(n-1)/2]
						result=((array[n/2-1]+array[n/2])/2);
						return result;
					}
					else{			//若数组有偶数个元素，中位数为array[n/2-1]和array[n/2]两个数的平均值
						result=array[(n-1)/2];
						return result;
					}
				break;
			case 6:
				cout<<"这列无序数组的中位数为："<<endl;
				return heapsort(array,n);
				break;	
			case 5:
				cout<<"这列无序数组的中位数为："<<endl;
				return quicksort(array,0,n-1);
				break;	
			case 4:
				cout<<"这列无序数组的中位数为："<<endl;
				return bubblesort(array,n);
				break;
			case 1:
				cout<<"这列无序数组的中位数为："<<endl;
				return selectsort(array,n);
				break;	
			case 2:
				cout<<"这列无序数组的中位数为："<<endl;
				return insertsort(array,n);
				break;
			case 3:
				//初始化一个增量数组 
				int n1=n;
				int m=0;
				while(n1>1){
					arr[m++]=n1/2;
					n1=n1/2;
				}
				cout<<"这列无序数组的中位数为："<<endl;
				return 	shellsort(array,arr,n,m);
				break;			

			}
}

int main(){

	int n,i;
	cout<<"输入一列无序数组数的个数："<<endl;
	cin>>n;
	cout<<"请输入一列无序数组："<<endl;
	for(i=0;i<n;i++){
		cin>>array[i];
	}

   int flag=1;
   while(flag==1){
	cout<<midiumnumber(array,n)<<endl;
}
//	cout<<selectsort(array,n);
   
	return 0;
}