本人参考网上对冒泡算法的优化，再一次进行的小小优化，欢迎各位指点
7 S. H& x8 `* R# l

1. void bubble4(uint16_t *arr, uint16_t length)
   
2. {
   
3.         uint16_t borden_right = length -1; //右边界初始值
   
4.         uint16_t borden_left  = 0;         //左边界初始值为
   
5.         uint16_t lastPos      = 0;         //记录右边界的值
   ' v- C2 D' H$ m# A
6.         uint16_t prePos       = 0;         //记录左边界的值
   
7.     uint16_t temp;                     //交换的中间变量
   
8.         uint8_t  flag, i, j;               //是否有交换的标志     
   4 H# o* H. C4 c9 [/ g/ T
9.    
   
10.    
    ) ^3 p: }5 I* {4 P
11.         for(i = 0; i < length-1; i++)
    & L) o: B9 k4 s4 G' R1 @9 B/ x7 ?: T
12.     {
    ; o' M" J+ ~6 ]' H  Q! n
13.                 flag = 1;
    
14. 
    9 l4 [% `/ w$ o+ y$ _* }
15.                 //正向找出最大值
    ( y. d/ y0 v3 Z! f* }( w7 m$ X
16.                 for( j = borden_left; j < borden_right; j++)
    9 [; a5 K  x0 `0 j) S
17.         {
    5 Z2 D: a  D; U
18.                         if(arr[j] > arr[j+1])
    
19.             {
    ( B- ~" t4 ]! [2 a$ O7 w2 x1 a
20.                 temp     = arr[j];
    & Q3 @3 O; Y( R: X7 d3 c
21.                 arr[j]   = arr[j+1];
    
22.                 arr[j+1] = temp;
    " j# _% X4 }7 b/ O: G$ ^1 e$ d, U
23.                                 flag = 0;
    
24.                                 lastPos = j;
    
25.                         }
    , R' x, Z/ Q0 h9 @) m, Q! `  B
26.                 }
    6 e2 d) X2 }/ K% @$ d* V1 u
27.         
    ! Y# I4 ^3 I, t
28.         //正向没发生交换就证明数组已经排好了
    . U1 x. q* K0 J, S, H5 p2 O" E8 n
29.         if(flag)
    
30.         {
    
31.             break;
    ' t! w. W; h/ v% o
32.         }
    . m+ Y+ }8 u- |+ m% h! c! b0 b( s6 \: X: l
33.         
    
34.         borden_right = lastPos;
    
35.    
    & C% E2 S2 n" K9 C* @
36.                 //逆向找出最小值
    
37.                 for( j = borden_right; j > borden_left; j--)
    
38.         {
    , m  U7 G* }% \) P5 H" {- p, n
39.                         if(arr[j] < arr[j-1])
    
40.             {
    ; g$ e. L( n6 v2 c. Q
41.                 temp     = arr[j];
    + v/ \$ r9 ]3 p0 b* a
42.                 arr[j]   = arr[j-1];
    
43.                 arr[j-1] = temp;
    
44.                                 flag = 0;
    
45.                                 prePos = j;
    
46.                         }
    $ B- A9 g( H5 z) r3 Y
47.                 }
    
48. 
    
49.                 if(flag)
    
50.         {
    ) o5 A$ _: {* B$ `$ u
51.                         break;
    
52.                 }
    
53.        
    
54.                 borden_left  = prePos;
    5 n) L* D" F8 `" {/ n
55.         
    : L1 M$ ~$ B* g! e
56.         //每排序一次都把数组打印出来
    : y- F0 V, A* ~) q$ f
57. //        for(j = 0; j < length; j++)
    ! C4 z& {) B2 V& P: _- X
58. //        {
    
59. //            USART_SendData(USART1, arr[j]);
    
60. //            while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
    / ?0 }% D5 r& R# n
61. //        }
    
62.         }
    
63. 
    
64. }

复制代码

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

我觉得所谓优化，应该是有明确的对比参数数据的，比如执行时间消耗短了，占用RAM变小了……等等
如果楼主能提供这些数据，我觉得更好

直接上选择法吧

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

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

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