本人参考网上对冒泡算法的优化，再一次进行的小小优化，欢迎各位指点
( Q7 T* l. l# w/ E

1. void bubble4(uint16_t *arr, uint16_t length)
   
2. {
   ) b! X% q  N" A. j1 Q8 \' f3 Z; ~- ^
3.         uint16_t borden_right = length -1; //右边界初始值
   
4.         uint16_t borden_left  = 0;         //左边界初始值为
   
5.         uint16_t lastPos      = 0;         //记录右边界的值
   % y# x, m& X9 G
6.         uint16_t prePos       = 0;         //记录左边界的值
   * a7 [% e1 j8 K* M/ g! ~$ Z, E
7.     uint16_t temp;                     //交换的中间变量
   * t! S  p% E8 X* A: u3 G! P
8.         uint8_t  flag, i, j;               //是否有交换的标志     
   
9.    
   
10.    
    + z" G$ }5 ]' _. M+ \
11.         for(i = 0; i < length-1; i++)
    / W' b! R/ a( L2 r" p
12.     {
    + o# W) D2 s3 J& [  N: o8 G* q
13.                 flag = 1;
    
14. 
    9 o$ o) a' W  j0 c: |
15.                 //正向找出最大值
    $ ~4 l9 v) ~# J. {( [& e- \
16.                 for( j = borden_left; j < borden_right; j++)
    & X) P! j, y# r% a/ [: }
17.         {
    
18.                         if(arr[j] > arr[j+1])
    / X0 N! Y8 S2 X. L, e% U
19.             {
    
20.                 temp     = arr[j];
    
21.                 arr[j]   = arr[j+1];
    " `7 g# k* o2 ~1 j* l0 i* @  L( |
22.                 arr[j+1] = temp;
    & F" l3 T% R9 S
23.                                 flag = 0;
    
24.                                 lastPos = j;
    
25.                         }
    
26.                 }
    
27.         
    * q- y8 T% }( f* e
28.         //正向没发生交换就证明数组已经排好了
    % {2 d% t, r5 ]+ E, @5 l2 C( Y$ ~
29.         if(flag)
    , f& n& ]+ j- k) T: E
30.         {
    
31.             break;
    
32.         }
    * `6 y- Q/ ?( Y7 P5 d
33.         
    
34.         borden_right = lastPos;
    6 a2 s: g0 l1 f! u& \
35.    
    ; L( u  c8 W: I( h
36.                 //逆向找出最小值
    
37.                 for( j = borden_right; j > borden_left; j--)
    2 @* b" h6 R8 ^. I
38.         {
    + r, i% m# {- N, G
39.                         if(arr[j] < arr[j-1])
    & @2 Y6 d9 c6 Q
40.             {
    & \9 l' K1 H$ b# v5 x% M
41.                 temp     = arr[j];
    - `  `# |, w; C$ A
42.                 arr[j]   = arr[j-1];
    ! y/ @: A7 n4 W) H
43.                 arr[j-1] = temp;
    
44.                                 flag = 0;
    
45.                                 prePos = j;
    
46.                         }
    ! K$ P  H1 Q4 v) c% `( t
47.                 }
    
48. 
    3 n. H8 o4 k! c7 f; s
49.                 if(flag)
    
50.         {
    
51.                         break;
    
52.                 }
    9 E6 _# N( A) N9 G
53.        
      U0 I/ N2 g/ C7 f* P
54.                 borden_left  = prePos;
    / r# W, D" g+ E5 K1 u! K" `
55.         
    
56.         //每排序一次都把数组打印出来
    
57. //        for(j = 0; j < length; j++)
    + _: y5 `% l, b. r6 c+ J- J- u
58. //        {
    ' n9 R1 `8 B$ ?0 q- j
59. //            USART_SendData(USART1, arr[j]);
    
60. //            while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
    
61. //        }
    
62.         }
    4 ?5 {+ N$ C. w1 W* n5 o
63. 
    
64. }

复制代码

从时间复杂度上，你比原始的冒泡法系数还大一些？

我觉得所谓优化，应该是有明确的对比参数数据的，比如执行时间消耗短了，占用RAM变小了……等等
" T1 ?0 p. V0 g% S  W& r如果楼主能提供这些数据，我觉得更好

直接上选择法吧

时间上会节省，但栈空间就要付出多一点，个人兴趣，实验数据就不发出来了

你这没看出哪有优化，在网上看到过相似的算法, 你这改过的程序，CPU执行的过程，比你不改更花时间，除非是运算的百W级别数组

你有没有测试过具体时间呢，比较下常规的和你改过在 1000个数组排列，耗时大小