二叉树链表存储、链表、栈、堆的结构实现（Java）

已于 2022-06-08 16:10:39 修改
阅读量479 收藏
点赞数
分类专栏： Java基础 数据结构 文章标签： java 数据结构
于 2022-03-28 22:59:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53574615/article/details/123806064
版权

目录

二叉树的实现

链表的实现

栈的实现

        栈的数组实现

        栈的链表实现

队列的实现

        队列的数组实现

        队列的集合实现

        两个栈实现队列

二叉树的实现

package binarytree;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 21:06
 */

public class TreeNode {
    public int value;
    public TreeNode leftTreeNode;
    public TreeNode rightTreeNode;

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

    public String toString() {
        return "TreeNode{value=" + this.value + ", leftTreeNode=" + this.leftTreeNode + ", rightTreeNode=" + this.rightTreeNode + '}';
    }
}
package binarytree;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 21:09
 */

public class Test {

    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(5);
        TreeNode node2 = new TreeNode(4);
        TreeNode node3 = new TreeNode(7);
        TreeNode node4 = new TreeNode(6);
        node1.leftTreeNode = node2;
        node1.rightTreeNode = node3;
        node3.leftTreeNode = node4;
        System.out.println(node1);
    }
}

测试结果

TreeNode{value=5, leftTreeNode=TreeNode{value=4, leftTreeNode=null, rightTreeNode=null}, rightTreeNode=TreeNode{value=7, leftTreeNode=TreeNode{value=6, leftTreeNode=null, rightTreeNode=null}, rightTreeNode=null}}

Process finished with exit code 0

链表的实现

package link;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 21:13
 */
public class ListNode {
    int value;
    ListNode next;

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

    public String toString() {
        return "ListNode{value=" + this.value + ", next=" + this.next + '}';
    }
}

package link;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 21:13
 */
public class Test {
    public static void main(String[] args) {
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(5);
        ListNode node3 = new ListNode(9);
        node1.next = node2;
        node2.next = node3;
        System.out.println(node1);
    }
}

测试结果 

 ListNode{value=1, next=ListNode{value=5, next=ListNode{value=9, next=null}}}

Process finished with exit code 0

栈的实现

        栈的数组实现

package stack;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 21:18
 */
public class StackArray<E> {
    private E[] arr = (E[])(new Object[12]);
    private int flag = 0;

    public StackArray() {
    }

    public void add(E x) {
        this.arr[this.flag] = x;
        ++this.flag;
        if (flag == arr.length) { //扩容之后
            E[] brr = (E[])(new Object[arr.length * 2]);

            for(int i = 0; i < flag; ++i) {
                arr[i] = brr[i];
            }

            arr = brr;
            System.out.println("栈已满，不能放入");
        }
    }

    public E get() {
        if (flag == 0) {
            System.out.println("栈已空");
            return null;
        } else {
            E result = arr[flag - 1];
            --flag;
            return result;
        }
    }
}

package stack;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 21:20
 */
public class TestArray {
    public static void main(String[] args) {
        StackArray<Integer> x1 = new StackArray();
        Integer i;
        for(i = 0; i < 10; i = i + 1) {
            x1.add(i);
        }

        for(i = 0; i < 15; i = i + 1) {
            System.out.print(x1.get() + " ");
        }
    }


}

 9 8 7 6 5 4 3 2 1 0 栈已空
null 栈已空
null 栈已空
null 栈已空
null 栈已空
null 
Process finished with exit code 0

        栈的链表实现

package stack;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 22:50
 */
public class StackNode<T> {
    class Node<T> {
        private T t;
        private Node next;
    }

    private Node<T> head;

    //构造函数初始化头指针
    StackLink() {
        head = null;
    }

    //入栈
    public void push(T t) {
        if (t == null) {
            throw new NullPointerException("参数不能为空");
        }
        if (head == null) {
            head = new Node<T>();
            head.t = t;
            head.next = null;
        } else {
            Node<T> temp = head;
            head = new Node<>();
            head.t = t;
            head.next = temp;
        }
    }

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

package stack;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 22:53
 */
public class TestLink {
    public static void main(String[] args) {
        StackNode stack = new StackNode();
        stack.push("useful");
        stack.push("is ");
        stack.push("Java ");
        System.out.print(stack.pop());
        System.out.print(stack.pop());
        System.out.print(stack.pop());
    }
}

 Java is useful
Process finished with exit code 0

        两个队列实现一个栈

package datastructure;

import java.util.LinkedList;

/**
 * @description:
 * @author: gyj
 * @date: 2022/6/7 21:42
 */
public class StackTest {
    LinkedList<Integer> queue1 = new LinkedList<Integer>();
    LinkedList<Integer> queue2 = new LinkedList<Integer>();

