KD树复杂实现

最近邻、k紧邻、范围查询

本文采用java对其进行实现，代码中关于Deque<S>双端队列数据结构是本人实现的，

 package LuoSen.DS.Tree.Distance;

/**用具KD树中的临近查询*/

public interface KDDistance<S> {

 /**返回两个数据之间的距离*/

 public double HPointToHPointDistance(S a,S b);

 /**返回指定高维数据指定维度之间的垂直距离*/

 public double HPointToHPointDistanceInIDemision(S a,S b,byte i);

}

package LuoSen.DS.Tree;

public class KDTreeNode<S> {

 /**左子结点*/

 public KDTreeNode<S> left=null;

 /**右子结点*/

 public KDTreeNode<S> right=null;

 /**父结点*/

 public KDTreeNode<S> parent=null;

 /**表示结点是否被删除*/

 public boolean isRemoved=false;

 /**当前所在的维度*/

 public byte i=0;

 /**结点数据*/

 public S data;

 /**默认构造函数*/

 public KDTreeNode() {

 }

 /**根据数据构造*/

 public KDTreeNode(S data) {

 super();

 this.data = data;

 }

 /**是否为叶子节点*/

 public boolean isLeaf(){

 return (left==null&&right==null);

 }

 /**删除树*/

 public void clear()

 {

 left=null;

 right=null;

 isRemoved=false;

 data=null;

 }

 @Override

 public String toString() {

 return ""+data;

 }

}

 

 

package LuoSen.DS.Tree;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import LuoSen.DS.DS.BinaryHeap;

import LuoSen.DS.DS.Deque;

import LuoSen.DS.DS.Stack;

import LuoSen.DS.Exceptions.IllegalParameterException;

import LuoSen.DS.Tree.Distance.KDDistance;

public class KDTree<S> implements Iterable<S> {

 /** 根节点 */

 private KDTreeNode<S> root = null;

 /** 树终结点的数目 */

 private int size = 0;

 /** 树的维度 */

 private int k = 0;

 /** k个维度的比较器列表 */

 private ArrayList<Comparator<S>> cp = null;

 /**计算两个数据之间的距离*/

 private KDDistance<S> kdd=null;

 public KDTree(int k) {

 root = new KDTreeNode<S>();

 root.parent = root;

 this.k = k;

 }

 public ArrayList<Comparator<S>> getCp() {

 return cp;

 }

 public void setCp(ArrayList<Comparator<S>> cp) {

 this.cp = cp;

 }

 public KDDistance<S> getKdd() {

 return kdd;

 }

 public void setKdd(KDDistance<S> kdd) {

 this.kdd = kdd;

 }

 

 public void buildKDTree(List<S> datas) {

 if (datas == null || datas.isEmpty())

 return;

 if (datas.size() == 1) {

 this.insert(datas.get(0));

 return;

 }

 int i = 0;

 Collections.sort(datas, cp.get(i));

 S mid = datas.get(datas.size() / 2 - 1);

 this.insert(mid);

 i++;

 i %= k;

 if (datas.size() >= 2) {

 buildKDTree(datas.subList(0, datas.size() / 2 - 1), i);

 buildKDTree(datas.subList(datas.size() / 2, datas.size()), i);

 } else {

 buildKDTree(datas, i);

 }

 }

 private void buildKDTree(List<S> datas, int i) {

 if (datas == null || datas.isEmpty())

 return;

 if (datas.size() == 1) {

 this.insert(datas.get(0));

 return;

 }

 Collections.sort(datas, cp.get(i));

 S mid = datas.get(datas.size() / 2 - 1);

 this.insert(mid);

 i++;

 i %= k;

 if (datas.size() >= 2) {

 buildKDTree(datas.subList(0, datas.size() / 2 - 1), i);

 buildKDTree(datas.subList(datas.size() / 2, datas.size()), i);

 } else {

 buildKDTree(datas, i);

 }

 }

 /** 插入数据 ,如果data==null返回false,若已存在关键字相同的数据会替换*/

 public boolean insert(S data) {

 if (data == null)

 return false;

 if (size == 0) {

 root.data = data;

 root.i=0;

 root.isRemoved=false;

 size++;

 return true;

 } else {

 return insert(root, data, 0);

 }

 }

 /** 插入数据,如果data==null返回false */

 private boolean insert(KDTreeNode<S> kdtn, S data, int i) {

 KDTreeNode<S> newNode = null;

 if (cp.get(i).compare(data, kdtn.data) < 0) {

 if (kdtn.left == null) {

 newNode = new KDTreeNode<S>(data);

 kdtn.left = newNode;

 newNode.parent = kdtn;

 newNode.i=(byte) (++i%k);

 size++;

 return true;

 } else {

 i++;

 i %= k;

 return insert(kdtn.left, data, i);

 }

 } else if (cp.get(i).compare(data, kdtn.data) > 0) {

 if (kdtn.right == null) {

 newNode = new KDTreeNode<S>(data);

 kdtn.right = newNode;

 newNode.parent = kdtn;

 newNode.i=(byte) (++i%k);

 size++;

 return true;

 } else {

 i++;

 i %= k;

 return insert(kdtn.right, data, i);

 }

 } else {

 if (kdtn.isRemoved) {

 kdtn.data = data;

 kdtn.isRemoved=false;

 size++;

 return true;

 }

 if (this.isEquals(kdtn.data, data)) {

 kdtn.data=data;

 return true;

 } else {

 if (kdtn.left == null) {

 newNode = new KDTreeNode<S>(data);

 kdtn.left = newNode;

 newNode.parent = kdtn;

 newNode.i=(byte) (++i%k);

 size++;

 return true;

 } else {

 i++;

 i %= k;

 return insert(kdtn.left, data, i);

 }

 }

 }

 }

