java中简单的数据结构实现

package com.day10;
import java.util.Arrays;
import java.util.LinkedList;
public class DataStructure{
    public static void main(String[] args) {
        //1.1数组栈
        // Arraystack<String> stack=new Arraystack<>();
        //1.2链栈
        //    LinkStack<String> stack=new LinkStack<>();
        //1.3LinkedList实现栈
        //  LinkedListStack<String> stack=new LinkedListStack<>();
        //2.LinkedList实现队列
        LinkedListQueue<String> stack=new LinkedListQueue<>();
        System.out.println(stack.peek());
        System.out.println(stack.isEmpty());
        stack.push("java");
        stack.push("is");
        stack.push("beautiful");
        stack.push("language");
        System.out.println(stack.pop());
        System.out.println(stack.peek());
        System.out.println(stack.isEmpty());
        //4.顺序表（数组）
//        Myarray myarray=new Myarray();
        //5.二叉树实现添加、遍历排序
        Bintree bintree=new Bintree();
        bintree.add(8);
        bintree.add(3);
        bintree.add(1);
        bintree.add(10);
        bintree.add(9);
        bintree.print();
    }
}
//数据结构，1.栈，增删查，长度，遍历
//实现栈的方式有很多种，用数组或者用链表或者用集合里面的LinkedList实现栈
interface MyStack<T>{//接口
    boolean isEmpty();//抽象方法，判断空
    T peek();//抽象方法，获取栈顶元素
    void push(T t);//抽象方法，压栈
    T pop();//抽象方法，出栈
}
/**
 * 1.1数组实现栈
 * @param <T>
 */
class Arraystack<T> implements MyStack<T>{//采用先赋值，再++的方式，指向下一个
    //实现栈的数组
    private Object[] stack;
    //数组大小,这个size一开始的指向可以是-1，也可以是0，看你怎么实现啦
    private int size;//全局变量 和 static变量,int类型初始化为0，局部变量需要自己赋值，否则会报错。
    //  private int size=-1;
    Arraystack() {
        stack = new Object[10];//初始容量为10
    }

    public boolean isEmpty(){//判断是否为空
        return size==0;
    }

    public T peek(){//获取栈顶元素
        T t=null;
        if(size>0){
            t=(T)stack[size-1];
        }
        return t;
    }

    public void push(T t){//压栈,压栈前先判断是否够容量
        expandCapacity(size+1);//加1是为了判断下一个有空间
        stack[size]=t;
        size++;//指针指向下一个值

    }

    public T pop(){//出栈
        T t=peek();
        if(size>0){
            stack[size-1]=null;//栈顶元素赋值为空
            size--;
        }
        return t;

    }
    public void expandCapacity(int size){//扩容
        int len=stack.length;
        if(size>len){
            size = size * 3 / 2 + 1;//每次扩大50%
            stack=Arrays.copyOf(stack,size);//扩大数组,copyOf(原数组，要比原来大的长度)
        }
    }

}

/**
 * 1.2链表实现栈，实际上就操作对象
 * @param <T>
 */

class LinkStack<T>  implements MyStack<T>{

    class Node<T>{//结点类
        private T t;//存储值
        private Node next;//存放一下个Node对象
    }
    private Node<T> head;

    //构造函数初始化头指针
    public LinkStack(){
        head=null;
    }
    public boolean isEmpty(){//判断是否为空
        return head==null;
    }

    public T peek(){//获取栈顶元素
        T t=null;
        try{
            t=head.t;
        }catch(Exception e){
            return t;
        }
        return t;
    }

    public void push(T t){//压栈
        if (t == null) {
            throw new NullPointerException("参数不能为空");
        }
        if(head==null){//第一个加进来的
            head=new Node<T>();//生成一个新的结点
            head.t=t;//结点赋值
            head.next=null;//next是用来存放下一个对象的，第一个就直接赋值为null就行
        }else{
            Node<T> temp = head;
            head=new Node<T>();//生成一个新的结点
            head.t=t;
            head.next=temp;

        }

    }

    public T pop(){//出栈
        T t=head.t;
        head=head.next;
        return t;
    }
}

/**
 * 1.3LinkedList（双向链表）实现栈
 * @param <T>
 */
class LinkedListStack<T>  implements MyStack<T>{

    private LinkedList<T> ll=new LinkedList<T>();

    public boolean isEmpty(){//判断是否为空
        return ll.isEmpty();
    }

    public T peek(){//获取栈顶元素
        T t=null;
        if(!ll.isEmpty()){
            //直接取元素会报异常，需要先判断是否为空
            t = ll.getFirst();
        }
        return t;
    }

    public void push(T t){//压栈
        ll.addFirst(t);//在链的头部添加数据
    }

    public T pop(){//出栈
        return ll.removeFirst();
    }

}


//数据结构，2.队列，增删查
class LinkedListQueue<T>  implements MyStack<T>{

    private LinkedList<T> ll=new LinkedList<T>();

    public boolean isEmpty(){//判断是否为空
        return ll.isEmpty();
    }

