簡介

作業：查詢結構與排序方法
作業題目： BST 查詢結構與折半查詢方法的實現與實驗比較
要求編寫程式實現 BST 儲存結構的建立（插入）、刪除、查詢和排序演演算法；實現折半查詢演演算法；比較 BST 查詢與折半查詢方法的時間效能。
作業要求：
- 1．設計 BST 的左右鏈儲存結構，並實現 BST 插入（建立）、刪除、查詢和排序演演算法。
- 2．實現折半查詢演演算法。
- 3．實驗比較：設計併產生實驗測試資料，考察比較兩種查詢方法的時間效能，並與理論結果進行比較。以下具體做法可作為參考：
  - （1）第 1 組測試資料： n=1024 個已排序的整數序列（如 0 至 2048 之間的奇數）；第 2 組測試資料：第 1 組測試資料的隨機序列。
  - （2）以上述兩組測試資料作為輸入，分別建立 BST 查詢結構。
  - （3）編寫程式計算所建的兩棵 BST 的查詢成功和查詢失敗的平均查詢長度（主要是改造 Search 演演算法，對「比較」進行計數），並與理論結果比較。
  - （4）分別以上述 BST 查詢結構的中序遍歷序列作為折半查詢演演算法的輸入，編寫程式分別計算折半查詢的查詢成功和查詢失敗的平均查詢長度，並與理論結果比較。
  - （5）以上實驗能否說明：就平均效能而言， BST 的查詢與折半查詢差不多，為什麼？

關於BST

二元搜尋樹（Binary Search Tree）又稱二叉查詢樹或二叉排序樹。

它是一棵樹，滿足以下性質：

對於任何一個節點，它的左子樹上的所有節點的權值都小於它的權值，它的右子樹上的所有節點的權值都大於它的權值。
不存在權值相等的節點。（不存在重複節點）
BST中最小權值的節點是整棵樹最左下的葉子節點。
BST中最大權值的節點是整棵樹最右下的葉子節點。
將任何一個點看作Root節點，則這個點的左子樹也是BST，右子樹也是BST。

定義

二元搜尋樹實際上是一個二元連結串列，所以它的資料結構定義如下：

typedef struct BST_Node{//二元樹
    int data;//資料
    struct BST_Node *lc, *rc;//左右孩子
}BST_Node, *BST;

搜尋與插入

搜尋與插入是非常相似的，插入就是在做完搜尋後進行插入節點。

這裡需要知道，BST在插入後，新節點一定是葉子節點，不會破壞原有的樹。所以它的邏輯非常簡單。

這裡介紹遞迴版本。

//遞迴查詢二叉排序樹,father為搜尋當前節點的父節點,T為搜尋的當前節點,key為搜尋的關鍵字指標,p指向查詢的結果
Status Search(BST T, BST father, int key, BST *p)
{
    if(!T)//查詢的節點不存在
    {
        *p = father;
        return FALSE;
    }else if(key == T->data)//查詢成功，返回當前節點
    {
        *p = T;
        return TRUE;
    }else if(key < T->data)
    {
        return Search(T->lc, T, key, p);//遞迴左兒子
    }else
    {
        return Search(T->rc, T, key, p);//遞迴右兒子
    }
}

就是利用性質1進行判斷和遞迴。

刪除

如果刪除的節點只有左子樹或只有右子樹或為葉子節點。

如上圖中的1（葉子節點），10（只有左子樹），27（只有右子樹）。

刪除後為：

很明顯，「子承父業」，子樹繼承父節點。這樣仍然是一個BST，這裡用到了性質5。

那如果是刪除的是左右子樹都存在的節點呢？

有兩種方案：

找該節點的前驅替代該節點。
找該節點的後繼替代該節點。

前驅和後繼是什麼呢，這是二元樹的中序遍歷的知識。

在中序遍歷序列中，該節點的前一個就是前驅節點，後一個就是後繼節點。

比如，我們現在要刪除7這個節點。根據中序遍歷，它的前驅是6，後繼是8。

發現了嗎？6和8就是整棵樹最接近7的值。

而中序遍歷是一個嚴格單調遞增的序列！

序列：1 4 6 7 8 10 15 27 35

現在，我們試試這兩種方法：

完全符合BST的性質！

測試資料

第一組測試資料：in1.txt

n=1024 個已排序的整數序列(0 至 2048 之間的奇數)。

