排序算法

===============common.h==================================================

#ifndef COMMON_H__#define COMMON_H__#define SIZE 100 /* 元素个数 */typedef int KeyType; /* 待比较元素数据类型 */typedef struct {KeyType key; /* 数据项 */int next; /* 做静态链表用到的下一个节点域 */}Snode; /* 单个结构体元素 */typedef struct {Snode rc[ SIZE ]; /* 预计元素存放区域 */int length; /* 数据的总长度，即元素个数 */}Slist; /* 整个待比较数据类型定义 */#endif /* COMMON_H__ */

 

=========================冒泡排序==========================================

/* 冒泡排序的基本思想：假设有N个无序的待排数据， * 首先将最大的或者最小的元素选出来放在最后 * 一个位置或第一个位置，接着再选出剩下的数中 * 最大或最小的放在次最后或次第一个位置，依次类推 * 直到N个最小或最大全部选出放好 */void BubbleSort(Slist *L) {int i, j;int length = L->length;for ( i = 0; i < length; i++ ){/* 有多少个数据就要选出多少个最大或最小，也就要循环多少次 */for ( j = length - 1; j > i; j-- ){/* 每次都在剩下的数据中找最小或最大的 */if (L->rc[ j ].key < L->rc[ j - 1 ].key){ /* 和相邻数据比较，这就是冒泡，不断的接近自己的最终位置 */int tmp = L->rc[ j ].key;L->rc[ j ].key = L->rc[ j - 1 ].key;L->rc[ j - 1 ].key = tmp;}}}} /* BubbleSort */

=========================插入排序==========================================

/* ******************************** *//*一般插入排序: 在已排好序的序列中插入一张 * 适合的数据*//* ******************************** */void InsertSort(int *data, int size){ int i, j;for (i = 1; i < size; ++i){int tmp = data[ i ];for (j = i - 1; j >= 0 && data[ j ] > tmp; --j){data[ j + 1 ] = data[ j ];}data[ j + 1 ] = tmp;}}/* ******************************** *//* 折半插入排序: 在已排好序的序列中采用 * 折半查找的思想找到下一个要插入的数据 * 的位置下标*//* ******************************** */void BInsertSort(int *data, int size){int i, j;for (i = 1; i < size; ++i){int low = 0, high = i - 1; /* 给定二分范围：当前已排好序的序列 */ int tmp = data[ i ]; /* */while (low <= high){int mid = (low + high) / 2;if (data[ mid ] > tmp)low = mid + 1;elsehigh = mid - 1;}for (j = i - 1; j >= high + 1; --j)/* for (j = i - 1; j >= low - 1; --j)*/data[ j + 1 ] = data[ j ]; /* *//*data[ high + 1 ] = tmp;*/data[ high + 1 ] = tmp;}}/* ******************************** *//* 二路插入排序: 定义一个头和尾；待插入数据 * 首先根首尾元素比较，如果不满足那么元素就 * 应该在首尾之间插入，此时就应该找到正确的 * 插入位置, 运用一般插入算法将数据插入适当 * 位置 *//* ******************************** */void TwaysInsertSort(int *data, int size) {int tmp[ SIZE ], t;int i, j;int first, final;first = final = 0;tmp[ 0 ] = data[ 0 ];for ( i = 1; i < size; i++ ) {t = data[ i ];if ( t >= tmp[ final ] ) { /* 与最后一个元素比较 */ tmp[ ++final ] = t;}else if ( t < tmp[ first ] ) { /* 与首元素比较 */first = (first + size - 1) % size;tmp[ first ] = t;}else { /* 待插入数据应该在首尾元素之间 */ int end = first;int start = final;for ( j = start; j != end && tmp[ j ] > t; j = (j + size - 1) % size) {tmp[ j + 1 ] = tmp[ j ];}tmp[ j + 1 ] = t;final++;}}for ( i = 0; i < size; i++ ) { /* 排好序的数列重新输入数组 */data[ i ] = tmp[ first ];printf( "%d ", tmp[ first ] );first = (first + 1) % size;}}/* ******************************** ** 表插入排序* 运用静态数组实现链表操作* ******************************** */void ArrayInsertSort(Slist *L) {int length = L->length;int i, j;int preID;L->rc[ 0 ].next = 1;L->rc[ 1 ].next = 0; /* 将0和1首先组成循环单链表 */for ( i = 2; i <= length; i++ ){ /* 通过简单循环比较，运用一般插入排序思想将数据下标进行链表排序 *//* 链表排序比较重要的就是把指向当前节点的域给记录下来，此处是preID */for ( j = L->rc[ 0 ].next, preID = 0; j != 0 && L->rc[ j ].key < L->rc[ i ].key; j = L->rc[ j ].next )preID = j;L->rc[ i ].next = L->rc[ preID ].next;L->rc[ preID ].next = i;}}

 

