对九种排序算法的实现

原创 2015年11月19日 23:34:47
关键是对算法的实现,写的不是特别严谨,有错误望指出.
<pre name="code" class="cpp">#include <stdio.h>
#include <memory.h>
#include <math.h>

#define INF 99999999//无穷大 

void swap(int *a, int *b);

void Insert_sort(int *a, int count)//插入排序 
{
	int k;
	int i, j;
	for(i = 1;i < count;i++ )
	{
		k = a[i];
		j = i - 1;
		while( j >= 0 && a[j] > k )
		{
			a[j + 1] = a[j];
			j--;
		}
		a[j + 1] = k;
	}
} 

void Bubble_sort( int *a, int count )//冒泡排序 
{
	int i, j;
	for( i = 0;i < count;i++ )
		for( j = count - 1;j > i;j-- )
			if( a[j - 1] > a[j] )
			{
				if( a[ j - 1 ] != a[j] )
					swap( &a[ j - 1 ], &a[j] );
			}
			
}

void Select_sort( int *a, int count)//选择排序 
{
	int i, j;
	int min;
	for( i = 0;i < count - 1;i++ )
	{
		 min = i;
		 for( j = i + 1;j < count;j++ )
		 	if( a[min] > a[j] )
		 	{
		 		min = j;
			}
		if( a[min] != a[i] )
		 	swap( &a[min], &a[i] );
	}
}

void Recursive_mergesort( int *a, int p, int q );
void Merge( int *a, int p, int m, int q );

void Merge_sort( int *a, int count )//归并排序 
{
	Recursive_mergesort( a, 0, count - 1 );
} 

void Recursive_mergesort( int *a, int p, int q )
{
	if( p < q )
	{
		int m = ( p + q ) / 2;
		Recursive_mergesort( a, p, m );
		Recursive_mergesort( a, m + 1, q );
		Merge( a, p, m, q );
	}
}

void Merge( int *a, int p, int m, int q )
{
	int Llength = m - p + 1;
	int Rlength = q - m;
	int *L = ( int * )malloc( ( Llength + 1 ) * sizeof( int ) );
	int *R = ( int * )malloc( ( Rlength + 1 ) * sizeof( int ) );
	int i, j;
	for( i = 0;i < Llength;i++ )
	{
		L[i] = a[ p + i ];
	}
	for( j = 0;j < Rlength;j++ )
	{
		R[j] = a[ m + j + 1 ];
	}
	L[Llength] = INF;
	R[Rlength] = INF;
	i = j = 0;
	int k;
	for( k = p;k <= q;k++ )
	{
		if( L[i] > R[j] )
		{
			a[k] = R[j];
			j++;
		}
		else
		{
			a[k] = L[i];
			i++;
		}
	}
	free( L );
	free( R ); 
}

void Recursive_quicksort( int *a, int p, int q );
int Partition( int *a, int p, int q );

void Quick_sort( int *a, int count )//快速排序 
{
	Recursive_quicksort( a, 0, count - 1 );
} 

void Recursive_quicksort( int *a, int p, int q )
{
	if( p < q )
	{
		int r = Partition( a, p, q );
		Recursive_quicksort( a, p, r - 1 );
		Recursive_quicksort( a, r + 1, q );
	}
}

int Partition( int *a, int p, int q )
{
	int i = p - 1, j;
	int pivot = a[q];
	for( j = p;j < q;j++ )
	{
		if( a[j] <= pivot )
		{
			i++;
			if( a[i] != a[j] )
				swap( &a[i], &a[j] );
		}
	}
	if( a[ i + 1 ] != a[q] )
		swap( &a[ i + 1 ], &a[q] );
	return i + 1;
}

void Build_heap( int *a, int count );
void Heap_adjust( int *a, int i, int headsize );

void Heap_sort( int *a, int count )//堆排序 
{
	int headsize = count - 1, i;
	Build_heap( a, headsize );
	for( i = headsize;i >= 0;i-- )
	{
		swap( &a[0], &a[i] );
		Heap_adjust( a, 0, i -1 );
	}
}

