数据结构java实现代码

时间：2019-12-07 11:58:11 阅读：63 评论：0 收藏：0 [点我收藏+]

双向链表

public class Node {

Object o;
Node up;
Node down;
public Object getO() {
  return o;
}
public void setO(Object o) {
  this.o = o;
}
public Node getUp() {
  return up;
}
public void setUp(Node up) {
  this.up = up;
}
public Node getDown() {
  return down;
}
public void setDown(Node down) {
  this.down = down;
}

}

public class SuperList {
Node first;
Node last;
int size;

public void add(Object o) {
  Node n=new Node();
  n.setO(o);

  if(first==null) {
   first=n;
   last=n;
   n.setUp(null);
   n.setDown(null);

  }else {
   last.setDown(n);
   n.setUp(last);
   n.setDown(null);
   last=n;

  }
  size++;

}

public boolean check(int index) {
  if(index<0||index>size) {
   System.out.println("索引出问题");
   return false;
  }
  return true;
}

public int getSize() {
  return size;

}

public Node getNode(int index) {
  boolean b=check(index);
  if(b==false) {
   return null;
  }
  Node n=first;
  for(int i=0;i<index;i++) {
   n=n.getDown();

  }

  return n;
}

public void remove(int index) {
  Node n=getNode(index);
  n.getUp().setDown(n.getDown());
  n.getDown().setUp(n.getUp());

  size--;

}

public void set(int index,Object o) {
  Node n=getNode(index);

  n.setO(o);

}

public Object get(int index) {
  return getNode(index).getO();

}

}

顺序栈实现

public class stack {

Object[] data;
int top=-1;//栈首指针
int max;

stack(){

}
stack(int max){
  this.max=max;
  data=new Object[max];


}
//判断栈是否满
public boolean check() {
  if(top<max-1) {
   return false;
  }
  return true;
}

public void push(Object o) {
  if(check()) {
   System.out.println("栈已经满了，无法继续入栈");
   return;
  }
  top+=1;
  data[top]=o;


}

public Object pop() {
  if(top==-1) {
   System.out.println("栈为空，无法出栈");
   return null;
  }
  Object ob=peek();
  top-=1;
  return ob;
}

public Object peek() {
  return data[top];

}

}

顺序队列实现

public class Queue {
Object[] data;
int front=0;
int rear=0;
int max;

public Queue() {

}
Queue(int max){
  this.max=max;
  data=new Object[max];
}

public boolean isEmpty() {
  if(front==rear) {
   return true;
  }else {
   return false;
  }

}

public int size() {
  return rear-front;

}

public boolean isFull() {
  if(size()==max) {
   return true;
  }
  return false;
}

public Object chudui() {
  if(isEmpty()) {
   System.err.println("对为空，无法出队");
   return null;
  }
  Object o=data[front];

  front+=1;

  return o;


}

public void rudui(Object o) {
  if(isFull()) {
   System.out.println("对已经满了，无法入队");
   return;
  }
  rear+=1;



}

}

循环队列实现

public class xunhuanQueue {
Object[] data;
int front=0;
int rear=0;
int max;

public xunhuanQueue(int max) {
  this.max=max;
  data=new Object[max];

}

public boolean isEmpty() {
  if(rear==front) {
   return true;
  }

  return false;
}

public boolean isFull() {
  if((rear+1)%max==front) {
   return true;
  }

  return false;
}

public int Size() {

  return rear-front;
}

public void rudui(Object o) {
  if(isFull()) {
   System.out.println("队满，无法入队");
   return;
  }
  data[rear]=o;
  rear=(rear+1)%max;


}

public void chudui() {
  if(isEmpty()) {
   System.out.println("队空，无法出队");
   return;
  }
  data[front]=null;
  front=(front+1)%max;


}

}

二叉排序树实现

public class Node {

int o;
Node leftChild;
Node rightChild;
public int getO() {
  return o;
}
public void setO(int o) {
  this.o = o;
}
public Node getLeftChild() {
  return leftChild;
}
public void setLeftChild(Node leftChild) {
  this.leftChild = leftChild;
}
public Node getRightChild() {
  return rightChild;
}
public void setRightChild(Node rightChild) {
  this.rightChild = rightChild;
}

}

public class BinaryTree {

Node root;

public void insert(int o) {
  Node n=new Node();
  n.setO(o);

  if(root==null) {
   n.setLeftChild(null);
   n.setRightChild(null);
   root=n;

  }

  insert(root,n);

}

public void insert(Node parent,Node n) {
  if(parent.getO()==n.getO()) {
   return;
  }

  if(parent.getO()>n.getO()) {
   if(parent.getLeftChild()==null) {
    parent.setLeftChild(n);
   }
   insert(parent.getLeftChild(),n);
   return;
  }

  if(parent.getO()<n.getO()) {
   if(parent.getRightChild()==null) {
    parent.setRightChild(n);
   }
   insert(parent.getRightChild(),n);
   return;
  }
}

public boolean isEmpty() {
  if(root==null) {
   return true;

  }
  return false;
}

public void XianSearch() {
  if(isEmpty()) {
   System.out.println("树为空，无法遍历");
   return ;
  }
  XianSearch(root);

}

public void XianSearch(Node parent) {
  if(parent!=null) {
   System.out.println(parent.getO());
   XianSearch(parent.getLeftChild());
   XianSearch(parent.getRightChild());

  }

}
public void zhongSearch() {
  if(isEmpty()) {
   System.out.println("树为空无法宾利");
   return;
  }
  zhongSearch(root);

}
public void zhongSearch(Node parent) {
  if(parent!=null) {
   zhongSearch(parent.getLeftChild());
   System.out.println(parent.getO());
   zhongSearch(parent.getRightChild());
  }


}
public void houSearch() {
  if(isEmpty()) {
   System.out.println("树为空无法i案例");
   return;
  }
  houSearch(root);

}
public void houSearch(Node parent) {
  if(parent!=null) {
   houSearch(parent.getLeftChild());
   houSearch(parent.getRightChild());
   System.out.println(parent.getO());

  }


}

public void clear() {
  root=null;

}

public int getHeight() {
  if(isEmpty()) {
   return 0;
  }

  return getHeight(root);


}

public int getHeight(Node parent) {
  if(parent!=null) {

   int l=getHeight(parent.getLeftChild());

   int r=getHeight(parent.getRightChild());

   return l>r?l+1:r+1;

  }

  return 0;

}

public int getNodes() {
  if(isEmpty()) {
   System.out.println("树为空");
  }
  return getNodes(root);


}

public int getNodes(Node parent) {
  if(parent!=null) {

   int left=getNodes(parent.getLeftChild());
   int right=getNodes(parent.getRightChild());

   return left+right+1;
  }
  return 0;
}
}

数据结构java实现代码

原文：https://www.cnblogs.com/ttaall/p/12001229.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)