2. 程式人生 > >查詢演算法（二叉搜尋樹查詢，二分查詢，hash查詢）

查詢演算法（二叉搜尋樹查詢，二分查詢，hash查詢）

阿新 • • 發佈：2019-01-22

這個是在連結串列基礎上根據實驗內容然後添加了一個二分查詢的功能：

二分查詢在競賽極其開發中極其有用，尤其是二分的思想！！！

[cpp] view plain copy print?
  1. usingnamespace std;  
  2. constint Dafultsize = 10;  
  3. enum Error_code{success, overflow, underflow, Range_error, faild};  
  4. template<class List_entry>  
  5. class List{  
  6.   public:  
  7.       List(int Size = Dafultsize):Max_list(Size), num(0){  
  8.         Entry = new List_entry[Max_list];  
  9.       }  
  10.       int Size_list()const;  
  11.       bool Full_list()const;  
  12.       bool Empty_list()const;  
  13.       void Clear();  
  14.       void Print_list()const;  
  15.       void Tra_list(void (*visit)(List_entry &));  
  16.       Error_code retrieve(int postion,  List_entry &item)
    const;  
  17.       Error_code Replace(int postion, const List_entry &item);  
  18.       Error_code Remove(int postion,  List_entry &item);  
  19.       Error_code Insert(int postion, const List_entry &item);  
  20.       ~List(){  
  21.          delete []Entry;  
  22.       }Error_code Binary_search(const List_entry &key, List_entry &position);  
  23.   protected:  
  24.       int num;  
  25.       List_entry  *Entry;  
  26.       int Max_list;  
  27. };  
  28. template<class List_entry>  
  29. int List<List_entry>::Size_list()const{  
  30.   return num ;  
  31. }  
  32. template<class List_entry>  
  33. bool List<List_entry>::Full_list()const{  
  34.    return num == Max_list - 1;  
  35. }  
  36. template<class List_entry>  
  37. bool List<List_entry>::Empty_list()const{  
  38.    return num == 0;  
  39. }  
  40. template<class List_entry>  
  41. void List<List_entry>::Clear(){  
  42.    num = 0;  
  43. }  
  44. template<class List_entry>  
  45. Error_code List<List_entry>::Insert(int position, const List_entry &item){  
  46.     if(Full_list()){  
  47.         return overflow;  
  48.     }  
  49.     if(position < 0 || position > num){  
  50.         return Range_error;  
  51.     }  
  52.     for(int i = num - 1; i >= position; i--){  
  53.         Entry[i + 1] = Entry[i];  
  54.     }  
  55.     Entry[position] = item;  
  56.     num++;  
  57.     return success;  
  58. }  
  59. template<class List_entry>  
  60. void List<List_entry>::Tra_list(void(*visit)(List_entry &)){  
  61.    for(int i = 0; i < num; i++){  
  62.         (*visit)(Entry[i]);  
  63.    }  
  64. }  
  65. template<class List_entry>  
  66. Error_code List<List_entry>::retrieve(int position,  List_entry &item)const{  
  67.     if(Full_list()){  
  68.         return underflow;  
  69.     }  
  70.     if(position < 0 || position > num){  
  71.         return Range_error;  
  72.     }  
  73.     item = Entry[position];  
  74.     return success;  
  75. }  
  76. template<class List_entry>  
  77. Error_code List<List_entry>::Replace(int position, const List_entry &item){  
  78.     if(position > num || position < 0){  
  79.         return Range_error;  
  80.     }  
  81.    Entry[position] = item;  
  82.    return success;  
  83. }  
  84. template<class List_entry>  
  85. Error_code List<List_entry>::Remove(int position,  List_entry &item){  
  86.    if(Empty_list()){  
  87.     return underflow;  
  88.    }  
  89.    if(position < 0 || position > num){  
  90.         return Range_error;  
  91.     }  
  92.     item = Entry[position];  
  93.    for(int i = position;i < num; i++){  
  94.        Entry[i] = Entry[i + 1];  
  95.    }  
  96.    num--;  
  97.    return success;  
  98. }  
  99. template<class List_entry>  
  100. void List<List_entry>::Print_list()const{  
  101.     cout<<"| ";  
  102.    for(int i = 0; i < num; i++){  
  103.     cout<<Entry[i];  
  104.     if(i != num - 1){  
  105.         cout<<" -- ";  
  106.     }  
  107.    }  
  108.    cout<<" |"<<endl;  
  109. }  
  110. template<class List_entry>  
  111. Error_code List<List_entry>:: Binary_search(const List_entry & key, List_entry &position){  
  112.       List_entry low, high, mid;  
  113.       low =0; high = this -> Size_list() - 1;  
  114.       while(low <= high){  
  115.         mid = (low + high) / 2;  
  116.         if(key < Entry[mid]){  
  117.             high = mid - 1;  
  118.         }  
  119.         elseif(key > Entry[mid]){  
  120.             low = mid + 1;  
  121.         }  
  122.         else{  
  123.            position = mid;  
  124.             return success;  
  125.         }  
  126.       }  
  127.       return faild;  
  128. }  

