#include<stdio.h>
#include<malloc.h>
#define SIZE 10
void printArray(int A[SIZE]);
void PopSort( int A[SIZE]);
void InsertSort( int A[SIZE] );
void ChooseSort( int A[SIZE] );
void ShellSort( int A[SIZE] );
void ShellSortPro(int A[SIZE],int add);
void Insertsort3(int A[], int n);
void MergeSort(int A[SIZE],int b,int e);
void Merge(int A[SIZE], int b,int m,int e);
void QuickSort(int A[SIZE],int left,int right);
void main()
{
int A[10] = {0,1,6,3,9,5,6,7,8,4};
int i = 1,j=1;
ChooseSort(A);
PopSort(A);
InsertSort(A);
ShellSort(A);
MergeSort(A,0,9);
printArray(A);
}
/************************************************************打印数组信息****************************************************/
void printArray(int A[SIZE])
{
int counter;//计数器
for( counter = 0; counter < SIZE ; counter++ )
{
printf("%d ",A[counter]);
}
printf("\n");
}
/****************************************冒泡排序算法*******************************************/
void PopSort( int A[SIZE])
{
int ControlTimes=0;//控制外层循环次数
int Current=0;//当前数字序号
int flag = 0; //当一次没有任何交换也可让循环停止
for(ControlTimes = 0; ControlTimes < SIZE-1; ControlTimes++)
{
for(Current = 0; Current < SIZE- ControlTimes -1;Current++)
{
if(A[Current]>A[Current+1])
{
A[Current]^=A[Current+1];
A[Current+1]^=A[Current];
A[Current]^=A[Current+1];
flag += 1;
}
}
if(flag==0)
break;
else
flag = 0;
}
}
/*******************************************************插入排序算法***************************************************/
//插入排序思想:第2到n个元素分别作为key值,每个值作为key值之前,它前面的元素是有序的,只需要将key值插入到合适位置
void InsertSort( int A[SIZE] )
{
int count = 0;//当前已经循环到的关键字序号
int key = 0;//存当前关键字
int compare = 0;//之前元素的迭代比较
for( count = 1; count < SIZE ; count ++ )
{
key = A[count];
compare = count-1;
while(compare>=0)
{
if(key < compare)
{
A[compare]^=A[compare+1];
A[compare+1]^=A[compare];
A[compare]^=A[compare+1];
compare--;
}else
break;
}
A[compare+1] = key;
}
}
/******************************************************选择排序算法(不稳定)******************************************************/
//选择排序思想:每次选出最小元素按顺序与当前未排序的第一个元素交换。
void ChooseSort( int A[SIZE] )
{
int min = 0; //最小值的序号
int sorted = 0;//控制循环
int iterator = 0;//遍历当前位之后的元素
for( sorted = 0; sorted < SIZE-1 ; sorted++ )
{
min = sorted ;
iterator = sorted;
while(iterator < SIZE )
{
if(A[min]>A[iterator])
{
min = iterator;
}
iterator++;
}
if(min != sorted )
{
A[min] = A[min] + A[sorted];
A[sorted] = A[min] - A[sorted];
A[min] = A[min] - A[sorted];
}
}
}
/**********************************************希尔排序算法********************************************************************/
//算法思想:据逆序数原理(排序后的逆序数为0),希尔排序是简单插入排序的变形,设有增量,每一组的相应位置进行插入排序
// 希尔排序的增量:增量大小可自定,但最后增量必须减小为1.两个比较好的建议:增量减少为原来2/3较好,增量不为倍数.d=d/3+1;
void ShellSort( int A[SIZE] )
{
int dataAdd[] = {4,2,1};
int i = 0;
for( i = 0; i < 3; i++ )
ShellSortPro(A,dataAdd[i]);
}
void ShellSortPro(int A[SIZE],int add)
{
int key = 0;//关键字
int iterator;//遍历后面元素
int count = 0; //控制循环
int innerCount = 0;//内部处理排序
for(count=0;count < add; count++)
{
for(innerCount = count ; innerCount < SIZE;innerCount+=add )
{
key = A[innerCount];
iterator = innerCount - add;
while(iterator>=0)
{
if(key < A[iterator])
{
A[iterator] = A[iterator] + A[iterator+add];
A[iterator+add] = A[iterator] - A[iterator+add];
A[iterator] = A[iterator] - A[iterator+add];
iterator -= add;
}else
break;
}
A[iterator+add] = key;
}
}
}
/**************************************归并排序算法****************************************************************************/
归并排序思想:将序列分为两份,每份同样递归下去,之后对每份排好序的数进行合并
void MergeSort(int A[10], int p,int r)
{
int q=(p+r)/2;
if(p<r)
{
MergeSort(A,p,q);
MergeSort(A,q+1,r);
}
Merge(A,p,q,r);
}
void Merge(int A[10],int p,int q, int r)
{
int i= 0;
int count = p;
int count1 = 0;
int count2 = 0;
int Size1 = q-p+1;
int Size2 = r - q ;
int B[50];
int C[50];
for(i=0; i < Size1; i++)
{
B[i] = A[i+p];
}
for( i = 0; i < Size2;i++)
{
C[i] = A[i+q+1];
}
while(count1 < Size1 && count2<Size2)
{
if(B[count1]<C[count2])
{
A[count] = B[count1];
count++;
count1++;
}
else
{
A[count] = C[count2];
count++;
count2++;
}
}
while(count1 < Size1)
{
A[count] = B[count1];
count++;
count1++;
}
while(count2 < Size2)
{
A[count] = C[count2];
count++;
count2++;
}
}
/****************************************************************快速排序******************************************************/
void quickSort(int Data[10],int left,int right)
{
int Temp = Data[(left + right)>>1];
int preLeft = left;
int preRight = right;
while(left < right)
{ while(Data[left] < Temp)
{
left++;
}
while(Data[right] > Temp)
{
right--;
}
int temp = Data[left];
Data[left] = Data[right];
Data[right] = temp;
left++;
right--;
}
if(preLeft < right) quickSort(Data,preLeft,right);
if(preRight>left) quickSort(Data,left,preRight);
}