點選檢視第一組資料

1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 
33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 
65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 
97 99 101 103 105 107 109 111 113 115 117 119 121 123 125 127 
129 131 133 135 137 139 141 143 145 147 149 151 153 155 157 159 
161 163 165 167 169 171 173 175 177 179 181 183 185 187 189 191 
193 195 197 199 201 203 205 207 209 211 213 215 217 219 221 223 
225 227 229 231 233 235 237 239 241 243 245 247 249 251 253 255 
257 259 261 263 265 267 269 271 273 275 277 279 281 283 285 287 
289 291 293 295 297 299 301 303 305 307 309 311 313 315 317 319 
321 323 325 327 329 331 333 335 337 339 341 343 345 347 349 351 
353 355 357 359 361 363 365 367 369 371 373 375 377 379 381 383 
385 387 389 391 393 395 397 399 401 403 405 407 409 411 413 415 
417 419 421 423 425 427 429 431 433 435 437 439 441 443 445 447 
449 451 453 455 457 459 461 463 465 467 469 471 473 475 477 479 
481 483 485 487 489 491 493 495 497 499 501 503 505 507 509 511 
513 515 517 519 521 523 525 527 529 531 533 535 537 539 541 543 
545 547 549 551 553 555 557 559 561 563 565 567 569 571 573 575 
577 579 581 583 585 587 589 591 593 595 597 599 601 603 605 607 
609 611 613 615 617 619 621 623 625 627 629 631 633 635 637 639 
641 643 645 647 649 651 653 655 657 659 661 663 665 667 669 671 
673 675 677 679 681 683 685 687 689 691 693 695 697 699 701 703 
705 707 709 711 713 715 717 719 721 723 725 727 729 731 733 735 
737 739 741 743 745 747 749 751 753 755 757 759 761 763 765 767 
769 771 773 775 777 779 781 783 785 787 789 791 793 795 797 799 
801 803 805 807 809 811 813 815 817 819 821 823 825 827 829 831 
833 835 837 839 841 843 845 847 849 851 853 855 857 859 861 863 
865 867 869 871 873 875 877 879 881 883 885 887 889 891 893 895 
897 899 901 903 905 907 909 911 913 915 917 919 921 923 925 927 
929 931 933 935 937 939 941 943 945 947 949 951 953 955 957 959 
961 963 965 967 969 971 973 975 977 979 981 983 985 987 989 991 
993 995 997 999 1001 1003 1005 1007 1009 1011 1013 1015 1017 1019 1021 1023 
1025 1027 1029 1031 1033 1035 1037 1039 1041 1043 1045 1047 1049 1051 1053 1055 
1057 1059 1061 1063 1065 1067 1069 1071 1073 1075 1077 1079 1081 1083 1085 1087 
1089 1091 1093 1095 1097 1099 1101 1103 1105 1107 1109 1111 1113 1115 1117 1119 
1121 1123 1125 1127 1129 1131 1133 1135 1137 1139 1141 1143 1145 1147 1149 1151 
1153 1155 1157 1159 1161 1163 1165 1167 1169 1171 1173 1175 1177 1179 1181 1183 
1185 1187 1189 1191 1193 1195 1197 1199 1201 1203 1205 1207 1209 1211 1213 1215 
1217 1219 1221 1223 1225 1227 1229 1231 1233 1235 1237 1239 1241 1243 1245 1247 
1249 1251 1253 1255 1257 1259 1261 1263 1265 1267 1269 1271 1273 1275 1277 1279 
1281 1283 1285 1287 1289 1291 1293 1295 1297 1299 1301 1303 1305 1307 1309 1311 
1313 1315 1317 1319 1321 1323 1325 1327 1329 1331 1333 1335 1337 1339 1341 1343 
1345 1347 1349 1351 1353 1355 1357 1359 1361 1363 1365 1367 1369 1371 1373 1375 
1377 1379 1381 1383 1385 1387 1389 1391 1393 1395 1397 1399 1401 1403 1405 1407 
1409 1411 1413 1415 1417 1419 1421 1423 1425 1427 1429 1431 1433 1435 1437 1439 
1441 1443 1445 1447 1449 1451 1453 1455 1457 1459 1461 1463 1465 1467 1469 1471 
1473 1475 1477 1479 1481 1483 1485 1487 1489 1491 1493 1495 1497 1499 1501 1503 
1505 1507 1509 1511 1513 1515 1517 1519 1521 1523 1525 1527 1529 1531 1533 1535 
1537 1539 1541 1543 1545 1547 1549 1551 1553 1555 1557 1559 1561 1563 1565 1567 
1569 1571 1573 1575 1577 1579 1581 1583 1585 1587 1589 1591 1593 1595 1597 1599 
1601 1603 1605 1607 1609 1611 1613 1615 1617 1619 1621 1623 1625 1627 1629 1631 
1633 1635 1637 1639 1641 1643 1645 1647 1649 1651 1653 1655 1657 1659 1661 1663 
1665 1667 1669 1671 1673 1675 1677 1679 1681 1683 1685 1687 1689 1691 1693 1695 
1697 1699 1701 1703 1705 1707 1709 1711 1713 1715 1717 1719 1721 1723 1725 1727 
1729 1731 1733 1735 1737 1739 1741 1743 1745 1747 1749 1751 1753 1755 1757 1759 
1761 1763 1765 1767 1769 1771 1773 1775 1777 1779 1781 1783 1785 1787 1789 1791 
1793 1795 1797 1799 1801 1803 1805 1807 1809 1811 1813 1815 1817 1819 1821 1823 
1825 1827 1829 1831 1833 1835 1837 1839 1841 1843 1845 1847 1849 1851 1853 1855 
1857 1859 1861 1863 1865 1867 1869 1871 1873 1875 1877 1879 1881 1883 1885 1887 
1889 1891 1893 1895 1897 1899 1901 1903 1905 1907 1909 1911 1913 1915 1917 1919 
1921 1923 1925 1927 1929 1931 1933 1935 1937 1939 1941 1943 1945 1947 1949 1951 
1953 1955 1957 1959 1961 1963 1965 1967 1969 1971 1973 1975 1977 1979 1981 1983 
1985 1987 1989 1991 1993 1995 1997 1999 2001 2003 2005 2007 2009 2011 2013 2015 
2017 2019 2021 2023 2025 2027 2029 2031 2033 2035 2037 2039 2041 2043 2045 2047

