排序算法

闲来无事实现了快排、合并排序、奇偶冒泡排序：

/*********************************************************************
 * Name: Sort
 *Author:zhangjie
 */
#include<iostream>
#include<stdlib.h>
#include<time.h>
using namespace std;
typedef struct 
{
	int data;
    float x;
    float y;
}FeatureRec,*Feature;

typedef struct 
{
	/* data */
	Feature *feature;
	int length;
}list,*List;
/*********************************************************************
 * Merge Sort
 */
void _merge_element(List Ldata,int left,int right,int mid,int* temp)
{
   int i = left, j = mid + 1;  
    int m = mid,   n = right;  
    int k = left;  
      
    while (i<= m && j<= n)  
    {  
        if (Ldata->feature[i]->data > Ldata->feature[j]->data)
		{
            temp[3*k] = Ldata->feature[i]->data;
		    temp[3*k+1] = Ldata->feature[i]->x; 
			temp[3*k+2] = Ldata->feature[i]->y;
			k=k+1;
			i=i+1;
		}
        else 
		{
            temp[3*k] = Ldata->feature[j]->data;
			temp[3*k+1] = Ldata->feature[j]->x; 
			temp[3*k+2] = Ldata->feature[j]->y;
			k=k+1;
			j=j+1;
		}
    }  
      
    if(i<= m) 
	{
		for(int s=i;s<=m;s++)
		{
        temp[3*k] = Ldata->feature[s]->data;
		temp[3*k+1] = Ldata->feature[s]->x; 
	    temp[3*k+2] = Ldata->feature[s]->y;
		k=k+1;
		}
	}
      
    if(j<= n) 
	{
		for(int t=j;t<=n;t++)
		{
        temp[3*k] = Ldata->feature[t]->data;
		temp[3*k+1] = Ldata->feature[t]->x; 
		temp[3*k+2] = Ldata->feature[t]->y;
		k=k+1;
		}
	}
      
    for (int p = left; p <= right; p++)
	{
        Ldata->feature[p]->data = temp[p*3];
		Ldata->feature[p]->x = temp[p*3+1]; 
		Ldata->feature[p]->y = temp[p*3+2]; 
	}
}
void _merge_sort_cpu(List Ldata,int left,int right,int* temp_data)
{
	if(left<right)
	{
		int mid=(left+right)/2;
		_merge_sort_cpu(Ldata,left,mid,temp_data);
		_merge_sort_cpu(Ldata,mid+1,right,temp_data);
		_merge_element(Ldata,left,right,mid,temp_data);
	}
}
/*********************************************************************
 * quick Sort
 */
void swap(Feature &a,Feature &b)
{
	Feature temp;
	temp=a;
	a=b;
	b=temp;

}
int partition(List Ldata,int left,int right)
{
	int base_element=Ldata->feature[left]->data;
	int i=left;
	int j=right+1;
	for(;;)
	{
		while(Ldata->feature[++i]->data>base_element&&(i+1 <Ldata->length));
		while(Ldata->feature[--j]->data<base_element&&(j-1>-1));
		if(i<j) swap(Ldata->feature[i],Ldata->feature[j]);
	    else break;
	}
	swap(Ldata->feature[left],Ldata->feature[j]);
	return  j;
}
void _quick_sort_cpu(List data,int left,int right)
{
	
	if(left<right)
	{
		int pivot=partition(data,left,right);
		_quick_sort_cpu(data,left,pivot-1);
		_quick_sort_cpu(data,pivot+1,right);
	}
}

/*********************************************************************
 * oddeven Sort
 */
void _oddeven_sort_cpu(List Ldata,int left,int right)
{
	for(int m=0;m<Ldata->length;m++)
	{
	 /*int odd=Ldata->length/2;
	 int even=Ldata->length/2;
	 int swap_count_odd=0;
	 int swap_count_even=0;*/
	for(int i=left;i+1<=right;i+=2)
	{
		if(Ldata->feature[i]->data<Ldata->feature[i+1]->data)
		{
			swap(Ldata->feature[i],Ldata->feature[i+1]);
			/*swap_count_odd++;*/
		}
	}
	for(int j=1;j+1<=right;j+=2)
	{
		if(Ldata->feature[j]->data<Ldata->feature[j+1]->data)
		{
			swap(Ldata->feature[j],Ldata->feature[j+1]);
			/*swap_count_even++;*/
		}
	}
	/*if((swap_count_odd+swap_count_even)==(even+odd))
	{
		break;
	}*/
	}
}
/*********************************************************************
 * main function
 */
int main(int argc,char* argv[])
{
	List list_data;
	int* temp_data;
	int nLength=2019924;
	int nBytes=sizeof(list)+nLength*sizeof(Feature)+nLength*sizeof(FeatureRec);
	temp_data=(int*)malloc(3*nLength*sizeof(int));
	list_data=(List)malloc(nBytes);
	//Input feature data
	list_data->length=nLength;
	list_data->feature=(Feature*)(list_data+1);
	Feature first;
	first=(Feature)(list_data->feature+nLength);
	for(int i=0;i<nLength;i++)
	{
		list_data->feature[i]=first+i;
	}
	cout<<"Please enter "<<nLength<<" feature data with form like x,y,val"<<endl;
	FILE* fp;
	fp=fopen("points.txt","r");
	for(int i=0;i<list_data->length;i++)
	 fscanf(fp,"%f,%f,%d",&list_data->feature[i]->x,&list_data->feature[i]->y,&list_data->feature[i]->data);
	fclose(fp);
	int choose;
	cout<<"Input your choose"<<endl;
	cin>>choose;
	cout<<endl;
	clock_t start,end;
	start=clock();
	switch(choose)
	{
	case 1:
	_quick_sort_cpu(list_data,0,list_data->length-1); 
	break;
	case 2:
	_merge_sort_cpu(list_data,0,list_data->length-1,temp_data);
	break;
	case 3:
	_oddeven_sort_cpu(list_data,0,list_data->length-1); 
	break;
	default: printf("Please input 1 or 2 for sort\n");
	}
	end=clock();
	double elps;
	elps=(double)(end-start)/CLOCKS_PER_SEC;
	printf("Sort time is:%fms\n",elps*1000);
	/*_quick_sort_cpu(list_data,0,list_data->length-1);*/
	cout<<"After sort"<<endl;
	FILE* fp1;
	fp1=fopen("points_result.txt","w");
	for(int i=0;i<list_data->length;i++)
	fprintf(fp1,"%f,%f,%d\n",list_data->feature[i]->x,list_data->feature[i]->y,list_data->feature[i]->data);
	fclose(fp1);
	cout<<"Finish to display"<<endl;
	system("pause");
	if(temp_data)free(temp_data);
	if(list_data) free(list_data);
	return(0);
}