 /** 删除数据 */

 public boolean remove(S data) {

 if (data == null || size == 0)

 return false;

 return remove(root, data, 0);

 }

 /** 删除数据 */

 private boolean remove(KDTreeNode<S> kdtn, S data, int i) {

 if (cp.get(i).compare(data, kdtn.data) < 0) {

 if (kdtn.left == null) {

 return false;

 } else {

 i++;

 i %= k;

 return remove(kdtn.left, data, i);

 }

 } else if (cp.get(i).compare(data, kdtn.data) > 0) {

 if (kdtn.right == null) {

 return false;

 } else {

 i++;

 i %= k;

 return remove(kdtn.right, data, i);

 }

 } else {

 if (this.isEquals(kdtn.data, data)) {

 if (kdtn.isRemoved)

 return false;

 kdtn.isRemoved = true;

 size--;

 if (kdtn.isLeaf()) {

 if (kdtn != root) {

 if (kdtn.parent.left == kdtn)

 kdtn.parent.left = null;

 else

 kdtn.right = null;

 }

 }

 return true;

 } else {

 if (kdtn.left == null) {

 return false;

 } else {

 i++;

 i %= k;

 return remove(kdtn.left, data, i);

 }

 }

 }

 }

 /** 查询对应对数关键字所对应的节点 */

 public KDTreeNode<S> search(S data) {

 if (size == 0 || data == null)

 return null;

 return search(root, data, 0);

 }

 /** 查询对应对数关键字所对应的节点 */

 private KDTreeNode<S> search(KDTreeNode<S> kdtn, S data, int i) {

 if (cp.get(i).compare(data, kdtn.data) < 0) {

 if (kdtn.left == null) {

 return null;

 } else {

 i++;

 i %= k;

 return search(kdtn.left, data, i);

 }

 } else if (cp.get(i).compare(data, kdtn.data) > 0) {

 if (kdtn.right == null) {

 return null;

 } else {

 i++;

 i %= k;

 return search(kdtn.right, data, i);

 }

 } else {

 if (this.isEquals(kdtn.data, data)) {

 if(kdtn.isRemoved)

 return null;

 else

 return kdtn;

 } else {

 if (kdtn.left == null) {

 return null;

 } else {

 i++;

 i %= k;

 return search(kdtn.left, data, i);

 }

 }

 }

 }

 /** 先序遍历KD树，返回迭代器，迭代器中元素为S类型 */

 public Iterator<S> PreOrderTraverse() {

 Deque<S> a = new Deque<S>();

 this.PreOrderTraverse(root, a);

 return new AbstractTreeDataIterator<S>(this, a);

 }

 /** 先序遍历KD树 */

 protected void PreOrderTraverse(KDTreeNode<S> S, Deque<S> a) {

 if (S != null) {

 if(!S.isRemoved)

 a.frontEnQueue(S.data);

 this.PreOrderTraverse(S.left, a);

 this.PreOrderTraverse(S.right, a);

 }

 }

 /** 中序遍历KD树，返回迭代器，迭代器中元素为S类型 */

 public Iterator<S> InOrderTraverse() {

 Deque<S> a = new Deque<S>();

 this.InOrderTraverse(root, a);

 return new AbstractTreeDataIterator<S>(this, a);

 }

 /** 中序遍历KD树 */

 protected void InOrderTraverse(KDTreeNode<S> S, Deque<S> a) {

 if (S != null) {

 this.InOrderTraverse(S.left, a);

 if(!S.isRemoved)

 a.frontEnQueue(S.data);

 this.InOrderTraverse(S.right, a);

 }

 }

 /** 后序遍历KD树，返回迭代器，迭代器中元素为S类型 */

 public Iterator<S> PostOrderTraverse() {

 Deque<S> a = new Deque<S>();

 this.PostOrderTraverse(root, a);

 return new AbstractTreeDataIterator<S>(this, a);

 }

 /** 后序遍历KD树 */

 protected void PostOrderTraverse(KDTreeNode<S> S, Deque<S> a) {

 if (S != null) {

 this.PostOrderTraverse(S.left, a);

 this.PostOrderTraverse(S.right, a);

 if(!S.isRemoved)

 a.frontEnQueue(S.data);

 }

 }

 /** 先序遍历KD树，返回迭代器，迭代器中元素为KDTreeNode类型 */

 public Iterator<KDTreeNode<S>> PreOrderNodeTraverse() {

 Deque<KDTreeNode<S>> a = new Deque<KDTreeNode<S>>();

 this.PreOrderNodeTraverse(root, a);

 return new AbstractTreeNodeDataIterator<KDTreeNode<S>>(this, a);

 }

