1. void Disp2(int iarr[], int length) 
  2. { 
  3.     for(int loop1 = 0; loop1 < length; ++loop1) 
  4.         cout<<iarr[loop1]<<' '; 
  5.     cout<<endl; 
  6. } 
  7.  
  8.  
  9. void InsertSort2(int iarr[], int length) 
  10. { 
  11.     int loop1 = 0, loop2 = 0, temp = 0; 
  12.      
  13.     for(loop1 = 1; loop1 < length; ++loop1) 
  14.     { 
  15.         temp  = iarr[loop1]; 
  16.         loop2 = loop1 - 1; 
  17.         while(loop2 >= 0)        
  18.             if(iarr[loop2] > temp) 
  19.             {    iarr[loop2 + 1] = iarr[loop2]; --loop2;} 
  20.             else break; 
  21.          
  22.         iarr[loop2 + 1] = temp; 
  23.     } 
  24. } 
  25.  
  26. void ShellSort2(int iarr[], int length) 
  27. { 
  28.     int loop1 = 0, loop2 = 0, temp = 0,gap = length / 2; 
  29.  
  30.     while(gap > 0) 
  31.     { 
  32.         for(loop1 = gap; loop1 < length; ++loop1) 
  33.         { 
  34.             temp  = iarr[loop1]; 
  35.             loop2 = loop1 - gap; 
  36.             while(loop2 >= 0 && iarr[loop2] > temp) 
  37.             { 
  38.                 iarr[loop2 + gap] = iarr[loop2]; 
  39.                 loop2 = loop2 - gap; 
  40.             } 
  41.             iarr[loop2 + gap] = temp; 
  42.         } 
  43.         gap = gap / 2; 
  44.     } 
  45. } 
  46.  
  47. void SelectSort2(int iarr[], int length) 
  48. { 
  49.     int loop1 = 0, loop2 = 0, temp = 0, tempval = 0; 
  50.      
  51.     for(loop1 = 0; loop1 < length; ++loop1) 
  52.     { 
  53.         temp = loop1; 
  54.         for(loop2 = loop1 + 1; loop2 < length; ++loop2) 
  55.         { 
  56.             if(iarr[loop2] < iarr[temp]) 
  57.                 temp = loop2; 
  58.         } 
  59.         if(temp != loop1) 
  60.         { 
  61.             tempval = iarr[temp]; 
  62.             iarr[temp] = iarr[loop1]; 
  63.             iarr[loop1] = tempval; 
  64.         } 
  65.     } 
  66. } 
  67.  
  68.  
  69.  
  70. void Sift2(int iarr[], int low, int high) 
  71. { 
  72.     int lowval = low, highval = high, temp = 0,  ivar1 = 0; 
  73.      
  74.     temp  = iarr[lowval]; 
  75.     while(lowval <= highval)                             //因为此处的判断是 lowval <= highval， 所以后面要有 lowval * 2 <= highval 的判断， 因为要保证其子树不越界 
  76.     {        
  77.         ivar1 = lowval * 2; 
  78.         if(ivar1 > highval) break;                      //子树越界的情况 
  79.         if( ivar1 + 1 <= highval && iarr[ivar1] < iarr[ivar1 + 1]) 
  80.             ++ivar1; 
  81.         if(temp < iarr[ivar1]) 
  82.         { 
  83.             iarr[lowval] = iarr[ivar1]; 
  84.             lowval = ivar1; 
  85.         }else                
  86.             break;       
  87.     } 
  88.     iarr[lowval] = temp; 
  89. } 
  90.  
  91. void Sift3(int iarr[], int low, int high) 
  92. { 
  93.     int lvar = 0, hvar = 0, tempvar = 0, temp = 0; 
  94.  
  95.     lvar = low, tempvar = lvar * 2;  hvar = high;  temp = iarr[low]; 
  96.     while(tempvar <= hvar) 
  97.     { 
  98.         if(tempvar + 1 <= hvar && iarr[tempvar] < iarr[tempvar + 1]) 
  99.             ++tempvar; 
  100.         if(temp < iarr[tempvar]) 
  101.         { 
  102.             iarr[lvar] = iarr[tempvar]; 
  103.             lvar = tempvar; 
  104.             tempvar = lvar * 2; 
  105.         }else break; 
  106.     } 
  107.     iarr[lvar] = temp; 
  108. } 
  109.  
  110. void HeapSort22(int iarr[], int length) 
  111. { 
  112.     int loop1 = 0, loop2 = 0, temp = 0; 
  113.  
  114.     for(loop1 = length / 2; loop1 > 0; --loop1) 
  115.         Sift3(iarr, loop1, length); 
  116.     for(loop1 = length; loop1 > 1; --loop1) 
  117.     { 
  118.         temp = iarr[loop1]; 
  119.         iarr[loop1] = iarr[1]; 
  120.         iarr[1] = temp; 
  121.         Sift3(iarr, 1, loop1 - 1); 
  122.     } 
  123. } 
  124.  
  125. void BubbleSort2(int iarr[], int length) 
  126. { 
  127.     int loop1 = 0, loop2 = 0, temp = 0, exchange = 0; 
  128.  
  129.     for(loop1 = 0; loop1 < length; ++loop1) 
  130.     {   exchange = 0; 
  131.         for(loop2 = length -1; loop2 > loop1; --loop2) 
  132.         { 
  133.             if(iarr[loop2] < iarr[loop2 - 1]) 
  134.             { 
  135.                 temp = iarr[loop2]; 
  136.                 iarr[loop2] = iarr[loop2 - 1]; 
  137.                 iarr[loop2 -1] = temp; 
  138.                 exchange = 1; 
  139.             } 
  140.         } 
  141.         if(exchange == 0) return; 
  142.     } 
  143. } 
  144.  
  145. void QuickSort22(int iarr[], int begin, int end) 
  146. { 
  147.     int loop1 = 0, loop2 = 0, temp = 0; 
  148.     temp = iarr[begin]; 
  149.  
  150.     loop1 = begin; loop2 = end; 
  151.     if(begin >= end) return; 
  152.     while(loop1 < loop2) 
  153.     { 
  154.         while(loop2 > loop1 && iarr[loop2] > temp) 
  155.             --loop2; 
  156.         if(loop2 > loop1) 
  157.         { 
  158.             iarr[loop1] = iarr[loop2]; 
  159.             ++loop1; 
  160.         } 
  161.         while(loop1 < loop2 && iarr[loop1] < temp) 
  162.             ++loop1; 
  163.         if(loop1 < loop2) 
  164.         { 
  165.             iarr[loop2] = iarr[loop1]; 
  166.             --loop2; 
  167.         } 
  168.     } 
  169.     iarr[loop1] = temp; 
  170.     QuickSort22(iarr, begin, loop1 -1); 
  171.     QuickSort22(iarr, loop1 + 1,end); 
  172. } 
  173.  
  174.  
  175.  
  176. void Merge2(int iarr[],int begin, int mid, int end) 
  177. { 
  178.     int loop1 = begin, loop2 = mid + 1, temp = 0, index = 0; 
  179.     int tempiarr[30]; 
  180.  
  181.     while(loop1 <= mid && loop2 <= end) 
  182.     { 
  183.         if(iarr[loop1] > iarr[loop2]) 
  184.         { 
  185.             tempiarr[index] = iarr[loop2]; 
  186.             ++index;    ++loop2; 
  187.         }else if(iarr[loop1] < iarr[loop2]) 
  188.         { 
  189.             tempiarr[index] = iarr[loop1]; 
  190.             ++index;    ++loop1; 
  191.         }else 
  192.         { 
  193.             tempiarr[index] = iarr[loop1]; 
  194.             ++index;    ++loop1; 
  195.             tempiarr[index] = iarr[loop2]; 
  196.             ++index;    ++loop2; 
  197.         } 
  198.     } 
  199.     while(loop1 <= mid) 
  200.     { 
  201.         tempiarr[index] = iarr[loop1]; 
  202.         ++index;   ++loop1; 
  203.     } 
  204.     while(loop2 <= end) 
  205.     { 
  206.         tempiarr[index] = iarr[loop2]; 
  207.         ++index;   ++loop2; 
  208.     } 
  209.     for(loop1 = 0; loop1 < index; ++loop1) 
  210.         iarr[loop1] = tempiarr[loop1];       
  211. } 
  212.  
  213. void MergePass2(int iarr[], int len, int length) 
  214. { 
  215.     int ivar = 0; 
  216.     for(ivar = 0; ivar + len * 2 - 1 <= length; ivar = ivar + 2 * len) 
  217.     { 
  218.         Merge2(iarr, ivar, ivar + len - 1, ivar + 2 * len - 1); 
  219.          
  220.     } 
  221.     if(ivar + len - 1 < length) 
  222.     { 
  223.         Merge2(iarr, ivar, ivar + len -1, length); 
  224.     } 
  225. } 
  226.  
  227. void MergeSort2(int iarr[], int length) 
  228. { 
  229.     int len = 1; 
  230.     for(len = 1; len <= length; len = 2 * len) 
  231.     {   MergePass2(iarr, len, length );  } 
  232. } 
 
  
 
 
  
 
  
  1. void main() 
  2. { 
  3.     Node *nodes = NULL; 
  4.     int iarr[16] = {1,18,7,30,9,15,99,36,9,12,25,11,2,16,17,10}; 
  5.     char carr[10][4] = {"123","345","568","126","455","987","356","678","387","438"}; 
  6. //  Disp(iarr,6); 
  7. //  InsertSort(iarr,6); 
  8. //  ShellSort(iarr,6); 
  9.      
  10. /*  CreateList(nodes,iarr,6); 
  11.     Disp(nodes);    
  12.     InsertSort2(nodes); 
  13.     Disp(nodes);*/ 
  14. //  Disp(carr,10); 
  15. //  SelectSort2(iarr,6); 
  16. //  HeapSort2(iarr,7); 
  17. //  BubbleSort(iarr,8); 
  18. //  QuickSort(iarr,0,8); 
  19. //  DBubble2 (iarr,10); 
  20. //  QuickSort2(iarr,0,12); 
  21. //  Partition(iarr,0,11);   不明白此函数为什么不能正常运行 
  22. //  MergeSort(iarr,14); 
  23. //  RadixSort(carr,10,3); 
  24. //  Disp(carr,10); 
  25.       
  26.   
  27. //  cout<<"is small heap: "<<isSmallHeap(iarr,7)<<endl; 
  28.  
  29.     Disp2(iarr,16); 
  30. //  InsertSort2(iarr,15); 
  31. //  ShellSort2(iarr,15); 
  32. //  SelectSort2(iarr,15); 
  33. //  HeapSort22(iarr,14); 
  34. //  BubbleSort2(iarr,15); 
  35. //  QuickSort22(iarr, 0, 15); 
  36.     MergeSort(iarr,15); 
  37.   
  38.     Disp2(iarr,16); 
  39. }