    public void push(int value){
        queue1.addLast(value);
    }

    public int pop() {
        if (sSize() != 0) {
            if (!queue1.isEmpty()) {
                putN_1ToAnother();
                return queue1.removeFirst();
            } else {
                putN_1ToAnother();
                return queue2.removeFirst();
            }
        } else {
            System.out.println("栈已空,不能出栈");
            return -1;
        }

    }

    public int sSize() {
        return queue1.size() + queue2.size();
    }

    public void putN_1ToAnother()//从非空中出队n-1个到另一个队列
    {
        if (!queue1.isEmpty()) {
            while (queue1.size() > 1) {
                queue2.addLast(queue1.removeFirst());
            }
        } else if (!queue2.isEmpty()) {
            while (queue2.size() > 1) {
                queue1.addLast(queue2.removeFirst());
            }
        }
    }

    public static void main(String[] args) {
        StackTest stack = new StackTest();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        stack.push(5);
        stack.push(6);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
    }
}

4
3
6
5
2
1
栈已空,不能出栈
-1

Process finished with exit code 0

队列的实现

        队列的数组实现

package queue;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 22:02
 */
public class QueueArray {

    int[] a = new int[5];
    int i = 1; //数组下标

    //入队
    public void in(int m) {
        a[i++] = m;
    }

    //出队
    public int out() {
        int index = 0;
        int temp = a[1];
        for (int j = 1; j < i; j++) {
            a[j - 1] = a[j];
            index++;
        }
        i = index;
        return temp;
    }
}

package queue;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 22:05
 */
public class TestArray {
    public static void main(String[] args) {
        //测试队列
        System.out.println("数组测试队列：");
        QueueArray queue = new QueueArray();
        queue.in(1);
        queue.in(2);
        queue.in(3);
        System.out.println(queue.out());
        System.out.println(queue.out());
        queue.in(4);
        System.out.println(queue.out());
        System.out.println(queue.out());
        queue.in(5);
        System.out.println(queue.out());
    }
}

测试结果 

 数组实现测试队列：
1
2
3
4
5

Process finished with exit code 0

        队列的集合实现

package queue;

import java.util.ArrayList;
import java.util.List;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 22:05
 */
public class QueueList {
    List<Integer> list = new ArrayList<Integer>();
    int index = 0;  //下标

    //入队
    public void in(int n){
        list.add(n);
        index++;
    }

    //出队
    public int out(){
        if(!list.isEmpty()){
            index--;
            return list.remove(0);
        }
        return -1;
    }
}

package queue;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 22:06
 */
public class TestList {
    public static void main(String[] args) {
        //测试队列
        System.out.println("集合实现测试队列：");
        QueueList queue = new QueueList();
        queue.in(1);
        queue.in(2);
        queue.in(3);
        System.out.println(queue.out());
        System.out.println(queue.out());
        queue.in(4);
        System.out.println(queue.out());
        System.out.println(queue.out());
        queue.in(5);
        System.out.println(queue.out());
    }
}

测试结果 

集合实现测试队列：
1
2
3
4
5

Process finished with exit code 0

        两个栈实现队列


   队列的主要操作有两个入队操作和出队操作，先进先出
   入队的操作和入栈的操作类似，而出队操作则是先进去的元素先出队，而栈则是栈顶元素先出，即后入栈的先出栈
   假设两个栈A和栈B，A主要用来处理入队操作，B用于处理出队操作。入队操作和入栈操作类似，
  直接将元素压入栈即可。出队的时候，实现我们假设栈B为空，则要把栈A的第一个元素（即栈底元素）弹出，需要将A中元素逆转过来，所以要先把栈A的元素全部出栈，并按顺序压入栈B中，这样每次栈B弹出的栈顶元素就是栈A相对应的栈底元素，就是出队操作。
  若B不为空，则代表之前从A复制过来的元素还没有完全出栈，要出栈的时候直接弹出即可。若栈B的元素都弹出来了，就需要从A中补充。
    
   入队：将元素压入栈A
   出队：判断栈B是否为空，如果为空，则将栈A中所有元素pop，并push进栈B，栈B出栈；如果不为空，栈B将剩余元素出栈。

package queue;


import java.util.Stack;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 22:05
 */
public class QueueStack {
    Stack<Integer> stackA = new Stack<Integer>();
    Stack<Integer> stackB = new Stack<Integer>();

    //入队
    public void in(int n) {
        stackA.push(n);
    }