void Build_heap( int *a, int headsize )
{
	int i;
	for( i = ( headsize / 2 );i >= 0;i-- )
	{
		Heap_adjust( a, i, headsize );
	}
}

void Heap_adjust( int *a, int i, int headsize )
{
	int lchild = 2 * i + 1;
	int rchild = 2 * i + 2;
	int max = i;
	if( lchild <= headsize && a[lchild] > a[max] )
	{
		max = lchild;
	}
	if( rchild <= headsize && a[rchild] > a[max] )
	{
		max = rchild;
	}
	if( max != i )
	{
		swap( &a[max], &a[i] );
		Heap_adjust( a, max, headsize );
	}
}

int range = 1000;//计数排序范围 

void Count_sort( int *a, int count )//计数排序 
{
	int *b = ( int * )malloc( count * sizeof( int ) );
	int *c = ( int * )malloc( ( range + 1 ) * sizeof( int ) );
	memset( b, 0, sizeof(b) * sizeof( int ) );
	memset( c, 0, sizeof(c) * sizeof( int ) );
	int i;
	for( i = 0;i < count;i++ )
		c[a[i]]++;
	for( i = 1;i < range + 1;i++ )
		c[i] += c[ i - 1 ];
	for( i = 0;i < count;i++ )
		b[--c[a[i]]] = a[i];
	for( i = 0;i < count;i++ )
		a[i] = b[i];
	free( b );
	free( c ); 
}  

int Max_radix = 1000;//设元素最大为1000; 

void Radix_count( int *a, int begin, int end, int radix );

int Get_digit( int a, int radix )//radix为基数,当从个位开始排时为1, 10, 100...到最高位,当从最高位开始时相反 
{
	return ( ( a / radix ) % 10 );
}

void Radix_sort( int *a, int count )//基数排序 
{
	int radix = Max_radix;
	Radix_count( a, 0, count - 1, radix );
}

void Radix_count( int *a, int begin, int end, int radix )
{
	int count[10] = {0};
	int i, j;
	int *bucket = ( int * ) malloc( ( end - begin + 1 ) * sizeof( int ) );
	for( i = begin;i <= end;i++ )
	{
		count[ Get_digit( a[i], radix ) ]++;
	}
	for( i = 1;i < 10;i++ )
	{
		count[i] += count[ i - 1 ];
	}
	for( i = begin;i <= end;i++ )
	{
		j = Get_digit( a[i], radix );
		bucket[ count[j] - 1 ] = a[i]; 
		--count[j];
	}
	for( i = begin, j = 0;i <= end;i++, j++ )
		a[i] = bucket[j];
	free( bucket );
	int p, q;
	for( i = 0;i < 10;i++ )
	{
		if( i == 0 )
		{
			p = begin;
			q = begin + count[i] - 1;
		}
		else
		{
			p = begin + count[ i - 1 ];
			q = begin + count[i] - 1;
		}
		if( p < q && radix / 10 > 0 )
			Radix_count( a, p, q, radix / 10 );
	}
}

double Min_radix = 0.00001;//设桶排序最小为0.0001 
int MAX_LENGTH;
void Bucket_count( float *a, int begin, int end, int radix );

int Get_MAX_LENGTH( double a )
{
	int i = 0;
	while( a < 1 )
	{
		a *= 10;
		i++;
	}
	return i;
}

int Get_decimal( float a, int radix )//radix为基数,当从个位开始排时为1, 10, 100...到最高位,当从最高位开始时相反 
{
	int i = 10;
	while( a < 1 && i <= radix)
	{
		a *= 10;
		i *= 10;
	}
	return a;
}

void Bucket_sort( float *a, int count )//桶排序 
{
	int radix = 10;
	Bucket_count( a, 0, count - 1, radix );
}