 /** 先序遍历KD树 */

 protected void PreOrderNodeTraverse(KDTreeNode<S> S, Deque<KDTreeNode<S>> a) {

 if (S != null) {

 if(!S.isRemoved)

 a.frontEnQueue(S);

 this.PreOrderNodeTraverse(S.left, a);

 this.PreOrderNodeTraverse(S.right, a);

 }

 }

 /** 中序遍历KD树，返回迭代器，迭代器中元素为KDTreeNode类型 */

 public Iterator<KDTreeNode<S>> InOrderNodeTraverse() {

 Deque<KDTreeNode<S>> a = new Deque<KDTreeNode<S>>();

 this.InOrderNodeTraverse(root, a);

 return new AbstractTreeNodeDataIterator<KDTreeNode<S>>(this, a);

 }

 /** 中序遍历KD树 */

 protected void InOrderNodeTraverse(KDTreeNode<S> S, Deque<KDTreeNode<S>> a) {

 if (S != null) {

 this.InOrderNodeTraverse(S.left, a);

 if(!S.isRemoved)

 a.frontEnQueue(S);

 this.InOrderNodeTraverse(S.right, a);

 }

 }

 /** 后序遍历KD树，返回迭代器，迭代器中元素为KDTreeNode类型 */

 public Iterator<KDTreeNode<S>> PostOrderNodeTraverse() {

 Deque<KDTreeNode<S>> a = new Deque<KDTreeNode<S>>();

 this.PostOrderNodeTraverse(root, a);

 return new AbstractTreeNodeDataIterator<KDTreeNode<S>>(this, a);

 }

 /** 后序遍历KD树 */

 protected void PostOrderNodeTraverse(KDTreeNode<S> S, Deque<KDTreeNode<S>> a) {

 if (S != null) {

 this.PostOrderNodeTraverse(S.left, a);

 this.PostOrderNodeTraverse(S.right, a);

 if(!S.isRemoved)

 a.frontEnQueue(S);

 }

 }

 /** 判断树种是否存在关键字和data相同的数据结点 */

 public boolean contains(S data) {

 return search(data) != null ? true : false;

 }

 /** 返回KD树的深度 */

 public int getDepth()// 返回KD树的深度

 {

 return this.coutDepth();

 }

 /** 返回KD树节点的数目 */

 public int getNodeNum()// 返回KD树节点的数目

 {

 return size;

 }

 /** 计算KD树的深度 */

 protected int coutDepth() {

 int depth = this.coutDepth(this.root);

 return depth == 0 ? 0 : depth - 1;

 }

 /** 计算KD树的深度 */

 protected int coutDepth(KDTreeNode<S> S) {

 if (S == null)

 return 0;

 int h1 = this.coutDepth(S.left);

 int h2 = this.coutDepth(S.right);

 return (Math.max(h1, h2) + 1);

 }

 /** 删除树 */

 public void clear() {

 root.clear();

 }

 /** 判断KD树是否为空 */

 public boolean isEmpty() {

 if (this.root == null || this.root.data == null)

 return true;

 return false;

 }

 /** 转化为字符串 */

 public void toString(KDTreeNode<S> kdtn, StringBuilder sb) {

 if (kdtn != null) {

 if (!kdtn.isRemoved && kdtn.data != null)

 sb.append(kdtn).append("\n");

 toString(kdtn.left, sb);

 toString(kdtn.right, sb);

 }

 }

 /** 先序转化为字符串 */

 public String toString() {

 StringBuilder sb = new StringBuilder();

 sb.append("树中结点的数目：" + size + "\n");

 toString(root, sb);

 return sb.toString();

 }

 /** 抽象树的数据的迭代器 */

 public static class AbstractTreeDataIterator<S> implements Iterator<S> {

 private Deque<S> D = null;

 private KDTree<S> tree;

 public AbstractTreeDataIterator(KDTree<S> tree, Deque<S> D) {

 this.tree = tree;

 this.D = D;

 }

 @Override

 public boolean hasNext() {

 return !D.isEmpty();

 }

 @Override

 public S next() {

 return D.rearDequeue();

 }

 @Override

 public void remove() {

 S a = D.rearDequeue();

 tree.remove(a);

 }

 }

 /** 抽象树的结点的迭代器 */

 public static class AbstractTreeNodeDataIterator<S> implements Iterator<S> {

 private Deque<S> D = null;

 private KDTree tree;

 public AbstractTreeNodeDataIterator(KDTree tree, Deque<S> D) {

 this.tree = tree;

 this.D = D;

 }

 @Override

 public boolean hasNext() {

 return !D.isEmpty();

 }

 @Override

 public S next() {

 return D.rearDequeue();

 }

 @Override

 public void remove() {

 KDTreeNode a = (KDTreeNode) D.rearDequeue();

 tree.remove(a.data);

 }

 }

 /**判断两个数据的所有关键是否都相等*/

 public boolean isEquals(S a,S b){

 if(a==null||b==null)

 return false;

 for(Comparator<S> c:cp){

 if(c.compare(a, b)!=0)

 return false;

 }

 return true;

 }

 /**最临近查询，首先设置计算节点之间距离的距离计算器

 * @throws IllegalParameterException */

