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