void Bucket_count( float *a, int begin, int end, int radix )
{
	int count[10] = {0};
	int i, j;
	float *bucket = ( float * )malloc( ( end - begin + 1 ) * sizeof( float ) );
	for( i = begin;i <= end;i++ )
	{
		count[ Get_decimal( a[i], radix ) ]++;
	}
	for( i = 1;i < 10;i++ )
	{
		count[i] += count[ i - 1 ];
	}
	for( i = begin;i <= end;i++ )
	{
		j = Get_decimal( a[i], radix );
		bucket[ count[j] - 1 ] = a[i];
		count[j]--;
	}
	for( i = begin,j = 0;i <= end;i++, j++ )
		a[i] = bucket[j];
	free( bucket );
	int p, q;
	for( i = 0;i < 10;i++ )
	{
		if( i == 0 )
		{
			p = begin;
			q = begin + count[i] - 1;
		}
		else
		{
			p = begin + count[ i - 1 ];
			q = begin + count[i] - 1;
		}
		if( p < q && radix <= pow ( 10, Get_MAX_LENGTH( Min_radix ) ) )
			Bucket_count( a, p, q, radix * 10 );
	}
}

void swap(int *a, int *b)
{
		*a = *a + *b;
		*b = *a - *b;
		*a = *a - *b;
}

void Print_array(int *a, int count)
{
	int i;
	for( i = 0;i < count;i++ )
	{
		printf( "%d ", a[i] );
	}
	printf( "\n" );
}

void Print_float_array(float *a, int count)
{
	int i;
	for( i = 0;i < count;i++ )
	{
		printf( "%g ", a[i] );
	}
	printf( "\n" );
}

int main(int argc, char** argv) {
	int a[] = {5, 8, 1, 3, 9, 0, 2, 19, 76, 43, 54, 78, 3, 5, 82, 13};
	float b[] = {0.05, 0.08, 0.01, 0.03, 0.09, 0, 0.02, 0.19, 0.76, 0.43, 0.54, 0.78, 0.03, 0.05, 0.82, 0.13};
	int sum = sizeof(a) / sizeof(int);
	int float_sum = sizeof(b) / sizeof(float);
	int i = 0;
	printf( "请输入排序方式:\n1.插入排序 2.冒泡排序 3.选择排序 4.归并排序 5.快速排序\n6.堆排序 7.计数排序 8.基数排序 9.桶排序\n" );
	scanf( "%d", &i );
	switch(i) 
	{
		case 1:
			printf( "原始数据:\n" ); Print_array( a, sum ); printf( "排序后数据:\n" );
			Insert_sort( a, sum); Print_array( a, sum ); break;
		case 2:
			printf( "原始数据:\n" ); Print_array( a, sum ); printf( "排序后数据:\n" );
			Bubble_sort( a, sum); Print_array( a, sum ); break;
		case 3:
			printf( "原始数据:\n" ); Print_array( a, sum ); printf( "排序后数据:\n" );
			Select_sort( a, sum); Print_array( a, sum ); break;
		case 4:
			printf( "原始数据:\n" ); Print_array( a, sum ); printf( "排序后数据:\n" );
			Merge_sort( a, sum); Print_array( a, sum ); break;
		case 5:
			printf( "原始数据:\n" ); Print_array( a, sum ); printf( "排序后数据:\n" );
			Quick_sort( a, sum); Print_array( a, sum ); break;
		case 6:
			printf( "原始数据:\n" ); Print_array( a, sum ); printf( "排序后数据:\n" );
			Heap_sort( a, sum); Print_array( a, sum ); break;
		case 7:
			printf( "原始数据:\n" ); Print_array( a, sum ); printf( "排序后数据:\n" );
			Count_sort( a, sum); Print_array( a, sum ); break;
		case 8:
			printf( "原始数据:\n" ); Print_array( a, sum ); printf( "排序后数据:\n" );
			Radix_sort( a, sum); Print_array( a, sum ); break;
		case 9:
			printf( "原始数据:\n" ); Print_float_array( b, float_sum ); printf( "排序后数据:\n" );
			Bucket_sort( b, float_sum ); Print_float_array( b, float_sum ); break;
		default:
			{
				printf( "输入错误" );
				exit(0);
			}
	}
	return 0;
}



                