 public S nearest(S data) throws IllegalParameterException{

 if(data==null||size==0)

 return null;

 if(this.kdd==null)

 throw new IllegalParameterException("请先设置计算距离的计算器!");

 BinaryHeap<KDTreeNode<S>> bp=new BinaryHeap<KDTreeNode<S>>(new HPointCP(data));

 nearest(root,data,bp,1);

 return bp.pop().data;

 }

 /**最临近查询，首先设置计算节点之间距离的距离计算器

 * @throws IllegalParameterException */

 public List<S> nearest(S data,int k) throws IllegalParameterException{

 if(data==null||size==0)

 return null;

 if(this.kdd==null)

 throw new IllegalParameterException("请先设置计算距离的计算器!");

 BinaryHeap<KDTreeNode<S>> bp=new BinaryHeap<KDTreeNode<S>>(new HPointCP(data));

 nearest(root,data,bp,k);

 List<S> ll=new LinkedList<S>();

 Stack<S> s=new Stack<S>();

 while(!bp.isEmpty()){

 s.push(bp.pop().data);

 }

 

 for(S sa:s){

 ll.add(sa);

 }

 return ll;

 }

 /**给定半径和原点，索索该范围内所有点

 * @throws IllegalParameterException */

 public List<S> inCircle(S p,double d) throws IllegalParameterException{

 List<S> ll=new LinkedList<S>();

 inCircle(root,p,ll,d);

 return ll;

 }

 /**得到当前结点的上一个同维结点*/

 public KDTreeNode<S> getAboveSameDemisionNode(KDTreeNode<S> kdtn){

 byte i=kdtn.i;

 kdtn=kdtn.parent;

 while(kdtn!=root){

 if(kdtn.i==i){

 return kdtn;

 }

 kdtn=kdtn.parent;

 }

 if(kdtn.i==i)

 return kdtn;

 else

 return null;

 }

 /**最临近查询，首先设置计算节点之间距离的距离计算器

 * @throws IllegalParameterException */

 private void inCircle(KDTreeNode<S> kdtn,S data,List<S> bp,double d) throws

IllegalParameterException{

 if(kdtn!=null){

 double dd=0.0;

 double d1=0.0;

 dd=kdd.HPointToHPointDistance(kdtn.data,data);

 if(dd>d){

 d1=kdd.HPointToHPointDistanceInIDemision

 (data,kdtn.data,kdtn.i);

 if(d1<d){

 inCircle(kdtn.left,data,bp,d);

 inCircle(kdtn.right,data,bp,d);

 }else if(d1==d){

 if(cp.get(kdtn.i).compare(kdtn.data, data)>0){

 inCircle(kdtn.left,data,bp,d);

 }else{

 inCircle(kdtn.right,data,bp,d);

 }

 }else{

 KDTreeNode<S> tn=this.getAboveSameDemisionNode(kdtn);

 if(tn==null){

 if(cp.get(kdtn.i).compare(kdtn.data, data)>0){

 inCircle(kdtn.left,data,bp,d);

 }else{

 inCircle(kdtn.right,data,bp,d);

 }

 }else{

 dd=kdd.HPointToHPointDistanceInIDemision(data,tn.data,tn.i);

 if(d<dd){

 if(cp.get(kdtn.i).compare(kdtn.data, tn.data)>0){

 if(cp.get(kdtn.i).compare(kdtn.data, data)>0){

 inCircle(kdtn.left,data,bp,d);

 }else{

 inCircle(kdtn.right,data,bp,d);

 }

 

 }else{

 if(cp.get(kdtn.i).compare(kdtn.data, data)>0){

 inCircle(kdtn.left,data,bp,d);

 }else{

 inCircle(kdtn.right,data,bp,d);

 }

 }

 }else{

 if(cp.get(kdtn.i).compare(kdtn.data, tn.data)>0){

 inCircle(kdtn.left,data,bp,d);

 }else{

 inCircle(kdtn.right,data,bp,d);

 }

 }

 }

 }

 }else{ 

 if(!kdtn.isRemoved){

 bp.add(kdtn.data);

 }

 inCircle(kdtn.left,data,bp,d);

 inCircle(kdtn.right,data,bp,d);

 }

 }

 }

 /**最临近查询，首先设置计算节点之间距离的距离计算器

 * @throws IllegalParameterException */

