排序题

题目为：

有一个已经排序的数组（升序），数组中可能有正数、负数或0，求数组中元素的绝对值最小的数，要求，不能用顺序比较的方法（复杂度需要小于O（n）），可以使用任何语言实现

例如，数组{-20，-13，-4, 6, 77,200} ，绝对值最小的是-4。

这一题该如何求呢？

初步的解决思路是：

    1.数组中的元素全为正，取最左边的数字；

    2.数组中的元素全为负，取最右边的数字的绝对值；

    3.数组中有正数有负数，就用二分法查找，判断中间元素的符号

       a)中间元素为正，继续判断中间元素前面一个元素的符号

       b)中间元素为负，判断中间元素后一个元素的符号

       c)中间元素为零，令其等于结果值返回

下面是根据上面的想法的代码实现，应该还会有漏洞

[cpp] view plaincopyprint?

1. #include "stdafx.h"   
2. #include <iostream>   
3.   
4. using namespace std;  
5.   
6. //求取数组中绝对值最小的数字   
7. int minAbsolute(int arr[],int size);  
8. //返回两个数中较小的数   
9. int compare(int a,int b);  
10. int _tmain(int argc, _TCHAR* argv[])  
11. {  
12.     int a[10] = {-10,-8,-5,-3,2,5,8,9,11,15};     
13.     int size = sizeof(a)/sizeof(int);  
14.     int result = minAbsolute(a,size);  
15.     cout<<"绝对值最小的数是："<<result<<endl;  
16.     return 0;  
17. }  
18.   
19. int minAbsolute(int arr[],int size)  
20. {  
21.     int first,last,mid;   
22.     first = 0;  
23.     last = size - 1;  
24.     int result;  
25.   
26.     //数组中的数全是负数，取最右边的数   
27.     if (arr[0] < 0 && arr[size-1] < 0)  
28.     {  
29.         result = arr[size-1];  
30.     }   
31.     //数组中的数全是正数，取最左边的数   
32.     else if (arr[0] > 0 && arr[size-1] > 0)  
33.     {  
34.         result = arr[0];  
35.     }  
36.     //数组有正有负，二分查找   
37.     else  
38.     {  
39.         while(first < last)  
40.         {  
41.             int mid = (first + last)/2;  
42.             if (arr[mid] > 0)  
43.             {  
44.                 if (arr[mid - 1] > 0)  
45.                 {  
46.                     last = mid - 1;  
47.                 }   
48.                 else if(arr[mid - 1] < 0)  
49.                 {  
50.                     result = compare(-arr[mid - 1],arr[mid]);  
51.                     break;  
52.                 }  
53.                 else  
54.                 {  
55.                     result = arr[mid - 1];  
56.                     break;  
57.                 }  
58.             }  
59.             else if (arr[mid] < 0)  
60.             {  
61.                 if (arr[mid + 1] < 0)  
62.                 {  
63.                     first = mid + 1;  
64.                 }   
65.                 else if (arr[mid + 1] > 0)  
66.                 {  
67.                     result = compare(-arr[mid],arr[mid+1]);  
68.                     break;  
69.                 }   
70.                 else  
71.                 {  
72.                     result = arr[mid + 1];  
73.                     break;  
74.                 }                 
75.             }   
76.             else  
77.             {  
78.                 result = arr[mid];  
79.                 break;  
80.             }  
81.         }  
82.     }  
83.     return result;  
84. }  
85.   
86. int compare(int a,int b)  
87. {  
88.     if (a > b)  
89.     {  
90.         return b;  
91.     }   
92.     else  
93.     {  
94.         return a;  
95.     }  
96. }