第二組測試資料：in2.txt

第 1 組測試資料的隨機序列。

點選檢視第二組資料

83 71 381 1801 1475 729 429 1373 677 1825 1171 995 1507 887 1491 983 
1895 1357 1463 633 1295 537 1661 307 585 189 27 569 525 879 655 445 
871 549 1691 913 135 1399 1303 63 519 1205 1275 531 1137 1611 1087 1211 
1449 1943 2041 1837 2027 1163 1143 1063 1051 1811 1557 57 1975 1637 577 821 
1697 1501 1665 241 1645 507 1061 2029 1341 763 1683 953 347 671 1065 997 
649 1153 1741 417 1239 1417 1121 1391 101 119 835 69 1517 803 315 791 
1973 353 1429 1331 517 1907 1765 1851 147 601 1281 253 1419 427 2003 257 
869 2005 1939 409 1703 383 207 1919 1577 1453 1115 441 1309 717 775 991 
1199 195 2047 211 287 1219 1435 931 1085 1339 313 557 741 1485 59 993 
1695 661 1263 5 431 2001 115 89 679 1597 103 233 317 1561 1001 939 
1343 425 1865 179 1277 107 1951 581 1513 1433 1439 935 1313 145 1959 799 
747 1997 947 571 597 1995 897 1007 87 259 271 1673 541 1215 161 1537 
1731 1307 1917 247 11 43 15 1655 1127 1285 575 561 1249 293 949 201 
681 925 1891 267 637 723 1067 2033 141 213 9 1255 1565 1971 1581 95 
719 721 495 1685 1173 1441 1745 237 1525 1571 785 755 509 165 439 1159 
971 1657 489 1675 945 1105 1047 491 907 705 1147 1839 79 1813 691 1261 
91 929 1413 411 1233 243 1041 641 41 631 725 331 547 593 899 1305 
1363 1559 793 607 483 1323 387 1335 451 1921 1873 1845 335 269 875 1193 
1333 1999 435 1607 1195 1617 217 1347 205 669 963 97 1337 1533 227 831 
1989 1867 453 311 1385 1679 1739 1109 1677 1299 339 1797 757 749 711 1379 
1101 447 1107 1755 197 449 1325 1641 1407 1139 845 639 701 2019 731 1053 
1479 1241 61 1083 919 7 1663 1155 1039 1567 553 1547 567 395 1487 285 
1133 1553 1465 1511 337 1819 471 511 321 235 281 765 743 155 1953 261 
1405 1925 1165 131 599 1817 2037 1633 1279 1505 1359 1805 853 1719 461 1787 
277 55 1019 369 1253 1947 1563 481 137 117 1897 1869 535 33 1177 985 
1689 1035 361 611 341 917 591 667 2025 1267 1103 645 249 1849 1411 1521 
783 65 1095 1225 1905 299 153 1377 283 635 1217 1469 1793 859 529 643 
979 1743 1355 1481 1585 319 1579 1157 1025 77 1021 1955 67 1831 1119 1823 
1301 351 405 735 1551 1859 893 1227 873 617 1043 515 559 1709 397 1937 
1457 23 1297 771 1649 1751 1221 2035 1763 1169 1777 1317 781 1619 1843 1081 
1135 1835 1711 1515 1769 1815 647 1059 1005 1915 1519 881 1729 1245 759 709 
789 1721 1483 1933 903 867 847 149 1259 1759 1031 1237 2015 545 673 1847 
1671 81 493 1853 1283 1635 1351 1841 1057 1023 175 911 891 1543 1791 699 
1727 1129 157 817 1669 1381 1111 1901 1497 965 1699 1789 1969 777 1027 1965 
1091 1799 563 305 1113 1629 1011 889 1941 1321 1123 1887 795 363 1353 801 
1749 129 1017 769 663 1071 215 579 181 469 1393 1459 501 1889 297 1201 
1207 1857 1209 745 683 1957 345 565 1875 1613 183 839 615 883 1131 1809 
209 1883 533 1775 1387 1319 1329 2007 1983 1033 1861 1451 377 239 703 1415 
1311 851 521 35 861 1767 1723 941 139 1967 849 921 539 475 1181 1009 
111 1499 1269 1345 697 1803 797 989 355 779 37 1421 2009 327 13 1125 
371 1627 961 1539 497 837 17 623 1647 503 1509 589 19 245 1707 815 
1573 365 221 1985 1141 959 1979 1397 457 1079 385 707 459 1401 1623 391 
1715 21 29 1045 31 1927 951 1893 203 523 123 359 2043 937 987 915 
51 1151 1931 809 609 1735 1667 455 1467 1713 1461 1183 1949 479 715 1747 
905 863 1725 109 1175 1 173 1631 1289 999 1093 169 1651 751 657 1871 
1149 1029 877 685 443 733 975 1231 543 1575 289 1371 1687 127 1003 675 
605 651 1589 413 379 423 1427 1069 1293 1569 421 367 1389 753 1443 477 
333 1621 927 1473 291 1423 1361 1049 73 767 49 1431 3 713 1549 1287 
1601 583 99 1073 1555 1779 1273 1761 143 1753 1717 2013 1681 957 901 1899 
467 693 1903 1493 193 125 587 219 473 1013 969 1197 407 349 1409 133 
279 2031 1545 1885 1529 1257 1243 1855 1771 923 843 1807 1821 225 75 433 
613 1527 659 1603 1531 329 885 627 827 485 301 1535 265 1583 199 343 
2017 393 813 1963 375 401 1495 1327 1785 555 1877 1863 977 1185 1291 1991 
47 465 1929 415 1625 1733 1145 1615 855 373 1489 527 943 1161 909 1961 
687 865 1075 1099 1455 807 773 1523 1097 357 629 1055 229 829 1783 1203 
177 275 1089 1541 2011 2039 595 933 573 505 45 895 309 273 163 487 
967 727 1503 419 1117 1879 653 295 1445 603 1235 1659 159 811 737 1229 
1977 1737 39 399 1705 2021 263 223 1993 2023 1265 787 185 2045 323 53 
1639 1987 819 1403 167 1773 513 105 1587 1369 1609 1643 1829 1437 625 1923 
1315 1653 463 1447 85 1981 121 231 1935 1189 171 1477 621 1425 1701 1375 
1827 1833 389 1037 665 403 619 93 981 191 325 187 151 825 761 1595 
499 303 1213 1605 1247 1367 805 1781 25 1015 1077 1593 1911 1881 1187 841 
1349 1471 1757 739 1251 1693 1909 973 1271 1191 833 551 1913 1599 251 1395 
113 695 1591 1945 1383 1795 1365 857 1179 955 1223 1167 255 689 823 437