 private void nearest(KDTreeNode<S> kdtn,S data,BinaryHeap<KDTreeNode<S>> bp,int

k) throws IllegalParameterException{

 if(kdtn!=null){

 double d=0.0;

 double dd=0.0;

 double d1=0.0;

 if(bp.size()<k){

 if(!kdtn.isRemoved){

 bp.add(kdtn);

 }

 nearest(kdtn.left,data,bp,k);

 nearest(kdtn.right,data,bp,k);

 }else{

 dd=kdd.HPointToHPointDistance(kdtn.data,data);

 d=kdd.HPointToHPointDistance(data,bp.getTopElement().data);

 if(dd>d){

 d1=kdd.HPointToHPointDistanceInIDemision

 (data,kdtn.data,kdtn.i);

 if(d1<d){

 nearest(kdtn.left,data,bp,k);

 nearest(kdtn.right,data,bp,k);

 }else if(d1==d){

 if(cp.get(kdtn.i).compare(kdtn.data, data)>0){

 nearest(kdtn.left,data,bp,k);

 }else{

 nearest(kdtn.right,data,bp,k);

 }

 }else{

 KDTreeNode<S> tn=this.getAboveSameDemisionNode(kdtn);

 if(tn==null){

 if(cp.get(kdtn.i).compare(kdtn.data, data)>0){

 nearest(kdtn.left,data,bp,k);

 }else{

 nearest(kdtn.right,data,bp,k);

 }

 }else{

 dd=kdd.HPointToHPointDistanceInIDemision(data,tn.data,tn.i);

 if(d<dd){

 if(cp.get(kdtn.i).compare(kdtn.data, tn.data)>0){

 if(cp.get(kdtn.i).compare(kdtn.data, data)>0){

 nearest(kdtn.left,data,bp,k);

 }else{

 nearest(kdtn.right,data,bp,k);

 }

 

 }else{

 if(cp.get(kdtn.i).compare(kdtn.data, data)>0){

 nearest(kdtn.left,data,bp,k);

 }else{

 nearest(kdtn.right,data,bp,k);

 }

 }

 }else{

 if(cp.get(kdtn.i).compare(kdtn.data, tn.data)>0){

 nearest(kdtn.left,data,bp,k);

 }else{

 nearest(kdtn.right,data,bp,k);

 }

 }

 }

 }

 }else{ 

 if(!kdtn.isRemoved){

 bp.pop();

 bp.add(kdtn);

 }

 nearest(kdtn.left,data,bp,k);

 nearest(kdtn.right,data,bp,k);

 }

 }

 }

 }

 /**查询在指定范围之内的数据集合region是查询区域*/

 public List<S> queryDataInRegion(KDRegion<S> region){

 List<S> ll=new LinkedList<S>();

 queryDataInRegion(root,region,ll);

 return ll;

 }

 /**查询在指定范围之内的数据集合*/

 private void queryDataInRegion(KDTreeNode<S> kdtn,KDRegion<S> region,List<S>

ll){

 if(kdtn!=null){

 if(!kdtn.isRemoved&&isInRegion(kdtn.data,region)){

 ll.add(kdtn.data);

 }

 if(!region.low[kdtn.i]||cp.get(kdtn.i).compare(kdtn.data,region.start)>=0)

 queryDataInRegion(kdtn.left,region,ll);

 if(!region.high[kdtn.i]||cp.get(kdtn.i).compare(kdtn.data,region.end)<0)

 queryDataInRegion(kdtn.right,region,ll);

 }

 }

 /**判断指定节点是否在指定区域里*/

 public boolean isInRegion(S data,KDRegion<S> r){

 for(int i=0;i<r.low.length;i++){

 if(!r.low[i]&&!r.high[i]){

 continue;

 }else if(!r.low[i]&&r.high[i]){

 if(cp.get(i).compare(data, r.end)>0)

 return false;

 }else if(r.low[i]&&!r.high[i]){

 if(cp.get(i).compare(data, r.start)<0)

 return false;

 }else if(r.low[i]&&r.high[i]){

 if(cp.get(i).compare(data, r.end)>0||cp.get(i).compare(data, r.start)<0)

 return false;

 }

 }

 return true;

 }

 /**判断对应的两个闭区域是否有交集*/

 public boolean isIntercect(KDRegion<S> r1,KDRegion<S> r2){

 for(int i=0;i<cp.size();i++){

 if((cp.get(i).compare(r1.start, r2.start)>0&&cp.get(i).compare(r1.start,

r2.end)<0)

 ||(cp.get(i).compare(r2.start, r1.start)>0

 &&cp.get(i).compare(r2.start, r1.end)<0))

 return true;

 }

 return false;

 }

 /**返回迭代器*/

 @Override

 public Iterator<S> iterator() {

 return this.InOrderTraverse();

 }

  **************************************************************************************************************************************************************

 /**计算高位数据巨臂比较器*/

 public class HPointCP implements Comparator<KDTreeNode<S>>{

 private S data;

 public HPointCP(S a) {

 super();

 this.data = a;

 }

 @Override

 public int compare(KDTreeNode<S> a, KDTreeNode<S> b) {

 double d1=0.0,d2=0.0;

 d1=KDTree.this.kdd.HPointToHPointDistance(data, a.data);

 d2=KDTree.this.kdd.HPointToHPointDistance(b.data,data);

 if(d1<d2)

 return 1;

 else if(d1>d2)

 return -1;

 else

 return 0;

 }

 }

 /**查询在指定范围之内的数据集合s,e分别表示高位区域，low,hight标示对应维度是否有

上下界*/

 public static class KDRegion<S>{

 /**标示左边界*/

 public S start;

 /**标示右边界*/

 public S end;

 /**标示对应维度是否有约束*/

 public boolean []low;

 /**标示对应维度是否有约束*/

 public boolean []high;

 public KDRegion() {

 super();

 }

 public S getS() {

 return start;

 }

 public void setS(S s) {

 this.start = s;

 }

 public S getE() {

 return end;

 }

 public void setE(S e) {

 this.end = e;

 }

 public boolean[] getLow() {

 return low;

 }

