基本排序算法

来源：互联网发布：淘宝交不了保证金编辑：程序博客网时间：2024/06/09 21:01
  1 typedef int datatype;  2   3 inline void swap(datatype &a, datatype &b)  4 {  5     datatype tmp = a;  6     a = b;  7     b = tmp;  8 }  9  10 /*********************************** 11   冒泡排序: 12   每次将最小的数"冒"在最前面  13 ***********************************/ 14 void BubbleSort(datatype Array[], int length) 15 { 16     for (int i = 0; i < length; i++) 17     { 18         for (int j = i+1; j < length; j++) 19         { 20             if (Array[j] < Array[i]) 21             { 22                 swap(Array[i], Array[j]); 23             } 24         } 25     } 26 } 27  28 /***********************************  29  插入排序 30    从后往前依次插入元素  31 ***********************************/ 32 void InsertSort(datatype Array[], int length) 33 { 34  35     for(int j = 1; j  != length; j++)   36     {   37         datatype key = Array[j];   38         int i = j - 1;   39         while(i != -1 && Array[i] > key)   40         {   41             Array[i+1]= Array[i];   42             i--;   43         }   44           45         Array[i+1] = key;   46     }   47  48 } 49  50 /***********************************  51  归并排序 52    分别对左右两边进行排序,然后合并,需要申请新的空间  53 ***********************************/  54 static void Merge(datatype SortArray[], int start, int middle, int end)   55 {   56     int LeftLength = middle - start + 1;   57     int RightLength = end - middle;   58    59     // 创建临时数组保存已排序好的左右数组    60     datatype *LeftArray = (datatype *)malloc(LeftLength * sizeof(datatype));   61     for(int i = 0; i != LeftLength; ++i)   62         LeftArray[i] = SortArray[start + i];   63     datatype *RightArray = (datatype *)malloc(RightLength * sizeof(datatype));   64     for(int i = 0; i != RightLength; ++i)   65         RightArray[i] = SortArray[middle + i + 1];   66   67     // 归并    68     int i = 0;   69     int j = 0;   70     int k = start;   71     while(i != LeftLength && j != RightLength)   72     {   73         if(LeftArray[i] <= RightArray[j])   74             SortArray[k++] = LeftArray[i++];   75         else   76             SortArray[k++] = RightArray[j++];   77     }   78    79     while(i != LeftLength)   80     {   81         SortArray[k++] = LeftArray[i++];       82     }   83    84     while(j != RightLength)   85     {   86         SortArray[k++] = RightArray[j++];   87     }   88    89     free(LeftArray);   90     free(RightArray);   91 }   92  93 static void _MergeSort(datatype Array[], int start, int end) 94 { 95     if (start < end) 96     { 97         int middle = (start + end)/2; 98         _MergeSort(Array, start, middle); 99         _MergeSort(Array, middle+1, end);100         Merge(Array, start, middle, end);101     }102 }103 104 void MergeSort(datatype Array[], int length)105 {106     _MergeSort(Array, 0, length -1);107 }108 109 /*********************************** 110     快速排序算法,和归并排序相比,快速排序不需要额外的空间111 ***********************************/112 // 将数组划分为2组,左边的都比中间元素小,右边的都比中间元素大113 static int Partition(datatype SortArray[], int start, int end)  114 {  115     datatype middleValue = SortArray[end];  116     int middleIndex = start - 1;  117   118    for(int j = start; j != end; ++j)  119     {  120         if (SortArray[j] <= middleValue)  121         {  122           middleIndex++;  123            swap(SortArray[middleIndex], SortArray[j]);  124         }  125           126     }  127     swap(SortArray[middleIndex+1], SortArray[end]);  128   129     return middleIndex+1;  130 }  131 132 static void _QuickSort(datatype SortArray[], int start, int end)  133 {  134     if(start < end)  135     {  136         int middle = Partition(SortArray, start, end);  137         _QuickSort(SortArray, start, middle-1);  138         _QuickSort(SortArray, middle+1, end);  139     }  140 }  141 142 void QuickSort(datatype SortArray[], int length)143 {144     _QuickSort(SortArray, 0, length-1);    145 }146 147 /*********************************** 148  计数排序 149     计数排序的基本思想是对每一个输入元素x,确定 150  出不小于x的元素个数。 151     只适用于正整数 152 ***********************************/153 static void _CountingSort(datatype SortArray[], datatype SortedArray[], int ArrayLength,datatype maxValue)  154 {  155     datatype *CountArray  = (datatype *)malloc((maxValue+1) * sizeof(datatype)); 156     assert(NULL != CountArray);157   158     // 初始化   159     for(int i = 0; i != maxValue+1; ++i)  160         CountArray[i] = 0;  161   162     // 计数   163     for(int i = 0; i != ArrayLength; ++i)  164         CountArray[(SortArray[i])] += 1;    // 等于的元素个数   165   166     /*167        若不考虑稳定性,可以使用以下代码,此时实际不需要SortedArray数组168         int index = 0;169         for (datatype i = 0; i <= maxValue; i++)170         {171             for (int j = 0; j < CountArray[i]; j++)172             {173                 SortedArray[inddex++] = i; 174             }175         }176 177     */178     179     // 重排   180     /* 181     从大到小,可保持稳定性,即具有相同值的元素 182     在输出数组中的相对次序与他们在输入数组中的次序相同 183     */  184     for(int i = 1; i != maxValue+1; ++i)  185         CountArray[i] += CountArray[i-1];   // 小于或等于的个数   186    187     for(int i = ArrayLength-1; i != -1; --i)  188     {  189         // CountArray[SortArray[i]]：小于或等于SortArray[i]的个数,再-1即为排序后在数组中的位置190         SortedArray[(CountArray[(SortArray[i])]) - 1] = SortArray[i];   191         CountArray[(SortArray[i])] -= 1;  192           193     }  194   195     free(CountArray);  196 }  197 198 void CountingSort(datatype SortArray[], int length)199 {200     datatype maxValue = 0;201     for (int i = 0; i < length; i++)202     {203         maxValue = maxValue > SortArray[i] ? maxValue : SortArray[i];204     }205 206     datatype *SortedArray = (datatype *)malloc(length * sizeof(datatype));207     assert(NULL !=SortedArray);208 209     _CountingSort(SortArray, SortedArray, length, maxValue);210 211     for (int i = 0; i < length; i++)212     {213         SortArray[i] = SortedArray[i];214     }215 216     free(SortedArray);217 218 }219 220 /***********************************221  基数排序 222     利用计数排序算法,对数组从低向高位排序 223 ***********************************/224 static void CountingSortForRadixSort(datatype SortArray[], datatype CmpArray[], int ArrayLength, int maxValue)  225 {  226     datatype *CountArray  = (datatype *)malloc((maxValue+1) * sizeof(datatype));  227     datatype *SortedArray = (datatype *)malloc(ArrayLength * sizeof(datatype));  228     assert(NULL != CountArray || NULL != SortedArray);229 230     for(int i = 0; i != maxValue+1; ++i)  231         CountArray[i] = 0;  232       233     for(int i = 0; i != ArrayLength; ++i)  234         CountArray[(CmpArray[i])]++;  235     for(int i = 1; i != maxValue+1; ++i)  236         CountArray[i] += CountArray[i-1];  237   238     for(int i = ArrayLength-1; i != -1; --i)  239     {  240         SortedArray[(CountArray[CmpArray[i]])-1]= SortArray[i];  241         CountArray[CmpArray[i]] -= 1;  242     }  243   244     for(int i = 0; i != ArrayLength; ++i)  245         SortArray[i] = SortedArray[i];  246   247     free(CountArray);  248     free(SortedArray);  249       250 }  251 252 void RadixSort(datatype SortArray[], int ArrayLength)  253 {  254     datatype *RadixArray = (datatype *)malloc(ArrayLength * sizeof(datatype)); 255     assert(NULL != RadixArray);256      257     datatype BaseNumber = 1;  258     bool rsIsOk = false;  259   260     while(false ==rsIsOk)  261     {  262         rsIsOk = true;  263         BaseNumber *= 10;  264   265         for(int i = 0; i != ArrayLength; ++i)  266         {  267             RadixArray[i] = SortArray[i] % BaseNumber;  268             RadixArray[i] = RadixArray[i] / (BaseNumber / 10);  269             if(RadixArray[i] > 0)  270                 rsIsOk = false;  271         }  272         if(true == rsIsOk)  273             break;  274         CountingSortForRadixSort(SortArray, RadixArray, ArrayLength, 9);  275     }  276   277     free(RadixArray);  278 }  279 /***********************************280 堆排序算法 281     堆: 可以视为一棵完全二叉树,树的每一层都是填满的,除了最后一层 282     其任何一非叶节点满足性质：283     Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]或者Key[i]>=Key[2i+1]&&key>=key[2i+2]284 285     堆排序算法主要用于优先级队列 286 ***********************************/287 #define PARENT(x)   ((x) >> 1)            // 节点x的父节点下标号   288 #define LEFT(x)     ((x) << 1)            // 节点x的左子节点下标号   289 #define RIGHT(x)    (((x) << 1) + 1)      // 节点x的右子节点下标号   290   291 static void MaxHeapify(int SortArray[], int heap_size, int parent)  292 {   293     int left, right, largest;  294   295     left = LEFT(parent+1) - 1;  296     right = RIGHT(parent+1) -1;  297   298     if(left < heap_size && SortArray[left] > SortArray[parent])  299         largest = left;  300     else  301         largest = parent;  302   303     if(right < heap_size && SortArray[right] > SortArray[largest])  304         largest = right;  305   306     if(largest != parent)  307     {  308         swap(SortArray[largest], SortArray[parent]);  309   310         MaxHeapify(SortArray, heap_size, largest);  311     }  312 }  313 314 static void BuildMaxHeap(int SortArray[], int ArrayLength)  315 {  316     int HeapSize = ArrayLength;  317   318     for(int i = ArrayLength/2; i != -1; --i)  319         MaxHeapify(SortArray,HeapSize,i);  320 } 321 322 void HeapSort(int SortArray[], int ArrayLength)  323 {  324     int HeapSize = ArrayLength;  325   326     BuildMaxHeap(SortArray, ArrayLength);  327     for(int i = ArrayLength-1; i !=0; --i)  328     {  329         swap(SortArray[0], SortArray[i]);  330         HeapSize--;  331         MaxHeapify(SortArray, HeapSize, 0);  332     }  333 }
0 0