進行查詢的測試資料為 0~2048，共2049個數。

理論分析（第三問和第四問）

BST查詢

test1

有序的序列初始化BST，是一棵斜樹。

可知查詢成功的長度為（1 + 2 + 3 + ··· + n）。n = 1024。

則平均長度為512.5，與執行結果一致。

查詢失敗則為（2 + 3 + ··· + （n + 1） + （n + 1））。n = 1024。

計算得，平均長度為513.99，與執行結果一致。
test2

隨機序列生成的BST的應為分佈較為均勻的二元樹，也就是比較平衡的。

設

\[h=⌊log2(n+1)⌋，r=n−(2^h−1)，v=n−r \]
則平均查詢成功長度

\[S=\frac{1}{n}(\sum_{j = 1}^{h}{j * 2^{j - 1} + r(h + 1)}) \]
化簡得

\[S = \frac{1}{n}(v + 1)\log_{2}{(v + 1)} - v + \frac{1}{n}r(h + 1) \]
若為理想的滿二元樹，即$$n = 2^{h} - 1$$。

則可得平均查詢成功長度為

\[S = \frac{n + 1}{n}log_{2}{(n + 1)} - 1 \]
此時平均查詢失敗長度為 $$log_2(n + 1)$$ 。

考慮到為隨機生成的序列，則執行結果應該比理論值偏大，結果說明，與理論一致。

