1.查詢的概念

查詢表是由同一型別的資料元素構成的集合，表中每個資料元素均由若干個資料項組成，每個資料項的值稱為該資料元素的關鍵字，其中可以唯一標識一個數據元素的關鍵字稱為主關鍵字，否則稱為次關鍵字。

線性表查詢：線性表查詢分為順序查詢演算法和折半查詢演算法

樹結構查詢

2.順序查詢演算法

  順序查詢的基本思想是，比較目標值與表中的每一個元素的值，如果某個元素的值與目標的值相等，則查詢成功，並返回該資料元素的位置，如果知道標為仍沒有佔到與目標值匹配的元素，則查詢失敗。

package com.wx.datastructure;

public class SequentialSearch {
    public static void main(String[] args)
    {
        int[] data={4,6,3,55,2,8};
        int  finddata=55;
        int len=data.length;
        for (int i=0;i<len;i++)
        {
            if (finddata==data[i])
            {
                System.out.println("查詢成功！");
                break;
            }
            if(i==(len-1))
            {
                System.out.println("查詢失敗！");
            }
        }
    }
}
 

3.折半查詢（線性表必須是有序序列）

  折半查詢，用指定的關鍵字與查詢表中間位置的資料元素的關鍵字做比較，如果二者相等，則查詢成功，否則以中間元素為界，將查詢表分為前後兩個部分，如果中間元素的關鍵字大於給定元素的關鍵字，則在前以字表進行折半查詢，否則在後一子表進行折半查詢，重複上述過程，直到出現匹配的資料元素，則查詢成功，反之，如果直到子表為空時仍未找到，則查詢失敗。

package com.wx.datastructure;

public class BinarySearch {
    public static void main(String[] args)
    {
        int[] data={3,6,7,14,26,32};
        int finddata=32;
        int low=0;
        int len=data.length;
        int high=len-1;
        while (low<=high)
        {
            //計算中間位
            int mid=(low+high)/2;
            if (data[mid]>finddata)
            {
                high=mid-1;
            }
            else if (data[mid]==finddata)
            {
                System.out.println("查詢成功下標位："+mid);
                break;
            }
            else {
                low=mid+1;
            }

        }
    }
}
 

 4.二叉樹查詢 

二叉樹查詢:若它的左子樹非空，則左子樹上所有節點的值均小於根節點的值。

若他的右子樹非空，則右子樹上所有節點的值均大於根節點的值。

左右子樹本身又是一棵二叉查詢樹。

二叉樹查詢的性質：按中序遍歷二叉查詢樹，所得的中序遍歷序列是一個遞增有序序列

 5.構造二叉查詢樹之插入演算法

   比較新節點關鍵字與各子樹根節點的大小關係，如果新節點關鍵字小，則遞迴進入相應根節點的左子樹，直到找到左子樹為空的位置，否則，遞迴進入相應根節點的右子樹，直到找到右子樹為空的位置。

  java程式碼實現二叉樹的新增，刪除元素二叉樹的歷遍實現在我之前的部落格中有，這次修改了部分程式碼，加入新增和刪除的操作，這裡還是把程式碼貼出來

 建立一個TreeNode類，他是樹的一個節點，包含了資料域，左指標域和右指標域

package com.wx.datastructure;
/*
  二叉樹的節點，包含資料域，左指標域和右指標域
 */
public class TreeNode {
    public int data;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int data,TreeNode left,TreeNode right)
    {
        this.data=data;
        this.left=left;
        this.right=right;
    }
    public TreeNode(int value)
    {

        this(value,null,null);
    }
    public TreeNode()
    {
        this(0,null,null);
    }

}

 建立一個二叉樹類

package com.wx.datastructure;

import java.util.ArrayList;
import java.util.List;
/*
  構造一個二叉樹類.
 */
public class TwoForkedTree {
    private List<Integer> datalist=new ArrayList<Integer>();
    public TreeNode root;
    public TwoForkedTree()
    {
        root=null;
    }
    public TwoForkedTree(TreeNode node)
    {
        this.root=node;
    }
    //判斷二叉樹是否為空
    public boolean isEmpty()
    {
        if (root==null)
        {
            return true;
        }
        return false;
    }
    /*
     新增樹的節點,（事先是一棵有序的二叉樹）
     */
    private void addTree(TreeNode rootnode,int data)
    {
          if (rootnode.data>data)
          {     //插入左子樹
                if (rootnode.left==null)
                {
                    TreeNode node = new TreeNode(data);
                    rootnode.left=node;
                }else {
                    addTree( rootnode.left,data);
                }
          }
          else {
                //插入右子樹
              if (rootnode.right==null)
              {
                  TreeNode node=new TreeNode(data);
                  rootnode.right=node;
              }else {
                  addTree(rootnode.right,data);
              }
          }
    }

    /*
    往樹中新增元素
     */
    public void add(int data)
    {
        if (root==null)
        {
            TreeNode node=new TreeNode(data,null,null);
            root=node;
        }else
        {
            addTree(root,data);
        }
    }
    /*
    刪除一個節點,思路：歷遍拿到所有的節點，刪除後重新構造二叉樹
     */
    public void deleteTree(int deletedata)
    {
        if(root==null)
        {
            throw new NullPointerException("二叉樹為空");
        }
        else {
            loadData(root);
            if (!datalist.contains(deletedata))
            {
                throw new NullPointerException("刪除的元素不存在");
            }
            datalist.remove(new Integer(14));
            root=null;
            for (Integer data:datalist)
            {

                add(data);
            }
        }


    }

    /*
    中序遍歷
     */
   private void showTree(TreeNode root)
   {
       if (root.left!=null)
       {
           showTree(root.left);
       }
        System.out.print(root.data+" ");
       if (root.right!=null)
       {
           showTree(root.right);
       }
   }
   /*
   將元素裝載到集合
    */
   private void loadData(TreeNode root)
   {
       if (root.left!=null)
       {
           loadData(root.left);
       }
       datalist.add(root.data);
       if (root.right!=null)
       {
           loadData(root.right);
       }
   }
   public void sequentialTraversal (TreeNode root)
   {
       if(root==null)
       {
           throw new NullPointerException("null");
       }
       else {
           showTree(root);
       }
   }

}

 測試;構造一個如圖所示的二叉樹：

package com.wx.datastructure;
public class TestTwoForkedTree {
    public static void main(String[] args)
    {
        /*
               15
         12          19
     9      14   18      22
         13                   23
         */
        TwoForkedTree forkedTree=new TwoForkedTree();
        forkedTree.add(9);
        forkedTree.add(12);
        forkedTree.add(15);
        forkedTree.add(18);
        forkedTree.add(19);
        forkedTree.add(22);
        forkedTree.add(23);
        forkedTree.add(13);
        forkedTree.add(14);
        System.out.print("中序遍歷");
        //中序遍歷輸出一下
        forkedTree.sequentialTraversal(forkedTree.root);
        System.out.println("");
        System.out.print("新增元素17：");

        forkedTree.add(17);
        forkedTree.sequentialTraversal(forkedTree.root);
        System.out.println("");
        forkedTree.deleteTree(14);
        System.out.print("刪除元素14：");
        forkedTree.sequentialTraversal(forkedTree.root);
    }
}

總結：