Text.cpp:

[cpp] view plain copy print?
  1.   #include<iostream>
  2.     #include"a.h"
  3.     usingnamespace std;  
  4.     int main()  
  5.     {  
  6.         List<int>list_1(9);  
  7.         for(int i = 1; i <= 5; i++){  
  8.             list_1.Insert(i - 1, i);  
  9.         }  
  10.         int x;  
  11.         list_1.Print_list();  
  12.         cout<<list_1.Size_list()<<endl;  
  13.         list_1.retrieve(1, x);  
  14.         cout<<x<<endl;  
  15.         list_1.Replace(2, 100);  
  16.         list_1.Print_list();  
  17.         list_1.Remove(3, x);  
  18.         list_1.Print_list();  
  19.         list_1.Clear();  
  20.         list_1.Print_list();  
  21.         // 二分查詢部分
  22.         for(int i = 1; i <= 5; i++){  
  23.             list_1.Insert(i - 1, i);  
  24.         }  
  25.         cout<<"二分查詢檢測：\n原資料：\n"<<endl;  
  26.         list_1.Print_list();  
  27.         cout<<"input value what you want to find:\n";  
  28.         cin>>x;  
  29.         int  position;  
  30.         list_1.Binary_search(x, position);  
  31.         cout<<"positon : "<<x<<endl;  
  32.         return 0;  
  33. }  

二叉搜尋樹的實現:

這裡使用了二級指標來操作，函式傳引數的時候傳的是二級指標，二級指標的值是一級指標的地址，指向的值是一級指標的值，通過傳遞二級指標來操作一級指標的值，進而可以改變一級指標的指向內容。如果我們在函式中傳遞的是一級指標，那麼就會出線傳遞的是一級指標的拷貝，函式就不會改變外部指標的指向內容。尤其應用在尋找插入點的時候的定位操作！！！然後中序遍歷列印。