=========================堆排序==========================================

/* 对排序算法涉及两个思想步骤: * 1. 建立大顶堆：形如一棵完全二叉树， * 根节点必须>=(<=)左右孩子节点，但这棵 * 树是通过静态数组建立的，也就是说数组 * 下标i存放的数据必须>=(<=) 2i 和 2i + 1 * 下标存放的数据，这样就形成一个大顶堆，即 * 树的根就是最大(最小)的数； * 2. 如1所述，此时只是将最大或者最小的数放在 * 了根节点上，因此还剩下的几多数据还没排序呢， * 第2个思想就是将根节点上的数据同树中最后一个 * 节点数据对换，那么最后一个节点就成了最小或 * 最大的那个数了；然后我们再将除最后一个外的 * 所有节点重新组成大顶堆，接着就是重复2，得出 * 最终结果*/void HeapSort(Slist *L){int i;for ( i = L->length / 2; i > 0; i-- ){/* 先将数据以i节点数据>=2i和2i+1建立初始大顶堆 -----思想1*/HeapAdjust(L, i, L->length);}for ( i = L->length; i > 1; i-- ){ /* 将大顶堆顶部(树根)同最后一个节点互换 */int tmp = L->rc[ i ].key;L->rc[ i ].key = L->rc[ 1 ].key;L->rc[ 1 ].key = tmp; /* 将除当前最后一个节点的所有节点重新建立大顶堆-----思想2 */HeapAdjust(L, 1, i - 1);}} /* HeapSort */void HeapAdjust(Slist *L, int s, int length){int i;KeyType tmp = L->rc[ s ].key; /* 备份根数据,避免过多的赋值交换 */for ( i = s * 2; i <= length; i *= 2 ){if ( i < length && L->rc[ i ].key < L->rc[ i + 1 ].key ){ /* 先比较根左右节点那个大, 记录大的下标 */i++;}if ( tmp > L->rc[ i ].key ){ /* 根与左右节点中较大, 如果根大，那么直接跳出 */break;}/* 左右节点中较大的同时也大过其父节点的数据移到父节点上 */L->rc[ s ].key = L->rc[ i ].key;s = i;}/* 最后将最初的根节点放在比较后的最终位置 */L->rc[ s ].key = tmp;} /* HeapAdjust */

 

=========================快速排序==========================================

/* **************************************** * 快速排序递归实现版本:选定一个数，一般选 * low下标数据，然后将low与high下标之间的数据 * 同low数据比较，将其分为大于low的和不大于low * 的两部分，分别存放在low的前面和后面； 接着 * 又将low前后数据重复之前的操作，直到low不小于high * ****************************************/void QuickSort(Slist *L){ SubQuickSort(L, 1, L->length);}void SubQuickSort(Slist *L, int low, int high) {int pivotloc;if ( low < high ){pivotloc = Partition(L, low, high); /* 找到low数据在low与high之间的位置privotloc */SubQuickSort(L, low, pivotloc - 1); /* 对low右边数据进行操作 */SubQuickSort(L, pivotloc + 1, high);/* 对low左边数据进行操作 */}}int Partition(Slist *L, int low, int high) {L->rc[ 0 ].key = L->rc[ low ].key;int pivotkey = L->rc[ low ].key;while ( low < high ){while ( low < high && L->rc[ high ].key >= pivotkey ) /* 在high区查找一个比low大的数 */--high;L->rc[ low ].key = L->rc[ high ].key;while ( low < high && L->rc[ low ].key <= pivotkey ) /* 在low区查找一个比low小的数 */++low;L->rc[ high ].key = L->rc[ low ].key;}L->rc[ low ].key = L->rc[ 0 ].key; /* 将low数据最终确定在low与high区域的最合适位置：大于low，小于high区数据 */return low; /* 返回此次low的位置 */}

 

 

=========================选择排序==========================================

/* 选择排序：选择排序其实跟冒泡差不多，也是选择最小或最大的 * 放入当前位置，接着在选择剩下的数据放入当前位置*/void SelectSort(Slist *L) {int i, j;for ( i = 0; i < L->length; i++ ){int tmp = i; /* 保留i，假设i就是最小的那个下标号 */for ( j = i + 1; j < L->length; j++ ){if ( L->rc[ j ].key < L->rc[ tmp ].key ) /* 不断的跟假设的最小比较，直到所有的都比较完，那么就选出最小的了 */{tmp = j;}}if ( tmp != i ){ /* 将选出的最小放在i个位置，也就是第i+1个最小值 */int t = L->rc[ i ].key;L->rc[ i ].key = L->rc[ tmp ].key;L->rc[ tmp ].key = t;}}}

 