    //出队
    public int out() {
        if(stackB.isEmpty()){
            while (stackA.size() > 0) {
                stackB.push(stackA.pop());
            }
        }
        return stackB.pop();
    }
}

package queue;

/**
 * @description:
 * @author: gyj
 * @date: 2022/3/28 22:09
 */
public class TestStack {
    public static void main(String[] args) {

        System.out.println("两个栈实现一个队列：");
        QueueStack queue = new QueueStack();
        queue.in(1);
        queue.in(2);
        queue.in(3);
        System.out.println(queue.out());
        System.out.println(queue.out());
        queue.in(4);
        System.out.println(queue.out());
        System.out.println(queue.out());
        queue.in(5);
        System.out.println(queue.out());

    }
}

 测试结果

两个栈实现一个队列：
1
2
3
4
5

Process finished with exit code 0

赚钱去流浪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树的二叉链表存储及其Java实现
生命在于折腾
07-28 4301
二叉链表存储的思想是让每个节点都记住它的左、右两个子节点，为每个节点增加left、right两个指针，分别引用该节点的左、右两个子节点，如图所示： 其中，每个节点大致有如下定义：   对于这种二叉链表存储的二叉树，如果程序需要，为指定节点添加子节点也非常容易，让父节点的left、right引用指向新节点即可。   Java实现代码：   测试代码：   对于这种二叉链表的二叉
java中常见的数据结构（list,stack,queue,linked,hashTable,tree）
weixin_44783506的博客
04-21 5022
6种常见数据结构 数组、链表、队列、堆栈、哈希表、树
Java二叉树链式存储,二叉树的链式存储结构（C语言详解）
weixin_34206129的博客
03-15 213
上一节讲了二叉树的顺序存储，通过学习你会发现，其实二叉树并不适合用数组存储，因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或多会存在空间浪费的现象。本节我们学习二叉树的链式存储结构。图 1 普通二叉树示意图如图 1 所示，此为一棵普通的二叉树，若将其采用链式存储，则只需从树的根节点开始，将各个节点及其左右孩子使用链表存储即可。因此，图 1 对应的链式存储结构如图 2 所示：图 2...
Morris算法遍历二叉树
qq_40585050的博客
09-09 570
中序遍历步骤 如果当前节点左子节点(cur.left)为空，输出当前节点(cur)，进入右子节点(cur.right)。 如果当前节点左子节点(cur.left)非空，找到当前节点左子树的最右节点(mostRight)： 1）如果该节点的右子节点(mostRight.right)为空，则将其指针指向当前节点(cur)，进入左子节点(cur.left)。 2）如果该节点的右子节点(mostRight.right)非空，则将其指针置为空，输出当前节点(cur)，进入右子节点(cur.right)。
java链树（含树的详细代码）
qq_56127002的博客
08-22 597
java树的原理介绍，以及java链树的代码详解
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
头歌数据结构二叉树的二叉链表存储及基本操作 第1关：先序遍历创建二叉链表存储的二叉树及遍历操作 第2关：计算二叉树的高度、总节点个数和叶子节点个数 第3关：层次遍历二叉树 第4关：递归实现二叉树左右子树交换 ...
常用算法链表堆栈二叉树.docx
09-07
今天我们主要讨论链表、栈和二叉树这三种数据结构，并介绍一些常用的算法。 一、链表 链表是一种动态的数据结构，每个结点都包含了一个值和一个指向下一个结点的指针。链表可以实现插入、删除、查找等操作。 1. ...
没有指针，Python如何实现链表、二叉树这些数据结构？
01-20
文章目录前言结点的实现单链表的操作单链表操作的实现is_empty()判断链表是否为空travel() 遍历整个链表length() 链表长度add(item) 链表头部添加元素append(item) 链表尾部添加元素insert(pos, item) 指定位置添加...
《数据结构》实验报告：链表与二叉树
最新发布
07-15
报告配套代码已经整理包含： 包含完整实验报告以及配套代码，结构完整，符合要求，实验成绩优。 建议大家自己写，我这个更多的是自己的资源存档 希望大家都能取得好成绩！！！
Java版数据结构代码，栈，动态数组，队列，链表，二叉树
07-28
在队列的代码中，引用了链表的代码
基于链表实现二叉树(java算法源码)
01-20
/* * 基于链表实现二叉树 */ package dsa; public class BinTree_LinkedList implements BinTree { protected BinTreePosition root;//根节点 /**************************** 构造函数 ****************************/ public BinTree_LinkedList() { this(null); } public BinTree_LinkedList(BinTreePosition r) { root = r; } /**************************** BinaryTree接口方法 ****************************/ //返回树根 public BinTreePosition getRoot() { return root; } //判断是否树空 public boolean isEmpty() { return null == root; } //返回树的规模（即树根的后代数目） public int getSize() { return isEmpty() ? 0 : root.getSize(); } //返回树（根）的高度 public int getHeight() {return isEmpty() ? -1 : root.getHeight(); } //前序遍历 public Iterator elementsPreorder() { return root.elementsPreorder(); } //中序遍历 public Iterator elementsInorder() { return root.elementsInorder(); } //后序遍历 public Iterator elementsPostorder() { return root.elementsPostorder(); } //层次遍历 public Iterator elementsLevelorder() { return root.elementsLevelorder(); } }
java链式结构_JAVA 实现二叉树（链式存储结构）
weixin_42522167的博客
02-15 582
二叉树的分类(按存储结构)树的分类(按存储结构)顺序存储(用数组表示(静态二叉树))链式存储一些特别的二叉根：完全二叉树，平衡二叉树(AVL)，线索二叉树，三叉的(带父亲的指针)二叉搜索树或者叫二叉　查找树(BST)所用二叉树如下图所示：二叉树的Java实现(链式存储结构)class TreeNode {private int key = 0;private String data = null;...
链表 栈 队列 堆 二叉树 （超级详细）
qq_53217755的博客
12-20 909
目录 链表 栈 队列 堆 二叉树 链表 栈 队列 堆 二叉树
黑马笔记---常见数据结构
weixin_65440201的博客
06-29 529
目录1.常见数据结构1.1数据结构概述、栈、队列数据结构概述常见的数据结构1.2数组1.3链表链表的特点链表的种类 1.4二叉树、 二叉查找树二叉树概述二叉树的特点 二叉查找树的特点1.5平衡二叉树1.6红黑树红黑树概述红黑规则添加节点红黑树小结：各种数据结构的特点和作用是什么样的1.数据结构是计算机底层存储、组织数据的方式。是指数据相互之间是以什么方式排列在一起的。2.通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。1.栈2.队列3.数组4.链表5.二叉树6.二叉查找树7.平衡二叉树8.红
数据结构之 二叉树 （java 链表实现）
qq_42711376的博客
03-13 815
一.树 在介绍二叉树之前，先普及一下树的概念，和一些名词： 树有一下特点： 1.每个节点有一个或多个子结点，从A看那 B和C 就是A的子结点，那A就是B和C的父结点 2.没有父结点的结点叫根节点 3.每一个非根节点只有一个父结点 4.没个节点往下看都可以看作一颗树，左边的结点就叫 左子树，右边的节点就叫右子树； 树的相关名词： 节点：每一个树的最小组成单元，上面的ABCD 结点的度: 没一个节点的子节点总数 树的度：选取所有结点中最大的度，就是树的度 叶子结点：度为0的结点就是叶子
以链表实现二叉树java,java -链表实现二叉树
weixin_42364852的博客
03-11 529
java – 链表实现二叉树1. 首先创建树TreeNode root;//设置根节点public void setRoot(TreeNode root) {this.root = root;}//获取根节点public TreeNode getRoot() {return root;}//前序遍历public void frontShow(){if(root!=null){root.frontS...
用Java实现二叉链表方式存储的二叉树
YanLeaon的博客
09-05 3488
**给定一颗二叉树的遍历顺序，创建相应的二叉树链表。这里所说的遍历顺序是一种“扩展的遍历序列”，即用“.”来表示空的子树。下面，我们来构建先序遍历序列为AB.DF..G..C.E.H..的二叉链表。** 先看书上面使用C语言的实现： void CreateBiTree(BiTree *bt){ char ch; ch = getchar();
java -链表实现二叉树
weixin_43345943的博客
02-16 1670
java – 链表实现二叉树 1. 首先创建树 TreeNode root; //设置根节点 public void setRoot(TreeNode root) { this.root = root; } //获取根节点 public TreeNode getRoot() { return root; ...
java链表与二叉树
AllenTang_ay的博客
10-28 1349
1. 链表 1) 基本特征：内存中不连续的节点序列，节点之间通过next指针彼此相连；                          每个节点的next指针都指向下一个节点，最后一个节点的next指针为NULL。 2) 基本操作：插入、删除、遍历。   3) 实现要点 追加：将新分配节点的地址赋给原链表最后一个节点的next指针。   插入：将前节点中存储的后节点地址赋给新节点
二叉树的二叉链表存储结构的实现项目计划书
06-03
好的，我会为您提供关于二叉树的二叉链表存储结构实现的项目计划书。以下是该计划书的主要内容： 一、项目背景 随着计算机科学技术的不断发展，数据结构的应用越来越广泛，其中二叉树是常用的数据结构之一。在实际...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

赚钱去流浪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值