折半查詢

兩組資料在BST上中序遍歷生成的序列都是0~2048順序的奇數序列，是有序的。

所以兩組測試的折半查詢平均查詢長度相同。

折半查詢的平均查詢長度藉助二元樹來計算。

與上述BST的test2的計算推導過程類似。

平均查詢成功長度約$$S = \frac{n + 1}{n}log_{2}{(n + 1)} - 1$$。

平均查詢失敗長度為 $$log_2(n + 1)$$ 。

直接代入n = 1024，算得理論值約為9.01，10.00。與執行結果一致！

第五問

就一般情況下的平均查詢效能來說，折半查詢與BST的查詢效能差不多。
但是對於特殊的資料，比如連續的已排序好的數，BST的查詢效能會大幅度下降。
而折半查詢卻不會，但這是建立在折半查詢在已排序好的資料上的。我們需要讀入資料後排序，才可以進行折半查詢。
所以，對於有插入和刪除操作的查詢來說，BST的的平均效能還是要比折半查詢優的。

程式碼

點選檢視程式碼

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <ctime>

using namespace std;

#define MAXN 1050
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef struct BST_Node{//二元樹
    int data;//資料
    struct BST_Node *lc, *rc;//左右孩子
}BST_Node, *BST;

typedef int Status;
int bs[MAXN];//中序遍歷序列
int cnt, idx;
//idx 為生成的中序遍歷序列大小，cnt 為查詢次數