=========================希尔排序==========================================

/* 希尔排序：定义一个规则，一个分组的规则 * dkArray就是这个定义的规则数组： * dkArray[ len ] = { 9, 5, 3, 2, 1}*/void ShellSort(Slist *L, int dkArray[], int len){int k;for ( k = 0; k < len; k++ ){ShellInsert(L, dkArray[ k ]);}}void ShellInsert(Slist *L, int dk) { /* 其实去掉dk，也就是一个普通的插入排序 */int i, j;for ( i = dk; i < L->length; i++ ){int tmp = L->rc[ i ].key;for ( j = i - dk; j >= 0 && tmp < L->rc[ j ].key; j = j - dk ){L->rc[ j + dk ].key = L->rc[ j ].key;}L->rc[ j + dk ].key = tmp;}} 

 

=========================归并排序==========================================

/* 归并排序：将一组序列递归的二分，然后再两两合并 * 思想就是将两个排好序的序列合并成一个有序序列*/void MergeSort(Slist *L) {MSort(L->rc, L->rc, 1, L->length);}void MSort(Snode *SR, Snode *TR1, int s, int t) {int m;Snode TR2[ SIZE ];if ( s == t ){TR1[ s ].key = SR[ s ].key;}else{m = (s + t) / 2;MSort(SR, TR2, s, m);MSort(SR, TR2, m + 1, t); /* TR2用于存放两个已排好序的序列 */Merge(TR2, TR1, s, m, t); /* 将TR2中的两个序列重新组合成一个放入TR1中 */}}void Merge(Snode *SR, Snode *TR, int i, int m, int n) {int j, k; /* 合并两个序列存储在TR[i~n] *//* 两个序列: SR[i...m] 和 SR[m+1...n] */for ( j = m + 1, k = i; j <= n && i <= m; ++k ){if ( SR[ i ].key < SR[ j ].key ){TR[ k ].key = SR[ i++ ].key;}else{TR[ k ].key = SR[ j++ ].key;}}while ( i <= m ){TR[ k++ ].key = SR[ i++ ].key;}while ( j <= n ){TR[ k++ ].key = SR[ j++ ].key;}}

 

=========================基数排序==========================================

/* 基数排序：运用多种规则对同一组数据进行排序 * 基数就是所用到的规则数； * 每使用一次规则，将数据按规则排好后，都要再 * 进行收集合并，以备下一个规则所用； * 好像扑克牌：有同一种花色，同一个数字等规则*//* 下面以整数排序为例,规则有以下几种： * 1. 按个位数分10各组组织数据(0到9) * 2. 按十位数分10................. * 3. 按百位数分10................. * 暂时就以3位数为例，其实可以很多位数据*/void RadixSort(Slist *L) { /* 还是采用单链表的方式组织收集数据 */int i;ArrType f[ RADIX ], e[ RADIX ]; /* f和e表示每个规则下的分组(总共10个), 其中f填充该组第一个成员下标，而e则填充该组最后一个成员下标 *//* 形成静态循环单链表 */for ( i = 0; i < L->length; i++ ){L->rc[ i ].next = i + 1;}L->rc[ i ].next = 0;for ( i = 1; i <= KEYNUM; i++ ) /* KEYNUM 是总的规则数, i为第几个规则 */{Distribute(L->rc, i, f, e);Collect(L->rc, i, f, e);}}void Distribute(Snode *r, int i, ArrType *f, ArrType *e) { /* 按规则分配数据，将数据分配在相符的列 */int j;int p;for ( j = 0; j < RADIX; j++ ){f[ j ] = 0;}for ( p = r[ 0 ].next; p; p = r[ p ].next ){j = KeyLocal(r[ p ].key, i);if ( !f[ j ] ){f[ j ] = p;}else{r[ e[ j ] ].next = p;}e[ j ] = p;}}void Collect(Snode *r, int i, ArrType *f, ArrType *e) { /* 数据收集重新整理，以备下一规则所用 */int j = 0, t = 0;while ( j < RADIX ){if ( f[ j ] ){r[ t ].next = f[ j ]; t = e[ j ];}j++;}r[ t ].next = 0;}int KeyLocal(KeyType key, int i){ /* 获取相应位的数据 */int j;switch ( i ) /* i为规则ID，1表示以个位规则，2表示十位，3表示百位.... */{case 1 :j = key % 10;break;case 2 :j = ( key / 10 ) % 10;break;case 3 :j = key / 100;break;default:break;}return j;}