 public void setLow(boolean[] low) {

 this.low = low;

 }

 public boolean[] getHigh() {

 return high;

 }

 public void setHigh(boolean[] high) {

 this.high = high;

 } 

 }

}

 

 /*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package LuoSen.DS.DS;

 

import LuoSen.DS.Alg.Util.CreateComparator;

import LuoSen.DS.Exceptions.IllegalParameterException;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

 

/**

 *

 * @author 雒森

 */

/**

 * 基于动态数组实现的二叉堆,根据比较器的结果，决定是大根堆，还是小根堆当比较器的

比较方法

 * >时返回1，=返回0，<返回-1就是小跟堆，,当S是可比较的数据时可以不传入比较器否

则要传入对应的比较器

 */

public class BinaryHeap<S> implements Iterable<S>, Serializable {

  /** 存储数据的动态数组 */

  protected ArrayList<S> data;

  /** 堆中数据的个数 */

  protected int num;

  /** 比较器 */

  protected Comparator<S> cp;

 

  /** 构造函数初始化 */

  public BinaryHeap() {

    data = new ArrayList<S>(100);

    num = 0;

    cp = null;

  }

 

  /** 构造函数初始化 */

  public BinaryHeap(Comparator<S> cp) throws IllegalParameterException {

    data = new ArrayList<S>(100);

    num = 0;

    if (cp == null)

      throw new IllegalParameterException("输入的参数不合法！");

    this.cp = cp;

  }

 

  /** 构造函数初始化 */

  public BinaryHeap(S datas[]) throws IllegalParameterException {

    data = new ArrayList<S>(100);

    num = 0;

    if (datas == null)

      throw new IllegalParameterException("输入的参数不合法！");

    else {

      if (Comparable.class.isAssignableFrom(datas[0].getClass())) {

        CreateComparator<S> cc = new CreateComparator<S>();

        cp = cc.getComparator();

      } else {

        cp = null;

      }

      this.add(datas);

    }

  }

 

  /** 构造函数初始化 */

  public BinaryHeap(S datas[], Comparator<S> cp)

      throws IllegalParameterException {

    data = new ArrayList<S>(100);

    num = 0;

    if (datas == null || cp == null)

      throw new IllegalParameterException("输入的参数不合法！");

    else {

      this.cp = cp;

      this.add(datas);

    }

  }

 

  /** 设置比较器 */

  public void setComparator(Comparator<S> cp) {

    this.cp = cp;

  }

 

  /** 返回比较器 */

  public Comparator<S> getComparator() {

    return cp;

  }

 

  /** 判断堆是否为空 */

  public boolean isEmpty() {

    return num == 0;

  }

 

  /** 返回堆的大小 */

  public int size() {

    return num;

  }

 

  /** 获取列表数据 */

  public List<S> getDatas() {

    return this.data;

  }

 

  /** 返回二叉堆中的第i个数据（i从1开始） */

  public S getIndex(int i) throws IllegalParameterException {

    if (i < 1 || i > num) {

      throw new IllegalParameterException("输入的参数不合法！");

    } else

      return data.get(i);

  }

 

  /** 向上浮动函数 */

  public void shiftUp(int hole) {

    if (hole == 1)

      return;

    S a = this.data.get(hole);

    for (; hole > 1 && cp.compare(a, data.get(hole / 2)) < 0; hole /= 2)

{

      data.set(hole, data.get(hole / 2));

    }

    data.set(hole, a);

  }

 

  /** 向下过滤函数 */

  public void percolateDown(int hole) {

    S a = data.get(hole);

    int child = 0;

    for (; hole * 2 <= num; hole = child) {

      child = hole * 2;

      if (child != num

          && cp.compare(data.get(child + 1),

data.get(child)) < 0) {

        child++;

      }

      if (cp.compare(data.get(child), a) < 0) {

        data.set(hole, data.get(child));

      } else

        break;

    }

    data.set(hole, a);

  }

 

  /** 获取堆顶元素 */

  public S getTopElement() {

    return data.get(1);

  }

 

  /** 向堆中插入元素 */