Status Search(BST T, BST father, int key, BST *p);//BST遞迴查詢
Status Insert(BST *T, int key);//BST遞迴插入
Status Delete(BST *T, int key);//BST遞迴刪除
void Del(BST *p);//BST刪除
void Traverse(BST T);//BST中序遍歷
void Test(BST T, int a[]);//平均查詢長度的測試
int Binary_Search(int key, int a[], int l, int r);//折半查詢
int main()
{  
    int temp;
    BST t1, t2;
    t1 = t2 = NULL;
    FILE* fp;
    
    fp = fopen("in1.txt", "r");
    if(fp == NULL) exit(1);

    //第一個測試樣例，in1.txt，為0~2048的奇數序列，共1024個
    idx = 0;
    while(fscanf(fp, "%d", &temp) != EOF)
    {
        Insert(&t1, temp);
    }
    Traverse(t1);
    fprintf(stdout, "test<1>:\n");
    Test(t1, bs);

    fp = fopen("in2.txt", "r");
    if(fp == NULL) exit(1);

    //第二個測試樣例，in2.txt，為上一個樣例的一個隨機排列
    idx = 0;
    while(fscanf(fp, "%d", &temp) != EOF)
    {
        Insert(&t2, temp);
    }
    Traverse(t2);
    fprintf(stdout, "test<2>:\n");
    Test(t2, bs);

    fclose(fp);


    return 0;
}
void Test(BST T, int a[])
{
    BST p;
    int cnt1, cnt2;
    int idx1, idx2;

    //BST查詢
    cnt1 = cnt2 = 0;
    idx1 = idx2 = 0;
    for(int i = 0; i <= 2048; i ++ )
    {
        cnt = 0;
        int key = i;
        int res = Search(T, NULL, key, &p);
        if(res == FALSE)
        {
            cnt2 += cnt;
            idx2 ++;
        }else
        {
            cnt1 += cnt;
            idx1 ++;
        }
    }
    fprintf(stdout, "BST: %.2f %.2f\n", cnt1 * 1.0 / idx1, cnt2 * 1.0 / idx2);//計算平均值

    //折半查詢
    cnt1 = cnt2 = 0;
    idx1 = idx2 = 0;
    int l = 0, r = idx - 1;//邊界
    for(int i = 0; i <= 2048; i ++ )
    {
        cnt = 0;
        int key = i;
        int res = Binary_Search(key, a, l, r);
        if(res == -1)//查詢失敗
        {
            cnt2 += cnt;
            idx2 ++;
        }else
        {
            cnt1 += cnt;
            idx1 ++;
        }
    }
    fprintf(stdout, "BS:  %.2f %.2f\n", cnt1 * 1.0 / idx1, cnt2 * 1.0 / idx2);//計算平均值
}
int Binary_Search(int key, int a[],int l, int r)
{

    while(l <= r)
    {
        cnt ++;
        int mid = (l + r) / 2;
        if(a[mid] == key)
        {
            return mid;
        }else if(a[mid] < key)
        {
            l = mid + 1;
        }else
        {
            r = mid - 1; 
        }
    }
    return -1;
}

void Traverse(BST T)
{
    if(T == NULL) return;
    Traverse(T->lc);
    bs[idx ++] = T->data;
    //fprintf(stdout, "%d ", T->data);
    Traverse(T->rc);
}
void Del(BST *p)
{
    BST q, s;
    q = *p;
    if((*p)->lc == NULL)//左孩子為空
    {
        *p = (*p)->rc;
        free(q);
    }else if((*p)->rc == NULL)
    {
        *p = (*p)->lc;
        free(q);
    }else
    {
        s = (*p)->lc;
        while(s->rc != NULL)
        {
            q = s;
            s = s->rc;
        }
        (*p)->data = s->data;
        if((*p) != q)
        {
            q->rc = s->lc;
        }else
        {
            q->lc = s->lc;
        }
        free(s);
    }
    
}
//刪除BST中關鍵字等於key的元素
Status Delete(BST *T, int key)
{
    if(*T == NULL)
    {
        return FALSE;
    }else
    {
        if(key == (*T)->data)
        {
            Del(T);
            return TRUE;
        }else if(key < (*T)->data)
        {
            return Delete(&((*T)->lc), key);
        }else
        {
            return Delete(&((*T)->rc), key);
        }
    }
}

//當二叉排序樹中不存在關鍵字key的元素時
//插入key並返回TRUE，否則返回FALSE 
Status Insert(BST *T, int key)
{
    BST p, s;
    if(!Search(*T, NULL, key, &p))
    {
        s = (BST)malloc(sizeof (BST_Node));
        s->data = key;
        s->lc = s->rc = NULL;

        if(p == NULL)//根節點不存在
        {
            *T = s;
        }else if(key < p->data)//左孩子
        {
            p->lc = s;
        }else//右孩子
        {
            p->rc = s;
        }

        return TRUE;
    }
    return FALSE;
}
//遞迴查詢二叉排序樹,father為搜尋當前節點的父節點,T為搜尋的當前節點,key為搜尋的關鍵字指標,p指向查詢的結果
Status Search(BST T, BST father, int key, BST *p)
{
    cnt ++;
    if(!T)//查詢的節點不存在
    {
        *p = father;
        return FALSE;
    }else if(key == T->data)//查詢成功，返回當前節點
    {
        *p = T;
        return TRUE;
    }else if(key < T->data)
    {
        return Search(T->lc, T, key, p);//遞迴左兒子
    }else
    {
        return Search(T->rc, T, key, p);//遞迴右兒子
    }
}

BST查詢結構與折半查詢方法的實現與實驗比較

簡介