[cpp] view plain copy print?
  1.     #include<iostream>
  2.     #include<stdio.h>
  3.     #include<stdlib.h>
  4.     usingnamespace std;  
  5.     typedefstruct BiTNode{  
  6.      int data;  
  7.      struct BiTNode *lchild, *rchild;  
  8. }BiTNode, *BiTree;  
  9. // 二叉搜尋樹實現
  10. bool SearchBST(BiTree T, int key, BiTree f, BiTree *p){  
  11.   if(!T){  
  12.     *p = f;  
  13.     returnfalse;  
  14.   }  
  15.   elseif(key == T -> data){  
  16.     *p  = T;  
  17.     returntrue;  
  18.   }  
  19.   elseif((key < T -> data)){  
  20.     return SearchBST(T -> lchild, key, T, p);  
  21.   }  
  22.   else{  
  23.     return SearchBST(T -> rchild, key, T, p);  
  24.   }  
  25. }  
  26. //二叉排序樹的插入操作
  27. bool InsertBST(BiTree *T, int key){  
  28.    BiTree p, s;  
  29.    if(!SearchBST(*T, key, NULL, &p)){  
  30.         s = (BiTree)malloc(sizeof(BiTNode));  
  31.         s -> data = key;  
  32.         s -> lchild = s -> rchild = NULL;  
  33.         if(!p){  
  34.             *T = s;  
  35.         }  
  36.         elseif(key < p -> data){  
  37.             p -> lchild = s;  
  38.         }  
  39.         else{  
  40.             p -> rchild = s;  
  41.         }  
  42.         returntrue;  
  43.    }  
  44.    else
  45.     returnfalse;  
  46. }  
  47. bool Delete(BiTree *p){  
  48.    BiTree q, s;  
  49.    if((*p) -> rchild == NULL){  
  50.     q = *p;  
  51.     *p = (*p) -> lchild;  
  52.     delete q;  
  53.    }  
  54.    elseif((*p) -> lchild == NULL){  
  55.     q = *p;  
  56.     *p = (*p) -> rchild;  
  57.     delete q;  
  58.    }  
  59.    else{  
  60.     q = *p;  
  61.     s = (*p) -> lchild;  
  62.     while(s -> rchild){  
  63.         q = s;  
  64.         s = s -> rchild;  
  65.     }  
  66.     (*p) -> data = s -> data;  
  67.     if(q != *p){  
  68.         q -> rchild = s -> lchild;  
  69.     }  
  70.     else{  
  71.         q -> lchild = s -> lchild;  
  72.     }  
  73.     delete s;  
  74.    }  
  75.    returntrue;  
  76. }  
  77. bool DeleteBST(BiTree *T, int key){  
  78.     if(! *T){  
  79.         returnfalse;  
  80.     }  
  81.     else{  
  82.         if(key == (*T) -> data){  
  83.             return Delete(T);  
  84.         }  
  85.         elseif(key < (*T) -> data){  
  86.             return DeleteBST(&(*T) -> lchild, key);  
  87.         }  
  88.         else{  
  89.             return DeleteBST(&(*T) -> rchild, key);  
  90.         }  
  91.     }  
  92. }  
  93. //中序遍歷演算法，列印二叉排序樹
  94. void InOrderTraverse(BiTree T){  
  95.    if(T == NULL){  
  96.     return ;  
  97.    }  
  98.    InOrderTraverse(T -> lchild);  
  99.    printf("--%d -- ", T -> data);  
  100.    InOrderTraverse(T -> rchild);  
  101. }  
  102.     int main()  
  103.     {  
  104.         BiTNode cnt;  
  105.         cnt.data = 89;  
  106.         cnt.lchild = cnt.rchild = NULL;  
  107.         BiTree T , t;  
  108.        t = T = &cnt;  
  109.        //插入：
  110.        cout<<"input 8 numbers what you want to insert:\n";  
  111.         for(int i = 0; i < 8; i++){  
  112.                 int x;cin>>x;  
  113.             InsertBST(&T, x);  
  114.         }  
  115.         InOrderTraverse(t);  
  116.         //查詢
  117.         cout<<"\ninput value what you want to find"<<endl;  
  118.         int x;  
  119.         cin>>x;  
  120.         t = &cnt;  
  121.         BiTree p, s;  
  122.         p = NULL;  
  123.         SearchBST(t, x, p, &s);  
  124.         cout<<(s) -> data<<endl;  
  125.         // 刪除搜尋樹結點
  126.         cout<<"input node what you want to delete:\n"<<endl;  
  127.         t = &cnt;  
  128.         cin>>x;  
  129.         DeleteBST(&t, x);  
  130.         InOrderTraverse(t);  
  131.         return 0;  
  132.     }  

Hash拉鍊實現查詢：

測試程式為數字去重，輸出部分包括數字不同的個數，並打印出去重後的序列。