  public void add(S a) throws IllegalParameterException {

    if (a == null)

      throw new IllegalParameterException("输入的参数不合法！");

    else {

      if (cp == null) {

        if (Comparable.class.isAssignableFrom(a.getClass())) {

          CreateComparator<S> cc = new

CreateComparator<S>();

          cp = cc.getComparator();

        } else {

          cp = null;

        }

      }

      if (cp == null)

        throw new IllegalParameterException("比较器为null值！

");

      ++num;

      if (data.isEmpty())

        data.add((S) new Object());

      while (data.size() < num + 1)

        data.add(a);

      data.set(num, a);

      this.shiftUp(num);

    }

  }

 

  /** 向堆中加入元素 */

  public final void add(S datas[]) throws IllegalParameterException {

    if (datas == null)

      throw new IllegalParameterException("输入的参数不合法！");

    else {

      for (int i = 0; i < datas.length; i++) {

        this.add(datas[i]);

      }

    }

  }

 

  /** 返回迭代器 */

  @Override

  public Iterator<S> iterator() {

    return this.data.listIterator(1);

  }

 

  /** 从堆中弹出顶部元素，并删除 */

  public S pop() {

    if (num <= 0)

      return null;

    S min = data.get(1);

    delete(1);

    return min;

  }

 

  /** 从堆中删除位于i>=1&&i<num好的元素 */

  public S delete(int index) {

    if (index > num || index < 1 || num <= 0)

      return null;

    S a = data.get(index);

    S b = data.get(num);

    data.set(index, data.get(num--));

    if (cp.compare(a, b) > 0)

      this.shiftUp(index);

    else

      this.percolateDown(index);

    return a;

  }

 

  /** 将二叉堆调整为当前大小 */

  public void trimToSize() {

    data.trimToSize();

  }

 

  @Override

  public String toString() {

    StringBuilder a = new StringBuilder("2叉堆中的元素依次为：\n[");

    for (int i = 1; i < num; i++)

      a.append(" ").append(data.get(i)).append(",");

    if (num > 0)

      a.append(data.get(num)).append(" ]");

    else

      a.append("堆为空]");

    return a.toString();

  }

}

 

 

/*

  * To change this template, choose Tools | Templates

  * and open the template in the editor.

  */

 

package LuoSen.DS.AbstractInterface;

 

import java.io.Serializable;

 

/**

  *

  * @author LENOVO

  */

/**抽象迭代器或遍历器接口*/

public interface Iterator<S> extends java.util.Iterator<S> , Serializable

{

    /**返回前一个元素*/

    public S prior();

    /**判断是否存在前一个元素*/

    public boolean hasPrior();                       

}

 

 

 

 

 

 

  /*

  * To change this template, choose Tools | Templates

  * and open the template in the editor.

  */

 

package LuoSen.DS.DS;

 

import LuoSen.DS.AbstractInterface.Iterator;

import java.io.Serializable;

 

/**

  *

  * @author luosen

  */

/**此数据类型为栈和队列中的数据元素类型*/

public class Data<S> implements Iterable<S>,Serializable

{

     /**数据元素可以是任何数据类型*/

    protected S data;//数据元素

    /**当前元素的下一个元素的引用*/

    protected Data<S> next;//当前元素的下一个元素的引用

    /**当前元素的前一个元素的引用*/

    protected Data<S> prior;//当前元素的下一个元素的引用

    /**默认构造函数*/

    public Data()

    {

        this.data=null;

         this.next=null;

        this.prior=null;

    }

    /**设置当前对象的数据*/

    public void setData(S data)

    {

        this.data=data;

    }

     /**返回当前对象的数据*/

    public S getData()

    {

        return this.data;

    }

    /**设置当前对象的下一个结点的引用*/

    public void setNext(Data<S> next)

    {

        this.next=next;

    }

    /**返回当前对象的下一个结点的引用*/

    public Data<S> getNext()

    {

        return this.next;

    }

    /**设置当前对象的前一个结点的引用*/

    public void setPrior(Data<S> prior)

    {

        this.prior=prior;

    }

     /**返回当前对象的前一个结点的引用*/

    public Data<S> getPrior()

    {

        return this.prior;

    }

    /**判断数据是否相等*/

    @Override

    public boolean equals(Object o)

    {

        if(this==o)

            return true;

        if(o==null||!(o instanceof Data))

            return false;

        Data<S> a=(Data<S>)o;

        if(this.data.equals(a.data))

            return true;

        return false;

    }

 

    @Override

    public int hashCode() 

    {

        int hash = 7;

        hash = 71 * hash + (this.data != null ? this.data.hashCode() : 0);

        return hash;

    }

    /**返回遍历器*/

    @Override

    public Iterator<S> iterator()

    {

        Data<S> c=this;

        class DataIterator<S> implements Iterator<S>

        {

            Data<S> cur;

            public DataIterator(Data<S> c)

            {

                cur=c;

            }

            @Override

            public S next()

            {

                cur=cur.getNext();

                return cur.getData();

            }

 

            @Override

            public S prior()

            {

                cur=cur.getPrior();

                return cur.getData();

            }

            @Override

            public boolean hasNext()

            {

                if(cur.getNext()!=null)

                    return true;

                return false;

            }

 

            @Override

            public boolean hasPrior()

            {

                if(cur.getPrior()!=null&&cur.getPrior().getData()!=null)

                    return true;

                return false;

            }

            

            @Override

            public void remove()

            {

                if(cur!=null&&cur.getPrior()!=null)

                {

                    if(cur.getNext()!=null)

                    {

                        cur.getPrior().setNext(cur.getNext());

                        cur.getNext().setPrior(cur.getPrior());

                        cur=cur.getPrior();

                     }

                    else

                    {

                        cur=cur.getPrior();

                        cur.setNext(null);

                    }

                }

                else if(cur!=null&&cur.getPrior()==null&&cur.getData()!=null)

                {

                    cur=null;

                }

            }

        }

        DataIterator<S> iterator=new DataIterator(c);

        return iterator;

    }

    /**将当前对象的字符串表示*/

    @Override

    public String toString()

