排序的几种算法

/*本题系直接插入排序法====升序 

基本思想是:将整个数组(count个元素)看成是由有序的(a[0],...,a[i-1])和无序的(a[i],...,a[count-1])两个部分组成;初始是时i等于1,每趟排序时将无序部分中的第一个元素a[i]插入到有序部分中的恰当位置,共需进行count-1趟,最终使整个数组有序.*/

#include <iostream>
using namespace std;
#define N 12
int InsertSort(int a[],int count)
{
int i,j,t;
for (i=1;i<count;i++) /*控制a[i],...,a[count-1]的比较和插入*/
{ t=a[i];
j=i-1;
while (j>=0&&t<a[j]) /*在有序部分中寻找元素a[i]的插入位置*/
{
a[j+1]=a[j];
j--;
}
a[j+1]=t;
}
return 0;
}
void main()
{
int a[12]={15,2,15,4,6,45,54,121,5,42,54,646};
InsertSort(a,N);
cout<<"排序后数组的顺序为:"<<endl;
for (int i=0;i<N;i++)
cout<<a[i]<<" ";
cout<<endl;
}

/* 泡冒排序 */
/*冒泡排序的基本思想是:设数组a中存放了n 个数据元素,循环进行n-1趟
如下的排序过程:第1趟时,依次比较相邻两个数据元素a[i]和a[i+1](i=0,
1,2,...,n-2),若为逆序,即a[i]>a[i+1],则交换两个数据元素,否则不交
换,这样数值最大的数据元素将被放置在a[n-1]中.第2趟时,数据元素个数
减1,即数据元素个数为n-1,操作方法和第1趟的类似,这样整个n个数据元素
集合中次小的数据元素将被放置在a[1]中,a[0]中放置了最小的数据元素*/

#include <iostream>
using namespace std;
void BubbleSort(int a[],int n);
#define N 10
void main()
{
int i,a[]={38,45,56,78,89,98,8,7,54,65,32,21,10};

cout<<"The new Array are:";
BubbleSort(a,N);
for(i=0;i<N;i++)
cout<<a[i]<<" ";
cout<<endl;
}
void BubbleSort(int a[],int n)
{
int i,j,temp,flag=1;
for (i=1;i<n&&flag==1;i++)
{
flag=0; /*flag用于标记本次交换排序过程是否有交换动作,
若本次交换排序过程没有交换动作则说明数据元素已全部排好序*/

for(j=0;j<n-i;j++)
{
if(a[j]>a[j+1])
{
flag=1;
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}

/* 直接选择排序 */
/*直接选择排序的基本思想是:从待排序的数据元素集合中选取关键字最小
的数据元素并将它与原始数据元素集合中的第一个数据元素交换位置;然后
从不包括第一个位置上数据元素的集合中选取关键字最小的数据元素并将它
与原始数据元素集合中的第二个数据元素交换位置;如此重复,直到数据元素
集合中只剩一个数据元素为止.*/

#include <iostream>
using namespace std;
void SelectSort(int a[],int n);
#define N 10
void main()
{
int i,a[]={38,45,56,78,89,98,8,7,54,65,32,21,10};
cout<<"The new Array are:";
SelectSort(a,N);
for(i=0;i<N;i++)
cout<<a[i]<<" ";
cout<<endl;
}
void SelectSort(int a[],int n)
{
int i,j,small,temp;
for (i=0;i<n-1;i++)
{
small=i; /*设第i个数据元素关键字最小*/
for(j=i+1;j<n;j++) /*寻找关键字最小的数据元素*/
if(a[j]<a[small])/*记住最小元素的下标*/
small=j;
if(small!=i) /*当最小元素的下标不为i时交换位置*/
{
temp=a[i];
a[i]=a[small];
a[small]=temp;
}
}
}
/* 快速排序 */
/*快速排序是一种二叉树结构的交换排序方法.基本思想是：设数组成a中存放了
n个数据元素，low为数组的低端下标，high为数组的高端下标，从数组a中任取
一个元素（通常取a[low]）作为标准，调整数组a中各个元素的位置，使排在标
准元素前面的元素的关键字均小于标准元素的关键字，排在标准元素后面的元素
的关键字均大于等于标准元素的关键字.这样一次过程结束后，一方面将标准元素
为中心分成了两个子数组，位于标准元素左边子数组中标准元素的关键字均小于
标准的关键字，位于标准元素右边子数组中元素的关键字均大于等于标准元素的
关键字.对这两个子数组中的元素分别再进行方法类同的递归快速排序.递归算法
的出口条件是high>low.*/
#include <iostream>
using namespace std;
void QuickSort(int a[],int low,int high);
#define N 10
void main()
{
int i,a[10]={0,45,-56,78,89,98,8,7,4454,65};

cout<<"The new Array are:"<<endl;
QuickSort(a,0,9);
for(i=0;i<N;i++)
cout<<a[i]<<" ";
cout<<endl;
}

void QuickSort(int a[],int low ,int high)
/*用递归方法对数据元素a[low]--a[high]进行快速排序*/
{
int i=low,j=high;
int temp=a[low]; /*取第一个元素为标准数据元素*/
while (i<j)
{
while (i<j&&temp<=a[j]) /*在数组的右端扫描*/
j--;
if (i<j)
{
a[i]=a[j];
i++;
}
while (i<j&&a[i]<temp)i++; /*在数组的左端扫描*/
if (i<j)
{
a[j]=a[i];
j--;
}
}
a[i]=temp;

if (low<i)QuickSort(a,low,i-1); /*对左端子集合进行递归*/
if(i<high)QuickSort(a,j+1,high); /*对右端子集合进行递归*/
}

/*奇偶交换排序*/
/*规律：第一趟对所有的偶数下标p...（...代表未写完的题目原文），第
二趟对所有的奇数下标q...，第三趟又是对所有的偶数下标...所以它们的
起始下标变化规律为：0，1，0，1...*/
#include <iostream>
using namespace std;
#define N 8
void sort(int a[],int n);
void main()
{
int a[]={2,45,-6,8,9,41,52,63,-87};
sort(a,N);
cout<<"The new array are:"<<endl;
for (int i=0;i<N;i++)
cout<<a[i]<<" ";
cout<<endl;
}
void sort(int a[],int n)
{
int i,j,t,tag=1;
for (j=0;j<n;j++)
{
for (i=j%2;i<n-1;i+=2) /*每次仅对奇数或偶数下标处理，步长为2*/
{
if (a[i]>a[i+1])
{
t=a[i];
a[i]=a[i+1];
a[i+1]=t;
tag=0;
}
}
tag++;
if(tag==3)break; /*如果待排序列本身已经有序，则只需执行再次
内层循环即对奇偶下标元素分别扫描一次就可判断出序列已经有序*/
}
}
/*对包含10个元素的数组a采用上述方法排序时，元素间的比较次数最少应该是（9）
次，最多为（45）次。
最好的情况是当待排序记录已经有序时，只需要比较两趟（奇.偶各一趟）.当n为偶数
时，第一趟对所有偶数下标比较，比较次数为n/2,第二趟对所有奇数下标比较，比较
次数为（n/2）-1,这时总比较次数为n-1次.当n为奇数时，第一趟对所有偶数下标比较，
比较为（n-1）/2，第二趟对所有奇数下标比较，比较次数为(n-1)/2，这时总比较次数
也为n-1次.
最坏的情况是当待排序记录逆序时，共需要比较n趟（包括奇数趟和偶数趟），每趟比较
次数与上述次数相同.
*/