    public T peek(){//获取栈顶元素
        T t=null;
        if(!ll.isEmpty()){
            //直接取元素会报异常，需要先判断是否为空
            t = ll.getLast();
        }
        return t;
    }

    public void push(T t){//压栈
        ll.addFirst(t);//在链的头部添加数据
    }

    public T pop(){//出栈,从尾部出去
        return ll.removeLast();
    }

}
//数据结构，3.顺序表（数组），增删查
class Myarray {
    //声明一个数组
    Object[] element;
    //当前数组的已用长度
    public Myarray() {
        //默认生成5个长度的数组
        this.element=new Object[5];
    }
    //获取数组的中还没存储的最开始下标
    public int lastIndex(Object[] element) {
        for (int i = 0; i < element.length; i++) {
            if (element[i] == null) {
                return i;
            }
        }
        //都存储完了,就返回数组的长度
        return element.length;
    }
    //获取数组的已存数据的长度
    public int length() {
        int len=0;
        for (int i = 0; i < this.element.length; i++) {
            if (this.element[i] != null) {
                len++;
            }
        }
        return len;
    }

    //增加方法
    public void add(Object arg) {
        //调用下标函数，查看最后一个空的下标
        int len=this.lastIndex(this.element);
//    System.out.println(len);
        try {//长度超出后肯定会抛出异常,说明长度已经不够了
            this.element[len]=arg;
        } catch (Exception e) {//扩容长度
            // TODO: handle exception
            //生成新数组
            Object[] newelement=new Object[this.element.length+5];
            //把原来数组的数据复制给新数组
            for (int i = 0; i < this.element.length; i++) {
                newelement[i]=this.element[i];
            }
            //新添加的也要加上来
            newelement[this.element.length]=arg;
            //覆盖原来的数组
            element= newelement;
        }


    }
    //删除元素的方法,根据数据删除
    public Object remove(Object obj) {
        //把存在的置为null
        Object ele=null;//用来记录返回删除的数据的小标
        for (int i = 0; i < this.element.length; i++) {
            if(this.element[i]==obj) {
                this.element[i]=null;
                if(ele==null) {
                    ele=i;
                }else {
                    ele=ele+","+i;
                }
            }
        }

        //遍历原来的数组
        for (int i = 0; i < this.element.length; i++) {
            if(this.element[i]==null) {//当为null时，说明是需要去掉的
                if(this.element.length!=i+1) {
                    this.element[i]=this.element[i+1];//把后面一个移动到前面
                    this.element[i+1]=null;//再把后面的置为空
                }

            }
        }
        return ele;
    }
    //删除元素的方法，根据下标删除，重载
    //int类型也是继承Object，所以就算重载，java会就近原则选，所以设置两个参数,返回删除的那个数据
    public Object remove(int index,int flag) {
        Object ele=null;//用来记录返回删除的数据
        try {
            //赋值
            ele=this.element[index];
            //null说明，该下标没有数据，直接返回null
            if(this.element[index]==null) {
                return null;
            }else {
                //该下标的数据置为空
                this.element[index]=null;
                //遍历原来的数组
                for (int i = 0; i < this.element.length; i++) {
                    if(this.element[i]==null) {//当为null时，说明是需要去掉的
                        this.element[i]=this.element[i+1];//把后面一个移动到前面
                        this.element[i+1]=null;//再把后面的置为空，最后一个数组会越界
                    }
                }

                return ele;
            }
        } catch (Exception e) {//有异常时跳转到这里
            if(ele==null) {//
                return null;
            }else {
                return ele;
            }
        }

    }
    //查询数据
    public Object get(int index) {
        try {
            return this.element[index];
        } catch (Exception e) {
            // TODO: handle exception
            return null;
        }
    }

}

// //数据结构，4.二叉树，增删查
class Bintree{
    private class Node{//内部类
        private int data;//存放数据
        private Node left;//左指针，指向左边下一个对象
        private Node right;//右指针，指向右边边下一个对象
        public Node(int data){
            this.data=data;
        }
        public void addNode(int data){//递归添加
            if(this.data>data){//比根结点小的就村左边
                if(this.left==null){
                    this.left=new Node(data);//直接生成对象
                }else{
                    this.left.addNode(data);//继续递归添加
                }
            }else{//村右边
                if(this.right==null){
                    this.right=new Node(data);
                }else{
                    this.right.addNode(data);
                }
            }
        }
        //中序遍历（左根右）,排好序的
        public void printNode(){
            if(this.left!=null){//递归
                this.left.printNode();
            }
            System.out.print(this.data+"->");
            if(this.right!=null){
                this.right.printNode();
            }
        }
    }
    private Node root;//根结点

    public void add(int data){
        if(root==null){//如果根结点为空
            root=new Node(data);//直接生成一个对象
        }else{
            root.addNode(data);//递归调用
        }
    }
    public void print(){
        root.printNode();
    }



}
//数据结构，5.红黑树，增删查
//有点难度，先不写，改天再来
class RBTrees {

}