    {

        String a="";

        a+=this.data;

        return a;

    }

}

 

 

/*

  * To change this template, choose Tools | Templates

  * and open the template in the editor.

  */

 

package LuoSen.DS.DS;

 

import LuoSen.DS.AbstractInterface.Iterator;

import java.io.Serializable;

 

 

/**

  *

  * @author luosen

  */

/**此类型为双向队列*/

public class Deque<S> implements Iterable<S>,Serializable

{

    /**指向对头的引用*/

    protected Data<S> front;//指向对头的引用

     /**指向队尾的引用*/

    protected Data<S> rear;//指向队尾的引用

    /**队列的长度*/

    protected int size;//队列的长度

    /**构造一个空队列*/

    public Deque()//构造一个空队列

    {

                front=new Data<S>();

                rear=front;

                this.front.setNext(null);

                size=0;

    }

    /**返回队列的长度*/

    public int length()//返回队列的长度

    {

                return this.size;

    }

     /**返回指向队首元素的数据,若队为空，返回null*/

    public S getFrontData()//返回指向队首元素的数据

    {

                if(this.front.getNext()==null)

                        return (S) this.front.getNext().getData();

                return null;

    }

     /**返回指向队首元素的引用,若队为空，返回null*/

    public Data<S> getFront()//返回指向队首元素的引用

    {

                return this.front.getNext();

    }

     /**返回指向队尾元素的数据,若队为空，返回null*/

    public S getRearData()//返回指向队尾元素的数据

    {

                return (S) this.rear.getData();

    }

     /**返回指向队尾元素的引用,若队为空，返回null*/

    public Data<S> getRear()//返回指向队尾元素的引用

    {

                return this.rear;

    }

    /**判断队列是否为空，若为空返回true否则返回false*/

    public boolean isEmpty()//判断队列是否为空

    {

                if(this.front==this.rear)

                        return true;

                return false;

    }

    /**销毁队列*/

    public void clear()//销毁队列

    {

                if(this.isEmpty()!=true)

                {

                        this.rear=this.front;

                        this.front.setNext(null);

                        this.size=0;

                        System.gc();

                }

    }

    /**从队尾将数据data进队*/

    public void rearEnQueue(S data)//尾进队

    {

                Data<S> a=new Data<S>();

                if(a==null)

                System.exit(1);

                a.setData(data);

                a.setPrior(rear);

                this.rear.setNext(a);

                this.rear=a;

                this.size++;

    }

    /**从队首将数据data进队*/

    public void frontEnQueue(S data)//前进队

    {

                Data<S> a=new Data<S>();

                if(a==null)

                System.exit(1);

                a.setData(data);

                a.setNext(this.front.getNext());

                if(a.getNext()!=null)

                        a.getNext().setPrior(a);

                else

                        this.rear=a;

            a.setPrior(this.front);

                this.front.setNext(a);

                this.size++;

    }

    /**从队首出队并返回删除的那个数据，若队为空返回null*/

    public S frontDequeue()//前出队并返回删除的那个数据

    {

                if(this.isEmpty()!=true)

                {

                        S a=(S) this.front.getNext().getData();

                        Data<S> b=this.front.getNext();

                        this.front.setNext(b.getNext());

                        if(b.getNext()!=null)

                                b.getNext().setPrior(b.getPrior());

                        else

                                this.rear=this.front;

                        this.size--;

                        return a;

                }

                return null;

    }

    /**从队尾出队并返回删除的那个数据，若队为空返回null*/

    public S rearDequeue()//后出队并返回删除的那个数据

    {

                if(this.isEmpty()!=true)

                {

                        S a=(S) this.getRear().getData();

                        this.rear=this.rear.getPrior();

                        this.rear.setNext(null);

                        this.size--;

                        return a;

                }

                return null;

    }

    /**判断当前队列与队列a是否相等，若相等返回true否则返回false*/

    @Override

    public boolean equals(Object o)

    {

                if(this==o)

                        return true;

                if(o==null||!(o instanceof    Deque))

                        return false;

                Deque<S> a=(Deque<S>)o;

                Data<S> cur1=this.front.getNext();

                Data<S> cur2=a.front.getNext();

                while(cur1!=null&&cur2!=null)

                {

                        if(cur1.getData().equals(cur2.getData())!=true)

                                return false;

                        cur1=cur1.getNext();

                        cur2=cur2.getNext();

                }

                if(cur1==null&&cur2==null)

                        return true;

                return false;

    }

 

    @Override

    public int hashCode() {

                int hash = 3;

                hash = 11 * hash + (this.front != null ? this.front.hashCode() : 0);

                hash = 11 * hash + (this.rear != null ? this.rear.hashCode() : 0);

                hash = 11 * hash + this.size;

                return hash;

    }

    /**返回遍历器*/

    @Override

    public Iterator<S> iterator()

    {

                if(this.front!=null)

                        return this.front.iterator();

                return null;

    }

    /**将队列对象转化为字符串*/

    @Override

    public String toString()//将队列对象转化为字符串

    {

                StringBuilder a=new StringBuilder("队列里的元素从顶到底依次为：\n");

                int i=1;

                Data<S> current=this.front.getNext();

                if(current==null)

                        a.append("此队列为空队列");

                while(current!=null)

                {

                        a.append("\n第").append(i).append("个元素为：").append(current.getData());

                        i++;

                        current=current.getNext();

                }

                return a.toString();

    }

}