顺序表操作补充

二分查找

a.非递归方法实现二分查找

 1 //[]
 2 int BinarySearch(SeqList *pSeq, ElemType x)
 3 {
 4     assert(pSeq);
 5     int left = 0;
 6     int right = pSeq->size - 1;
 7     while(left<=right)
 8     {
 9         int cur = left+(right-left)/2;
10         if(pSeq->array[cur] == x)
11         {
12             return cur;
13         }
14         else if(pSeq->array[cur]>x)
15         {
16             right = cur - 1;
17         }
18         else
19             left = cur + 1;
20     }
21     return -1;
22 }

b 递归方法实现二分查找：

 1 //////////////////////////////////递归实现二分查找
 2 int BinarySearch_R(SeqList *pSeq,int left,int right ,ElemType x)
 3 {
 4     if (left<=right)
 5     {
 6         int mid = left+(right-left)/2;
 7         if( x== pSeq->array[mid])
 8             return mid;
 9         else if(x<pSeq->array[mid])
10             return BinarySearch_R(pSeq,left,mid-1,x);
11         else if(x>pSeq->array[mid])
12             return BinarySearch_R(pSeq,mid+1,right,x);
13     }
14     else
15         return -1;
16 }

优化的冒泡排序

注：与一般的冒泡排序相比，优化方法是设置岗哨，监视每次遍历是否有值交换，没有直接退出，减少不必要的循环次数

优化后的冒泡查找：

 1 //////////冒泡排序优化
 2 void  BubbSort_op(SeqList *s)
 3 {
 4     int exchange = 0;
 5     for(size_t i = 0; i < s->size-1;++i)
 6     {
 7         for(size_t j = 0; j < s->size-1-i; ++j)
 8         {
 9             if(s->array[j] > s->array[j+1])
10             {
11                 ElemType tmp = s->array[j];
12                 s->array[j] = s->array[j+1];
13                 s->array[j+1] = tmp;
14                 exchange = 1;
15             }
16         }
17         if(exchange == 0)
18             return;
19     }
20 }

选择排序实现：

a.选择排序（非优化）

注：内层每次循环找到最大的值，与外层循环控制的位置进行交换

 1 /////////////////////选择排序
 2 void  SelectSort(SeqList *s)
 3 {
 4     for(size_t i = 0; i < s->size-1;++i)
 5     {
 6         int maxind = i;
 7         for(size_t j = i+1; j < s->size; ++j)
 8         {
 9             if(s->array[j] > s->array[maxind])
10             maxind = j;
11         }
12         //change maxind  and  i;
13         ElemType tmp = s->array[i];
14         s->array[i] = s->array[maxind];
15         s->array[maxind] = tmp;
16     }
17 }

b.选择排序优化：

注：每次内层找到最大，最小两个值，与头尾进行交换，循环次数减少一半

这种情况应当注意的一点是，如果你两边的标记走到中间时，有可能错误，所以会有进入循环先判断，杜绝该问题的存在（12行）

if(s->array[min]>s->array[max])
  {
   ElemType tmp1 = s->array[max];
   s->array[max] = s->array[min];
   s->array[min] = tmp1;
  }

 1 /////////////////////选择排序优化
 2 void  SelectSort_op(SeqList *s)
 3 {
 4     int max = s->size-1;
 5     int min = 0;
 6     //从两端往中间走，比较，循环次数缩小一半
 7     while(max >= min)
 8     {
 9         int maxind = max;
10         int minind = min;
11         //当遇到刚好[6,5]时，尴尬了。兑换
12         if(s->array[min]>s->array[max])
13         {
14             ElemType tmp1 = s->array[max];
15             s->array[max] = s->array[min];
16             s->array[min] = tmp1;
17         }
18         ///找到最大最小值
19         for(int i = min;i<=max;++i)
20         {
21             if(s->array[i]>s->array[maxind])
22             {
23                 maxind = i;
24             }
25             if(s->array[i]<s->array[minind])
26             {
27                 minind = i;
28             }
29         }
30         ///兑换并缩小范围
31         ElemType tmp = s->array[minind];
32         s->array[minind] = s->array[min];
33         s->array[min] = tmp;
34         ElemType tmp1 = s->array[maxind];
35         s->array[maxind] = s->array[max];
36         s->array[max] = tmp1;
37         max--;
38         min++;
39     }
40 }

希望以上功能实现对各位有所帮助，如有何缺陷或者可改进之处欢迎各位大神指正。