标签：cts global 函数 交换 def \n 有序 perror int end
排序算法有很多种，并在实际编程过程中用的非常广泛。常用的排序算法有：插入排序算法，选择排序算法，冒泡排序算法，快速排序算法，归并排序算法，希尔排序算法，堆排序算法。
各种排序算法的时间复杂度：
1.冒泡法： O(n*n)
2.直接插入排序：O(n*n)
3.选择排序：O(n*n)
4.快速排序：平均时间复杂度log2(n)*n，所有内部排序方法中最高好的
5.归并排序：log2(n)*n
6.堆排序：log2(n)*n
7.希尔排序：算法的复杂度为n的1.2次幂头文件：
/*****************************************************************************************************
*Copyright:Yue Workstation
*
*FileName:Sort.h
*
*Function:排序相关数据定义和函数声明
*
*Author:Abel Lee
*
*CreateOn:2012-2-9
*
*Log:2012-2-9 由Abel Lee创建
*****************************************************************************************************/
#ifndef SORT_H
#define SORT_H
#include "global.h"
#include <time.h>
#define MAXSIZE 20
typedef int InfoType;
#define EQ(a,b) ((a) == (b))
#define LT(a,b) ((a) < (b))
#define LQ(a,b) ((a) <= (b))
#ifdef STRING
#define EQ(a,b) (!strcmp(a,b))
#define LT(a,b) (strcmp(a,b) < 0)
#define LQ(a,b) (strcmp(a,b) <= 0)
#endif
typedef struct
{
ElemType key;
InfoType otherinfo;
}ReadType;
typedef struct
{
ReadType r[MAXSIZE+1];
int length;
}SortList;
typedef SortList HeapType;//堆采用顺序表存储表示
#define MAX_NUM_OF_KEY 8 //关键字项数最大值
void InitSortList(SortList *L);
void PrintSortList(SortList L);
int InsertSort(SortList *L);
int BubblingSort(SortList *L);
int SelectSort(SortList *L);
int QuickSort(SortList *L, int low, int high);
void MergeSort(int a[], int size);
int ShellSort(SortList *L, int dlta[], int t);
int HeapSort(HeapType *L);
#endif源文件：
/*****************************************************************************************************
*Copyright:Yue Workstation
*
*FileName:Queue.c
*
*Function:排序基本算法
*
*Author:Abel Lee
*
*CreateOn:2012-2-9
*
*Log:2011-2-9 由Abel Lee创建
*****************************************************************************************************/
#include "../inc/Sort.h"
/****************************************************************************************************
*Function Name: InsertSort
*
*Function:初始化排序队列
*
*Parameter: L:排序队列
*
*Return Value:无
*
*Author:Abel Lee
*
*Log:2011-2-10
***************************************************************************************************/
void InitSortList(SortList *L)
{
int i = 0;
srand((unsigned)time(NULL));
for(i = 1;i <= MAXSIZE; i++)
{
L->r[i].key = rand()%100;
}
L->length = 20;
return;
}
/****************************************************************************************************
*Function Name: PrintSortList
*
*Function:打印排序队列
*
*Parameter: L:排序队列
*
*Return Value:无
*
*Author:Abel Lee
*
*Log:2011-2-10
***************************************************************************************************/
void PrintSortList(SortList L)
{
int i = 0;
for(i = 1;i <= MAXSIZE; i++)
{
printf("%d--",L.r[i].key);
}
putchar(‘\n‘);
return;
}
/****************************************************************************************************
*Function Name: InsertSort
*
*Function: 插入排序算法（插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。）
*
*Parameter: L:排序数据指针
*
*Return Value:成功返回0，失败返回-1
*
*Author:Abel Lee
*
*Log:2011-2-10
***************************************************************************************************/
int InsertSort(SortList *L)
{
int i = 0;
int j = 0;
if(L == NULL)
{
perror("L is NULL!\n");
return -1;
}
for(i = 2; i<=L->length; i++)
{
if(LT(L->r[i].key, L->r[i-1].key))
{
L->r[0] = L->r[i];
L->r[i] = L->r[i-1];
for(j=i-2; LT(L->r[0].key, L->r[j].key); j--)
{
L->r[j+1] = L->r[j];
}
L->r[j+1] = L->r[0];
}
}
return 0;
}
/****************************************************************************************************
*Function Name: BubblingSort
*
*Function: 选择排序算法
*
*Parameter: L:排序数据指针
*
*Return Value:成功返回0，失败返回-1
*
*Author:Abel Lee
*
*Log:2011-2-21
***************************************************************************************************/
int SelectSort(SortList *L)
{
int i = 0;
int j = 0;
ReadType temp;
if(L == NULL)
{
return -1;
}
for(i = 1; i <= L->length; i++)
{
for(j = i+1; j <= L->length; j++)
{
if(L->r[i].key > L->r[j].key)
{
temp = L->r[i];
L->r[i] = L->r[j];
L->r[j] = temp;
}
}
}
return 0;
}
/****************************************************************************************************
*Function Name: BubblingSort
*
*Function: 冒泡排序算法
*
*Parameter: L:排序数据指针
*
*Return Value:成功返回0，失败返回-1
*
*Author:Abel Lee
*
*Log:2011-2-21
***************************************************************************************************/
int BubblingSort(SortList *L)
{
int i = 0;
int j = 0;
ReadType temp;
if (L == NULL)
{
return -1;
}
for (i = 1; i <= L->length; i++)
{
for (j = 1; j < L->length; j++)
{
if (L->r[j].key > L->r[j+1].key)
{
temp = L->r[j];
L->r[j] = L->r[j+1];
L->r[j+1] = temp;
}
}
}
return 0;
}
/****************************************************************************************************
*Function Name: QuickSort
*
*Function: 快速排序算法
*
*Parameter: L:排序数据指针
*
*Return Value:成功返回0，失败返回-1
*
*Author:Abel Lee
*
*Log:2011-2-21
***************************************************************************************************/
static int Partition(SortList *L, int low, int high)
{
int flag = 0;
L->r[0] = L->r[low];
flag = L->r[low].key;
while(low < high)
{
while(low < high && L->r[high].key >= flag)
high--;
if(low < high)
L->r[low] = L->r[high];
while(low < high && L->r[low].key <= flag)
low++;
if(low < high)
L->r[high] = L->r[low];
}
L->r[low] = L->r[0];
return low;
}
int QuickSort(SortList *L, int low, int high)
{
int flag = 0;
if(low < high)
{
flag = Partition(L,low,high);
QuickSort(L,low,flag-1);
QuickSort(L,flag+1,high);
}
return 0;
}
/****************************************************************************************************
*Function Name: MergeSort
*
*Function: 归并排序算法
*
*Parameter: a:要排序的数组
* size:要排序的数组长度
*
*Return Value:成功返回0，失败返回-1
*
*Author:Abel Lee
*
*Log:2011-2-21
***************************************************************************************************/
static void Merge(int a[], int b[], int low, int mid, int high)
{
int k = low;
int begin1 = low;
int end1 = mid;
int begin2 = mid + 1;
int end2 = high;
int q;
while(begin1 <= end1 && begin2 <= end2)
{
if(a[begin1] <= a[begin2])
b[k++] = a[begin1++];
else
b[k++] = a[begin2++];
}
if(begin1 <= end1)
for( q = begin1; q <= end1; q++)
b[k++] = a[q];
else
for(q = begin2; q <= end2; q++)
b[k++] = a[q];
}
static void MergePass(int a[], int b[], int seg, int size)
{
int seg_start_ind = 0;
int j;
while(seg_start_ind <= size - 2 * seg) //#size - 2 * seg的意思是满足可两两归并的最低临界值#%
{
Merge(a, b, seg_start_ind, seg_start_ind + seg - 1, seg_start_ind + seg * 2 - 1);
seg_start_ind += 2 * seg;
}
//#如果一段是正好可归并的数量而另一段则少于正好可归并的数量#%
if(seg_start_ind + seg < size)
Merge(a, b, seg_start_ind, seg_start_ind + seg - 1, size - 1);
else
for(j = seg_start_ind; j < size; j++) //#如果只剩下一段或者更少的数量#%
b[j] = a[j];
}
void MergeSort(int a[], int size)
{
int* temp = (int *)malloc(size);
int seg = 1;
while(seg < size)
{
MergePass(a, temp, seg, size);
seg += seg;
MergePass(temp, a, seg, size);
seg += seg;
}
}
/****************************************************************************************************
*Function Name: RadixSort
*
*Function: 基数排序算法
*
*Parameter: L:排序数据指针
*
*Return Value:成功返回0，失败返回-1
*
*Author:Abel Lee
*
*Log:2011-2-21
***************************************************************************************************/
int RadixSort()
{
return 0;
}
/****************************************************************************************************
*Function Name: ShellSort
*
*Function: 希尔排序算法
*
*Parameter: L:排序数据指针
* dlta:步长值数组
* t：步长值数量
*
*Return Value:成功返回0，失败返回-1
*
*Author:Abel Lee
*
*Log:2011-2-21
***************************************************************************************************/
static void ShellInsert(SortList *L,int dk)
{
int i = 0;
int j = 0;
for(i=dk; i<=L->length; i++)
{
if(LT(L->r[i].key,L->r[i-dk].key))//须将L->r[i]插入有序增量子表
{
L->r[0] = L->r[i];//暂时存在L.r[0]
for(j=i-dk; j>0 && LT(L->r[0].key,L->r[j].key);j-=dk)
{
L->r[j+dk] = L->r[j];//记录后移，查找插入位置
}
L->r[j+dk] = L->r[0];//插入
}
}
}
int ShellSort(SortList *L, int dlta[], int t)
{
int i = 0;
if(L == NULL)
{
return -1;
}
for(i = 0; i < t; i++)
ShellInsert(L,dlta[i]);//一趟增量为dlta[i]的插入排序
return 0;
}
/****************************************************************************************************
*Function Name: HeapSort
*
*Function: 堆排序算法
*
*Parameter: L:排序数据指针
*
*Return Value:成功返回0，失败返回-1
*
*Author:Abel Lee
*
*Log:2011-2-22
***************************************************************************************************/
//已知H->r[s...m]中记录的关键字除H->r[s].key之外均满足堆的定义，本函数调整H->r[s]
//的关键字，使H->r[s...m]成为一个大堆顶（对其中记录的关键字而言）
static int HeapAdject(HeapType *H, int s, int m)
{
ReadType rc;
int i = 0;
rc = H->r[s];
for(i = 2*s; i <= m; i*=2)//沿key较大的孩子节点乡下筛选
{
if(i < m && LT(H->r[i].key,H->r[i+1].key))
{
i++;//i为key较大的记录的下标
if(!LT(rc.key,H->r[i].key))//rc应插入在位置s上
{
break;
}
H->r[s] = H->r[i];
s = i;
}
}
H->r[s] = rc;//插入
return 0;
}
int HeapSort(HeapType *H)
{
int i = 0;
ReadType rt;
for(i = H->length/2; i > 1; i--)
{
HeapAdject(H,i,H->length);
}
for(i = H->length; i > 1; i--)
{
//将堆顶记录和当前未经排序的记录交换
rt = H->r[1];
H->r[1] = H->r[i];
H->r[i] = rt;
HeapAdject(H,1,i-1);//将H->r[1...i-1]重新调整为打顶堆
}
return 0;
}标签：cts global 函数 交换 def \n 有序 perror int end
原文地址：http://blog.51cto.com/14207158/2352653
