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);
}
}
总结：
