1.

 1 int partion(int *a, int low, int high)
 2 {
 3    int  value = a[low];
 4    int  t;
 5 
 6    while (low < high)
 7    {
 8       while( high > low && a[high] >= value)
 9          high--;  //会跳到8行的while去执行，而不是转到10行去执行if语句
10       if(high != low)
11       {
12            t = a[low];
13            a[low] = a[high];
14            a[high] = t;
15       }
16 
17       while(low < high && a[low] <= value)
18         low++;
19       
20       if(low != high)
21       {
22             t = a[low];
23            a[low] = a[high];
24            a[high] = t;
25       }
26    }
27    return low;
28 }

 

2.

 1 /*
 2     IBM <数据结构>上的介绍的比普通冒泡排序方法更快速的冒泡排序方法
 3 */
 4 
 5 # include <c:\turboc2\10-2\ziliao\sort\hh.c>
 6 
 7 /*  该函数用的仍是冒泡排序,唯一不同的是我们加了个标志flag,一旦发现数组
 8 元素没有相互交换,我们就可以提前推出循环,从而节省了时间!
 9 
10 */
11 void sort(int *a, int n)  /* 冒泡升序排序 */
12 {
13     int  i, flag = 1, j;
14     int  temp;
15     
16     i=1;
17     while (flag)
18     {
19         flag = 0;
20         for (j=0; j<n-i; ++j)
21         {
22             if (a[j] > a[j+1])
23             {
24                 temp = a[j];
25                 a[j] = a[j+1];
26                 continue; //会跳去执行++j
27                 a[j+1] = temp;
28                 flag = 1;
29                 break; //会跳出for循环，转去执行32行的break语句
30             } 
31         }
32         break; //2 会跳出while循环
33         ++i;
34     }
35 }
36 
37 
38 main()
39 {
40     clrscr();
41     
42     printf("The array is:\n");
43     prin(a,10);
44     sort(a,10);
45     printf("The sorted array is:\n");
46     prin(a,10);
47     
48     getch();
49     return 0;
50 }
51 
52 /*
53 最后修改于07年正月初四晚上21:15 远通网吧!
54 
55 */

 

3.

 1 /*
 2     2007-5-21    
 3     折半查找算法【递归法来实现】
 4 */
 5 
 6 # include <stdio.h>
 7 
 8 /* 
 9     p指向数组首元素,n表示数足长度, val是待查找的元素,如果找到就返回该元素的下标,否则返回-1表
10     示没有找到 嘿嘿!
11 */
12 int Find(int* p, int low, int high, int val)
13 {
14     int mid = (low + high) / 2;
15     
16     if (low == high)  /* 不会存在low > high 的情况! */
17     {
18         if (p[mid] == val)
19         {
20             return mid;
21         }
22         else
23         {
24             return -1;  
25         }
26     }
27     else
28     {    
29         if (p[mid] < val)
30         {
31             Find(p,mid+1,high,val);
32         }
33         else if (p[mid] > val)
34         {
35             Find(p,low,mid-1,val);
36         }
37         else if (p[mid] == val) /* 最后这个else..if不要漏掉了,当然if (p[mid] == val)也可不写 */
38         {
39             return mid;    
40         }
41     }
42     
43     printf("李四!\n");
44 }
45 
46 
47 
48 void Traverse(int* p, int n)
49 {
50     for (int i=0; i<n; ++i)
51         printf("%-5d",p[i]);
52     
53     printf("\n");
54 }
55 
56 
57 int main(void)
58 {
59     int a[10] = {-10,1,23,54,55,76,88,100,200,9897};
60     
61     puts("原始数组的内容是:");
62     Traverse(a,10);
63     
64     int k = Find(a,0,9,-10);
65     if (-1 == k)
66         printf("没找到该元素!!!\n");
67     else
68         printf("该元素的具体位置是 %d \n",k);
69     
70     return 0;
71 }
72 
73 /*
74     首先要明白,
75     折半查找的前提是数组中的元素已经排好序(无论升序降序都行)
76     
77 */

 

You can do anything you set your mind to, man!