排序算法

===============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; else high = 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; }