九种经典排序算法汇总

/*********************************************************** 总结各种排序算法包括但不限于: 1. 插入排序类 1.1 直接插入排序 1.2...
  • zy122121cs
  • zy122121cs
  • 2016年06月28日 21:03
  • 3894

九种基本排序算法总结

排序分类: 1、插入排序:直接插入排序,二分法插入排序,希尔排序; 2、选择排序:简单选择排序,堆排序; 3、交换排序:冒泡排序,快速排序; 4、归并排序; 5、基数排序; (1)直接插入排序:(稳...
  • zlele0326
  • zlele0326
  • 2016年04月29日 14:23
  • 1821

【算法】九种常见排序

本节给出直接插入、希尔、冒泡、快速、选择、堆排序、归并、计数、基数排序以及排序测试代码的C++实现;...
  • skyuppour
  • skyuppour
  • 2015年03月22日 20:10
  • 1389

八种常用内部排序算法总结

在公司实习了,由于公司的性质,以后的工作中用到算法&数据结构的知识可能会很少,很想把以前学的数据结构&算法的知识系统的回忆一下,但由于时间的原因,再加上我一直都很喜欢排序算法的思想。近期主要就排序这个...
  • Thinker_YU
  • Thinker_YU
  • 2014年10月18日 22:31
  • 3759

算法导论-----排序的9种实现(C/C++)

目录 A、冒泡排序 B、选择排序 C、插入排序 D、折半插入排序 E、归并排序 F、快速排序 G、希尔排序 堆排序、基数排序、桶排序后续补充。。。。。A、冒泡排序冒泡排序有很多种实现方式。下面总结常见...
  • so_geili
  • so_geili
  • 2016年11月23日 23:30
  • 1201

九种经典排序算法详解(冒泡排序,插入排序,选择排序,快速排序,归并排序,堆排序,计数排序,桶排序,基数排序)

综述 最近复习了各种排序算法,记录了一下学习总结和心得,希望对大家能有所帮助。本文介绍了冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序、计数排序、桶排序、基数排序9种经典的排序算法。针对每...
  • damontive
  • damontive
  • 2018年01月26日 01:08
  • 67

希尔排序算法实现(C++)

希尔排序是一种按照增量排序的方法。其中增量值是小于n的正整数。   shell排序的基本思想[1]是:     先取一个小于n的整数d1作为第一个增量,把文件的全部记录分成d1个组。所有距离为dl...
  • xiaofei0859
  • xiaofei0859
  • 2014年04月15日 17:10
  • 1431

九种排序算法

from http://blog.csdn.net/xiazdong排序的定义: 输入:n个数:a1,a2,a3,…,an 输出:n个数的排列:a1’,a2’,a3’,…,an’,使得a1’...
  • u010235472
  • u010235472
  • 2016年04月14日 11:37
  • 363

【排序算法】九种排序算法的总结

1.排序算法的分类 插入排序:直接插入排序、二分法插入排序、希尔排序。 交换排序:冒泡排序、快速排序。 选择排序:简单选择排序、堆排序。 归并排序 基数排序 2.插入排序 基本思想:依次遍历元素,在已...
  • baiye_xing
  • baiye_xing
  • 2017年07月14日 11:28
  • 94

【算法分析与设计】各种排序算法的效率对比

排序在编程的过程中是非常重要的一类算法。一个好的排序算法可以让我们整体的算法效率提高很多,但是不同的排序算法实现起来的难度也有比较大的差别。那么现在具体来看一下各个排序算法的主要思想。   1、直接...
  • qq_32353771
  • qq_32353771
  • 2017年01月17日 19:56
  • 1166
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:对九种排序算法的实现
举报原因:
原因补充:

(最多只允许输入30个字)