[cpp] view plain copy print?
  1. #include<iostream>
  2. #include<sstream>
  3. #include<algorithm>
  4. #include<cstdio>
  5. #include<string.h>
  6. #include<cctype>
  7. #include<string>
  8. #include<cmath>
  9. #include<vector>
  10. #include<stack>
  11. #include<queue>
  12. #include<map>
  13. #include<set>
  14. usingnamespace std;  
  15. constint M = 1007;  
  16. struct Node{  
  17.     int d;  
  18.     Node * next ;  
  19. };  
  20. Node * pnd[M + 1];  
  21. Node nd[M +1];  
  22. int n_cnt;  
  23. int a[1000 + 18];  
  24. int a_cnt;  
  25. int main(){  
  26.     int n, d, p;  
  27.     while(scanf("%d",&n) != EOF){  
  28.          memset(pnd, 0, sizeof(pnd));  
  29.   n_cnt = 0;  
  30.   a_cnt = 0;  
  31. for(int i = 0; i < n; i++){  
  32.     scanf("%d",&d);  
  33.     p = d % M;  
  34.     bool found = false ;  
  35.     Node *pt = pnd[p];  
  36.     while(pt){  
  37.         if(pt -> d == d){  
  38.             found = true;  
  39.             break;  
  40.         }  
  41.         pt = pt -> next;  
  42.     }  
  43.     if(!found){  
  44.         nd[n_cnt].d = d;  
  45.         nd[n_cnt].next = pnd[p];  
  46.         pnd[p] = &nd[n_cnt];  
  47.         n_cnt ++;  
  48.         a[a_cnt++] = d;  
  49.     }  
  50. }  
  51. sort(a, a + a_cnt);  
  52. printf("%d\n%d", a_cnt, a[0]);  
  53. for(int  i = 1; i < a_cnt; ++i){  
  54.     printf(" %d",a[i]);  
  55. }  
  56. printf("\n");  
  57.     }  
  58. return 0;  
  59. } 

相關推薦

查詢演算法（二叉搜尋樹查詢，二分查詢，hash查詢）

這個是在連結串列基礎上根據實驗內容然後添加了一個二分查詢的功能： 二分查詢在競賽極其開發中極其有用，尤其是二分的思想！！！ [cpp] view plain copy print? usi

資料結構與演算法之二叉搜尋樹插入、查詢與刪除

1 二叉搜尋樹（BSTree）的概念 　　二叉搜尋樹又被稱為二叉排序樹，那麼它本身也是一棵二叉樹，那麼滿足以下性質的二叉樹就是二叉搜尋樹，如圖： 若左子樹不為空，則左子樹上所有節點的值都小於根節點的值； 若它的右子樹不為空，則它的右子樹上所有節點的值都大於

二叉搜尋樹的基本操作 ---- 插入，刪除，查詢，銷燬，遍歷

首先來看看二叉搜尋樹的概念 二叉搜尋樹又稱二叉排序樹，它或者是一棵空樹，或者是具有以下性質的二叉樹 若它的左子樹不為空，則左子樹上所有節點的值都小於根節點的值 若它的右子樹不為空，則右子樹上所有節點的值都大於根節點的值 它的左右子樹也分別為二叉搜尋樹

二叉搜尋樹(BST)的建立、插入、查詢和刪除

樹的結構體定義 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 插入 因為二叉搜

Java查詢演算法(四): 二叉排序樹

[ 為什麼使用二叉排序樹 ]  如果查詢的資料集是有序線性表，並且是順序儲存的，查詢可以用折半、插值等查詢演算法來實現，但是因為有序，在插入和刪除操作上，需要耗費大量的時間。 因為二叉排序樹使用連結的方式儲存，在執行插入或刪除操作時不用移動元素，所以插入刪除的時間效能

中英互譯詞典（二叉搜尋樹）

一、BSTree.h #ifndef __BSTREE_H__ #define __BSTREE_H__ #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <

劍指offer系列（十一）二叉搜尋樹與雙向連結串列， 字串的排序

二叉搜尋樹與雙向連結串列 題目描述 輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的結點，只能調整樹中結點指標的指向。 解題思路： 由於輸入的一個二叉搜尋樹，其左子樹小於右子樹的值，這位後面的排序做了準備，因為只需要中序遍歷即可，將所有 的節點儲存

劍指Offer 62. 二叉搜尋樹的第k個結點 （二叉搜尋樹）

題目描述 給定一棵二叉搜尋樹，請找出其中的第k小的結點。例如， （5，3，7，2，4，6，8）    中，按結點數值大小順序第三小結點的值為4。 例如， 5 / \ 3 7 / \ / \ 2 4 6 8 中，按結點數值大小順序第三個結點的值為4。 題目地址 https:

