《程序设计实践》读书笔记一

1. 1. 
      
2. #include <stdio.h>
3. 
   
4. #include <string.h>
5. 
   
6. 
   
7. 
   
8. char *flab[] = 
9. 
   
10. {
11. 
    
12.     "actually",
13. 
    
14.     "just",
15. 
    
16.     "quite",
17. 
    
18.     "really",
19. 
    
20.     NULL
21. 
    
22. };
23. 
    
24. 
    
25. 
    
26. // 顺序检索法算法
27. 
    
28. int lookup(char *word,char *array[])
29. 
    
30. {
31. 
    
32.      int i;
33. 
    
34. 
    
35. 
    
36.      for (i =0;array[i]!=NULL;i++)
37. 
    
38.      {
39. 
    
40.          if (strcmp(word,array[i])==0)
41. 
    
42.          {
43. 
    
44.              return i;
45. 
    
46.          }
47. 
    
48.      }
49. 
    
50. 
    
51. 
    
52.      return -1;
53. 
    
54. }
55. 
    
56. 
    
57. 
    
58. int main(int argc, char* argv[])
59. 
    
60. {
61. 
    
62.     printf("%d/n",lookup("quite",flab));
63. 
    
64.     return 0;
65. 
    
66. }
67. 
    
68. 
    
69. 
    
70. typedef struct Nameval Nameval;
71. 
    
72. 
    
73. 
    
74. struct Nameval
75. 
    
76. {
77. 
    
78.      char *name;
79. 
    
80.      int value;
81. 
    
82. };
83. 
    
84. 
    
85. 
    
86. Nameval htmlchars[] =
87. 
    
88. {
89. 
    
90.     "AElig", 0x00c6,
91. 
    
92.     "Aacute", 0x00c1,
93. 
    
94.     "Acirc", 0x00c2,
95. 
    
96.     "zeta", 0x03b6
97. 
    
98. };
99. 
    
100. // 二分检索法源码
101. 
     
102. int lookup2(char *name,Nameval tab[],int ntab)
103. 
     
104. {
105. 
     
106.      int low,high,mid,cmp;
107. 
     
108.      low =0;
109. 
     
110.      high = ntab-1;
111. 
     
112. 
     
113. 
     
114.      while(low<=high)
115. 
     
116.      {
117. 
     
118.          mid = (low+high) /2;
119. 
     
120.          cmp = strcmp(name,tab[mid].name);
121. 
     
122.          if (cmp<0)
123. 
     
124.               high = mid -1;
125. 
     
126.          else if(cmp>0)
127. 
     
128.              low = mid + 1;
129. 
     
130. 
     
131. 
     
132.          else 
133. 
     
134.              return mid;
135. 
     
136. 
     
137. 
     
138.      }
139. 
     
140. 
     
141. 
     
142.      return -1;
143. 
     
144. }
145. 
     
146. 
     

     二分检索只能用在元素已经排好序的数组上。如果需要对某个数据集反复进行检索，先把它排序，然后再用二分检索就会是很值得的。如果数据集事先已经知道，写程序时就可以直接将数据排好序，利用编译时的初始化构建数组。

最好的排序算法之一是快速排序（quicksort）。快排的工作方式是：

从数组中取出一个元素（基准值）。

把其他元素分为两组：

“小的”是那些小于基准值的元素；

“大的”是那些大于基准值的元素。

递归地对这两个组做排序。

快排算法的一种实现如下：

1. 1. 
      
2. void quicksort(int v[],int n)
3. 
   
4. {
5. 
   
6.       int i,last;
7. 
   
8.       if(n<=1)
9. 
   
10.           return;
11. 
    
12.     // 随机抽取数组的元素作为基准元素，并将它和第一个元素交换
13. 
    
14.       swap(v,0,rand()%n);
15. 
    
16.     last = 0; // 用于保存基准元素应该放置的位置
17. 
    
18. 
    
19. 
    
20.     // 以基准元素为界，将数组元素分为两组
21. 
    
22.     for (i = 0;i<n;i++)
23. 
    
24.     {
25. 
    
26.          if (v[i]<v[0])
27. 
    
28.          {
29. 
    
30.               swap(v,++last,i);
31. 
    
32.          }
33. 
    
34.     }
35. 
    
36. 
    
37. 
    
38.     // 将基准元素放在数组准确的位置中
39. 
    
40.     swap(v,0,last);
41. 
    
42.     // 对数组的前一部分进行快速排序
43. 
    
44.     quicksort(v,last);
45. 
    
46.     // 对数组的后一部分进行快速排序
47. 
    
48.     quicksort(v+last+1,n-last-1);
49. 
    
50. 
    
51. 
    
52. }
53. 
    
54. 
    

这时我脑海中产生的一个问题是:在一般情况下采用快排+二分检索是不是就比顺序检索快呢？思考：使用循环方式实现快排算法。