查找算法总结之顺序查找、二分查找、静态树查找

 

1. #include <iostream>   
2. using namespace std;  
3.   
4. //顺序查找, 平均查找长度为(n + 1)/2   
5. int search_sq(int array[], int array_len, int key)   
6. {  
7.     for (int i = 0; i < array_len; ++i)  
8.     {  
9.         if (key == array[i])  
10.         {  
11.             return i;  
12.         }  
13.     }  
14.   
15.     return -1;  
16. }  
17.   
18. //二分查找,平均查找查找长度为〖log2 (N+1〗 - 1,但是序列必须是有序的   
19. int search_binary(int array[], int array_len, int key)   
20. {  
21.     int left = 0;  
22.     int right = array_len -1;  
23.       
24.   
25.     while (left <= right)  
26.     {  
27.         int middle = (left + right)/2;  
28.         if (array[middle] == key)  
29.         {  
30.             return middle;  
31.         }  
32.   
33.         else if (array[middle] > key)  
34.         {  
35.             right = middle - 1;  
36.         }  
37.   
38.         else  
39.              left = middle + 1;  
40.   
41.     }  
42.   
43.     return -1;  
44.   
45. }  
46.   
47.   
48. //二叉树查找   
49.   
50. struct BSTreeNode  
51. {  
52.     int data;  
53.     BSTreeNode* left_child;//左孩子   
54.     BSTreeNode* right_child; //右孩子   
55. };  
56.   
57. typedef BSTreeNode* BSTree;   
58.   
59. BSTreeNode* pNode = NULL;  
60. // 根据结点值创建数目   
61. void Create(BSTree& tree, int data)   
62. {  
63.   
64.     if (tree == NULL)  
65.     {  
66.         tree = new BSTreeNode;  
67.         tree->left_child = NULL;  
68.         tree->right_child = NULL;  
69.         tree->data = data;  
70.     }  
71.   
72.     else  
73.     {  
74.         if (tree->data > data)  
75.         {  
76.             Create(tree->left_child, data);  
77.         }  
78.   
79.         else if (tree->data < data)  
80.         {  
81.             Create(tree->right_child, data);  
82.         }  
83.         else  
84.             return;  
85.     }  
86.   
87. }  
88.   
89. //创建二叉树   
90. void CreateBSTree(int array[], int array_len)  
91. {  
92.     for (int i = 0; i < array_len; ++i)  
93.     {  
94.         Create(pNode, array[i]);  
95.     }  
96. }  
97.   
98. //查找树查找,平均查找查找长度为〖log2 (N+1〗 - 1   
99. BSTreeNode* search_binaryTree(BSTree tree, int data)  
100. {  
101.   
102.     if (tree == NULL)  
103.     {  
104.         return NULL;  
105.     }  
106.   
107.     if (tree->data == data)  
108.     {  
109.         return tree;  
110.     }  
111.   
112.     else if (tree->data > data)  
113.     {  
114.         return search_binaryTree(tree->left_child, data);  
115.     }  
116.   
117.     else   
118.          return search_binaryTree(tree->right_child, data);  
119.   
120.   
121. }  
122.   
123.   
124.   
125. int main()  
126. {  
127.   
128.     int a[10] ={2, 5, 1, 8, 9};  
129.     cout<<"顺序查找元素8的位置是:"<<search_sq(a, 5, 8)<<endl;  
130.   
131.     int b[7]  = {1, 2, 3, 3, 5, 6};  
132.   
133.     cout<<"二分查找元素3的位置是:"<<search_binary(b, 7, 3)<<endl;  
134.     CreateBSTree(a, 5);  
135.   
136.     cout<<"二叉树查找是否存在8:";  
137.     CreateBSTree(a, 5);  
138.     BSTreeNode* find = search_binaryTree(pNode, 8);  
139.     cout<<find->data<<endl;  
140.     find = search_binaryTree(pNode, 10);  
141.     if (find == NULL)  
142.     {  
143.         cout<<"不存在10!";  
144.     }  
145.     return 0;  
146.   
147. }