pat-A1043:Is it a Binary Search Tree（二叉搜尋樹和及其映象樹的遍歷）

目錄 題目解釋： 解題思路： ac程式碼： 題目地址：https://pintia.cn/problem-sets/994805342720868352/problems/994805440976633856 題目解釋： 給出一個二叉樹的序列，判斷它是否是“二叉搜尋樹

劍指Offer 26. 二叉搜尋樹與雙向連結串列 （二叉搜尋樹）

題目描述 輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的結點，只能調整樹中結點指標的指向。 題目地址 https://www.nowcoder.com/practice/947f6eb80d944a84850b0538bf0ec3a5?tpId=13&tqId=1

演算法導論——二叉搜尋樹

二叉搜尋樹是以一個二叉樹來組織的，樹的每個節點都是由鍵值value，父節點parent，左子節點left_child，右子節點right_child組成的，而且二叉搜尋樹的節點間滿足以下的關係：假設x是二叉搜尋樹中的一個節點，如果y是x左子樹中的一個節點，那麼y的value是比x的value小；如果

二叉排序樹（二叉搜尋樹）

題目大意：現在給你N個關鍵字值各不相同的節點，要求你按順序插入一個初始為空樹的二叉排序樹中，每次插入後成功後，求相應的父親節點的關鍵字值，如果沒有父親節點，則輸出-1。 九度OJ連結：http://ac.jobdu.com/problem.php?pid=1467 分析：二

二叉搜尋樹與雙向連結串列，Python實現

class ListNode: def __init__(self, x): self.val = x self.next = None class TreeNode: def __init__(self, x):

二叉排序樹（Binary Sort Tree，二叉查詢樹，二叉搜尋樹）--【演算法導論】

今天的收穫就是二叉搜尋樹，“好記性不如爛筆頭”，寫下來加深一下印象； 1、首先是瞭解了二叉搜尋樹（Binary Sort Tree）又稱二叉查詢樹，亦稱二叉排序樹。 若它的左子樹不空，則左子樹上所有結點的值均小於它的根結點的值； 若它的右子樹不空，則右子樹上所有結點的值均

【模板】二叉搜尋樹（二叉排序樹，二叉查詢樹，BST）

二叉搜尋樹其實就是滿足左結點小於根，右結點大於根這類規則的樹形結構。  1 int n; 2 int a[MAX_N]; 3 int lt[MAX_N], rt[MAX_N]; 4 // 沒有則為-1 5 // 預設a[0]為根結點 6 7 void Insert(int

二叉搜尋樹的最小節點絕對值之差/在二叉查詢樹中尋找兩個節點，使它們的和為一個給定值/找出 BST 中的所有眾數（出現頻率最高的元素）。

關於二叉樹的數值運算，一般考慮借用中序遍歷為陣列；再進行計算的思想。 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; *

查詢演算法之——二叉查詢樹（圖文分析）

1 package Unit3; 2 3 import java.util.Stack; 4 5 import edu.princeton.cs.algs4.Queue; 6 7 public class BST<Key extends Comparab

【演算法】【python實現】二叉搜尋樹插入、刪除、查詢

二叉搜尋樹 定義：如果一顆二叉樹的每個節點對應一個關鍵碼值，且關鍵碼值的組織是有順序的，例如左子節點值小於父節點值，父節點值小於右子節點值，則這棵二叉樹是一棵二叉搜尋樹。 類（TreeNode）：定義二叉搜尋樹各個節點 在該類中，分別存放節點本身的值，以及其左子節點，右子節點，父節點的值。   clas

二叉搜尋樹的查詢、插入與刪除操作（Binary Search Tree, Search, Insert, Delete）（C++）

一、概念     設 x 是二叉搜尋樹中的一個結點。如果 y 是 x 左子樹中的一個結點，那麼 y.key ≦ x.key。如果 y 是 x 右子樹中的一個結點，那麼 y.key ≧ x.key。  

二叉搜尋樹Java實現（查詢、插入、刪除、遍歷）

1 class Node { 2 int key; 3 int value; 4 Node leftChild; 5 Node rightChild; 6 7 public Node(int key, int value) { 8