数据结构java实现代码
双向链表
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;
}
}
