java数据结构栈、队列、二叉树、链表的具体实现

前言

本文只列出
本文只列举链表、栈和队列、二叉树的结构及相应方法,具体算法慢慢补充

链表

n个节点离散分配,彼此通过指针相连,每个节点只有一个前驱节点,每个节点只有一个后续节点,首节点没有前驱节点,尾节点没有后续节点。
确定一个链表我们只需要头指针,通过头指针就可以把整个链表都能推出来。
优点
1.空间没有限制
2.插入删除元素很快
缺点
1.存取速度很慢

创建链表结构

/**
 * 链表实体结构
 */
public class Node {
    //数据域
    public Object data;
    //指针域
    public Node next;
    public Node(){
    }
    public Node(Object data){
        this.data=data;
    }
}

相对应方法

public class NodeMethod {
    //头结点
    private static Node head=new Node();
    /**
     * 向链表添加数据
     */
    public void addData(Node node) {
        //临时节点
        Node temp = head;
        // 找到尾节点
        while (temp.next != null) {
            temp = temp.next;
        }
        // 已经包括了头节点.next为null的情况了~
        temp.next = node;
    }

    /**
     * 遍历链表
     */
    public void traverse() {
        //临时节点,从首节点开始
        Node temp = head.next;

        while (temp != null) {
            System.out.println("链表数据:" + temp.data);
            //继续下一个
            temp = temp.next;
        }
    }
}

这里只列举单链表结构

核心思想:先入后出
可想象为一个尾部被堵死的管道,先进出的只能等后进的全出去了,在出去

链表实现

沿用链表的实体结构
**相应方法

public class Stack {
    private static Node headNode=new Node();

    /**
     * 入栈
     * @param data
     */
    public void push(Object data){
        if (headNode==null){
            headNode=new Node(data);
        }else {
            Node node=new Node(data);
            node.next=headNode;
            headNode=node;
        }
    }
    /**
     * 出栈
     */
    public Object pop(){
        if (headNode==null){
            System.out.println("栈为空,无数据");
            return 0;
        }
        Object data = headNode.data;
        headNode=headNode.next;
        return data;
    }
    /**
     * 遍历
     */
    public void traverse(){
        Node node=headNode;
        int i=0;
        if (node==null){
            System.out.println("栈内无数据");
            return;
        }
        while (node.next!=null){
            i++;
            System.out.println("第"+i+"个出栈:"+node.data);
            node=node.next;
        }
    }
    /**
     * 获取长度
     */
    public Integer length(){
        Node node=headNode;
        int length=0;
        if (node==null){
            return length;
        }
        while (node.next!=null){
            length++;
            node=node.next;
        }
        return length;
    }
}

列表实现

public class Stack_m {
    private List<Object> stack=new Vector<>();
    /**
     * 入栈
     */
    public void push(Object data){
        stack.add(data);
    }

    /**
     * 出栈
     */
    public Object pop(){
        if (stack.size()<=0){
            System.out.println("栈内无数据");
            return null;
        }
        Object t = stack.get(stack.size() - 1);
        stack.remove(stack.size()-1);
        return t;
    }
    /**
     * 遍历
     */
    public void traverse(){
        if (stack.size()<=0){
            System.out.println("栈内无数据");
            return;
        }
        for (int i=stack.size()-1;i>=0;i--){
            System.out.println(new Date()+"-->出栈"+stack.get(i));
        }
    }

    /**
     * 长度
     */
    public int length(){
        return stack.size();
    }

}

队列

核心思想:先入先出
可想象为是一个管道,只能一端进一端出

链表实现

沿用链表实体结构

public class Queue {
    private static Node headNode=null;

    /**
     * 入队
     *
     */
    public void push(Object data){
        if(headNode==null){
            headNode=new Node(data);
        }
        else {
            Node node=headNode;
            while (node.next!=null){
                node=headNode.next;
            }
            node.next=new Node(data);
        }
    }
    /**
     * 出队
     */
    public Object pop() {
        if(headNode==null){
            System.out.println("队为空,无数据");
            return 0;
        }
        Object data=headNode.data;
        headNode=headNode.next;
        return data;
    }
    /**
     * 遍历
     *
     */
    public void traverse(){
        Node node=headNode;
        int i=0;
        if (headNode==null){
            System.out.println("队内无数据");
            return;
        }
        while (node.next!=null){
            i++;
            System.out.println("第"+i+"个出队:"+node.data);
            node=node.next;
        }
        if(node.next==null){
            i++;
            System.out.println("第"+i+"个出队:"+node.data);
        }
    }
    /**
     * 长度
     */
    public Integer length(){
        Node node=headNode;
        int i=0;
        if (headNode==null){
            System.out.println("队内无数据");
            return i;
        }
        while (node.next!=null){
            i++;
            node=node.next;
        }
        i++;
        return i;
    }
}

列表实现

public class Queue_m {
    private static List<Object> queue=new Vector<>();

    /**
     * 入队
     *
     */
    public void push(Object data){
        queue.add(data);
    }
    /**
     * 出队
     */
    public Object pop() {
        if (queue.size()<=0){
            System.out.println("队内无数据");
            return 0;
        }
        Object o = queue.get(0);
        queue.remove(0);
        return o;
    }
    /**
     * 遍历
     *
     */
    public void traverse(){
        if (queue.size()<=0){
            System.out.println("队内无数据");
            return ;
        }
        for (int i=0;i<queue.size();i++){
            System.out.println("第"+(i+1)+"个出队:"+queue.get(i));
        }
    }
    /**
     * 长度
     */
    public Integer length(){
        return queue.size();
    }
}

二叉树

实体结构

@Data  //没有lomcok插件的请手动set和get
public class TreeNode {
    // 数据
    private int value;
    // 左节点
    private TreeNode leftNode;
    // 右节点
    private TreeNode rightNode;

    public TreeNode(){

    }
    public TreeNode(int value) {
        this.value = value;
    }
}

相应方法

public class TreeNodeMethod {
    /**
     * 中序遍历
     * @param rootTreeNode  根节点
     */
    public void inTraverseBTree(TreeNode rootTreeNode) {

        if (rootTreeNode != null) {
            //访问根节点
            System.out.println(rootTreeNode.getValue());
            //访问左节点
            inTraverseBTree(rootTreeNode.getLeftNode());
            //访问右节点
            inTraverseBTree(rootTreeNode.getRightNode());
        }
    }
    /**
     * 先序遍历
     * @param rootTreeNode  根节点
     */
    public void firstTreeNode(TreeNode rootTreeNode) {

        if (rootTreeNode.getLeftNode() != null) {
            firstTreeNode(rootTreeNode.getLeftNode());
        }
        //访问根节点
        System.out.println(rootTreeNode.getValue());
        if(rootTreeNode.getRightNode()!=null){
            firstTreeNode(rootTreeNode.getRightNode());
        }
    }
    /**
     * 先序遍历
     * @param rootTreeNode  根节点
     */
    public void lastTreeNode(TreeNode rootTreeNode) {
		// 递归左节点
        if (rootTreeNode.getLeftNode() != null) {
            lastTreeNode(rootTreeNode.getLeftNode());
        }
         //  递归右节点
        if(rootTreeNode.getRightNode()!=null){
            lastTreeNode(rootTreeNode.getRightNode());
        }
        //访问根节点
        System.out.println(rootTreeNode.getValue());

    }
}

相应的理论这里就不在过多的阐述了,网上有很多

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 书香水墨 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读