手写数据结构(JAVA基础)

已于 2024-04-22 16:33:59 修改
阅读量967 收藏 20
点赞数 19
分类专栏： JAVA基础 文章标签： 数据结构 java
于 2024-02-29 15:28:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zlx116282/article/details/136371908
版权

目录

一.手写栈结构

二.手写单向链表结构

三.手写双向链表结构

四.手写二叉树排序

五.手写树形数据结构

一.手写栈结构

在Java中，你可以手写一个栈（Stack）结构。栈是一种后进先出（LIFO, Last In First Out）的数据结构，它只允许在栈顶进行元素的添加和删除操作。

下面是一个简单的栈的实现示例：

public class MyStack<T> {
    private List<T> elements;

    public MyStack() {
        elements = new ArrayList<>();
    }

    // 入栈操作
    public void push(T element) {
        elements.add(element);
    }

    // 出栈操作
    public T pop() {
        if (!isEmpty()) {
            return elements.remove(elements.size() - 1);
        } else {
            throw new EmptyStackException();
        }
    }

    // 查看栈顶元素，不移除
    public T peek() {
        if (!isEmpty()) {
            return elements.get(elements.size() - 1);
        } else {
            throw new EmptyStackException();
        }
    }

    // 检查栈是否为空
    public boolean isEmpty() {
        return elements.isEmpty();
    }

    // 获取栈的大小
    public int size() {
        return elements.size();
    }

    // 清空栈
    public void clear() {
        elements.clear();
    }

    // 栈溢出异常
    public static class EmptyStackException extends RuntimeException {
        private static final long serialVersionUID = 1L;

        public EmptyStackException() {
            super("Stack is empty");
        }
    }

    // 测试
    public static void main(String[] args) {
        MyStack<Integer> stack = new MyStack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);

        System.out.println(stack.peek());  // 输出 3
        System.out.println(stack.pop());   // 输出 3
        System.out.println(stack.pop());   // 输出 2
        System.out.println(stack.pop());   // 输出 1

        // 再次尝试出栈将抛出异常
        try {
            stack.pop();
        } catch (MyStack.EmptyStackException e) {
            System.out.println(e.getMessage());
        }
    }
}

在这个示例中，MyStack 类使用了一个 ArrayList 作为内部存储机制。push 方法用于向栈中添加元素，pop 方法用于移除并返回栈顶元素，peek 方法用于查看栈顶元素但不移除，isEmpty 方法用于检查栈是否为空，size 方法用于获取栈的大小，clear 方法用于清空栈。此外，还定义了一个内部异常类 EmptyStackException，用于在栈为空时抛出异常。

在 main 方法中，我们创建了一个 MyStack 实例，并演示了如何使用它进行基本的栈操作。

二.手写单向链表结构

在Java中，你可以手写一个单向链表（Singly Linked List）结构。单向链表由一系列节点组成，每个节点包含两部分：数据部分（用于存储数据）和链接部分（用于指向下一个节点）。

下面是一个简单的单向链表的实现示例：

public class Node<T> {
    private T data;
    private Node<T> next;

    public Node(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Node<T> getNext() {
        return next;
    }

    public void setNext(Node<T> next) {
        this.next = next;
    }
}

public class SinglyLinkedList<T> {
    private Node<T> head;

    public SinglyLinkedList() {
        head = null;
    }

    // 添加元素到链表尾部
    public void append(T data) {
        Node<T> newNode = new Node<>(data);
        if (head == null) {
            head = newNode;
        } else {
            Node<T> current = head;
            while (current.getNext() != null) {
                current = current.getNext();
            }
            current.setNext(newNode);
        }
    }

    // 遍历链表并打印元素
    public void printList() {
        Node<T> current = head;
        while (current != null) {
            System.out.print(current.getData() + " ");
            current = current.getNext();
        }
        System.out.println();
    }

    // 测试
    public static void main(String[] args) {
        SinglyLinkedList<Integer> list = new SinglyLinkedList<>();
        list.append(1);
        list.append(2);
        list.append(3);
        list.append(4);
        list.printList();  // 输出 1 2 3 4
    }
}

在这个示例中，Node 类表示单向链表中的一个节点，包含数据（data）和指向下一个节点的指针（next）。SinglyLinkedList 类是单向链表的实现，它有一个头节点（head）用于开始遍历链表。append 方法用于在链表尾部添加一个新元素，而 printList 方法则用于遍历链表并打印出所有元素。

在 main 方法中，我们创建了一个 SinglyLinkedList 实例，并添加了几个整数元素，然后调用 printList 方法打印链表的内容。

请注意，这个示例只包含了单向链表的基本操作，实际上一个完整的单向链表实现可能还会包括其他方法，如插入元素、删除元素、查找元素等。

三.手写双向链表结构

在Java中，你可以手写一个双向链表（Doubly Linked List）结构。双向链表与单向链表的主要区别在于，每个节点不仅有一个指向下一个节点的链接，还有一个指向前一个节点的链接。这使得双向链表可以从头到尾或从尾到头进行遍历。

下面是一个简单的双向链表的实现示例：

public class Node<T> {
    private T data;
    private Node<T> next;
    private Node<T> prev;

    public Node(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Node<T> getNext() {
        return next;
    }

    public void setNext(Node<T> next) {
        this.next = next;
        if (next != null) {
            next.setPrev(this);
        }
    }

    public Node<T> getPrev() {
        return prev;
    }

    public void setPrev(Node<T> prev) {
        this.prev = prev;
    }
}

public class DoublyLinkedList<T> {
    private Node<T> head;
    private Node<T> tail;
    private int size;

    public DoublyLinkedList() {
        head = null;
        tail = null;
        size = 0;
    }

    // 添加元素到链表尾部
    public void append(T data) {
        Node<T> newNode = new Node<>(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            tail.setNext(newNode);
            newNode.setPrev(tail);
            tail = newNode;
        }
        size++;
    }

    // 添加元素到链表头部
    public void prepend(T data) {
        Node<T> newNode = new Node<>(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            newNode.setNext(head);
            head.setPrev(newNode);
            head = newNode;
        }
        size++;
    }

    // 遍历链表并打印元素
    public void printList() {
        Node<T> current = head;
        while (current != null) {
            System.out.print(current.getData() + " ");
            current = current.getNext();
        }
        System.out.println();
    }

    // 测试
    public static void main(String[] args) {
        DoublyLinkedList<Integer> list = new DoublyLinkedList<>();
        list.append(1);
        list.append(2);
        list.append(3);
        list.prepend(0);
        list.printList();  // 输出 0 1 2 3
    }
}

在这个示例中，Node 类表示双向链表中的一个节点，它包含了数据（data）、指向下一个节点的指针（next）和指向前一个节点的指针（prev）。DoublyLinkedList 类是双向链表的实现，它维护了头节点（head）、尾节点（tail）和链表的大小（size）。append 方法用于在链表尾部添加一个新元素，而 prepend 方法用于在链表头部添加一个新元素。printList 方法则用于遍历链表并打印出所有元素。

在 main 方法中，我们创建了一个 DoublyLinkedList 实例，并添加了几个整数元素，然后调用 printList 方法打印链表的内容。注意，在添加新节点时，我们需要更新相邻节点的指针以保持链表的双向连接。

四.手写二叉树排序

在Java中，手写一个二叉树排序通常是指实现一个二叉搜索树（Binary Search Tree, BST）的插入和遍历方法，以保证树中的节点按照某种顺序排列。下面是一个简单的二叉搜索树的实现，包括插入和中序遍历（结果是有序的）的方法。

首先，我们定义一个二叉树节点的类：

public class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

然后，我们定义二叉搜索树类：

public class BinarySearchTree {
    TreeNode root;

    // 插入新节点
    public void insert(int value) {
        root = insertRecursive(root, value);
    }

    private TreeNode insertRecursive(TreeNode node, int value) {
        if (node == null) {
            return new TreeNode(value);
        }

        if (value < node.value) {
            node.left = insertRecursive(node.left, value);
        } else if (value > node.value) {
            node.right = insertRecursive(node.right, value);
        }

        return node;
    }

    // 中序遍历（左-根-右），结果是有序的
    public void inorderTraversal(TreeNode node) {
        if (node != null) {
            inorderTraversal(node.left);
            System.out.println(node.value);
            inorderTraversal(node.right);
        }
    }
}

最后，我们可以创建一个二叉搜索树实例并插入一些值，然后使用中序遍历来查看排序结果：

public class Main {
    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();

        bst.insert(50);
        bst.insert(30);
        bst.insert(20);
        bst.insert(40);
        bst.insert(70);
        bst.insert(60);
        bst.insert(80);

        bst.inorderTraversal(bst.root);
    }
}

运行上面的代码，你会看到输出结果是按升序排列的：20, 30, 40, 50, 60, 70, 80。这就是如何在Java中手写一个二叉树排序的例子。

五.手写树形数据结构

在Java中手写一个树形数据结构通常意味着实现一个基本的树结构，其中可以包括节点（Node）和树（Tree）类。节点类代表树中的单个元素，而树类代表整个树结构。以下是一个简单的树形数据结构的实现，包括节点类和树类。

首先，我们定义一个树节点类（TreeNode），它包含节点的值以及指向其子节点的引用：

public class TreeNode<T> {
    T value;
    TreeNode<T> left;
    TreeNode<T> right;

    public TreeNode(T value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

然后，我们可以定义一个树类（Tree），它包含一个根节点以及可能的一些树操作（如插入、遍历等）：

public class Tree<T> {
    TreeNode<T> root;

    public Tree(T value) {
        root = new TreeNode<>(value);
    }

    public Tree(TreeNode<T> root) {
        this.root = root;
    }

    // 插入新节点（假设这是一个二叉搜索树）
    public void insert(T value) {
        root = insertRecursive(root, value);
    }

    private TreeNode<T> insertRecursive(TreeNode<T> node, T value) {
        if (node == null) {
            return new TreeNode<>(value);
        }

        if (value.compareTo(node.value) < 0) {
            node.left = insertRecursive(node.left, value);
        } else if (value.compareTo(node.value) > 0) {
            node.right = insertRecursive(node.right, value);
        } else {
            // 值已存在，不插入
        }

        return node;
    }

    // 中序遍历（左-根-右）
    public void inorderTraversal(TreeNode<T> node) {
        if (node != null) {
            inorderTraversal(node.left);
            System.out.println(node.value);
            inorderTraversal(node.right);
        }
    }

    // 前序遍历（根-左-右）
    public void preorderTraversal(TreeNode<T> node) {
        if (node != null) {
            System.out.println(node.value);
            preorderTraversal(node.left);
            preorderTraversal(node.right);
        }
    }

    // 后序遍历（左-右-根）
    public void postorderTraversal(TreeNode<T> node) {
        if (node != null) {
            postorderTraversal(node.left);
            postorderTraversal(node.right);
            System.out.println(node.value);
        }
    }
}

在这个例子中，我们假设树是一个二叉搜索树（BST），这意味着对于树中的每个节点，其左子树中的所有元素值都小于该节点的值，而右子树中的所有元素值都大于该节点的值。

现在，我们可以创建一个Tree实例并插入一些值：

public class Main {
    public static void main(String[] args) {
        Tree<Integer> tree = new Tree<>(50);

        tree.insert(30);
        tree.insert(20);
        tree.insert(40);
        tree.insert(70);
        tree.insert(60);
        tree.insert(80);

        // 遍历树
        System.out.println("Inorder Traversal:");
        tree.inorderTraversal(tree.root);

        System.out.println("\nPreorder Traversal:");
        tree.preorderTraversal(tree.root);

        System.out.println("\nPostorder Traversal:");
        tree.postorderTraversal(tree.root);
    }
}

当你运行这个程序时，你将看到按照不同遍历顺序打印出来的节点值。中序遍历将给出排序后的结果。这个例子演示了如何在Java中手写一个简单的树形数据结构。当然，根据你的具体需求，你可以扩展这个基本框架来包括其他功能，如删除节点、查找节点、平衡树等。

 文章制作不易，如果有帮助的话，还希望能给个点赞和关注支持一下，谢谢大家！🙏🙏🙏

一只藏羚吖
关注
  • 19
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构之树（JAVA实现）
weixin_38419670的博客
02-18 7205
1. 什么是树 树（Tree）是一种抽象数据类型，用来模拟实现具有树状类型结构的数据集合。它具有n（n>=0）个有层次的有限结点。当n=0时，称为空树；n>0时，其余结点分为m个互斥的有限集合T1，T2，T3，每个集合分别称为子树。 2. 树的性质 3. ...
数据结构之二叉树（JAVA实现）
weixin_38419670的博客
02-22 1911
1. 什么是二叉树 满足以下两个条件的树称之为二叉树： 1. 本质上为有序树； 2. 每个结点的度不能超过2，即结点的度仅能为0，1，2。 2. 二叉树的性质 性质1：二叉树第i层的结点数最多为2^(i-1) (i>=1)。 性质2：深度为k的二叉树最多有2^k - 1个结点。 性质3：在任意一颗二叉树中，若终端结点（叶子结点）的个数为n0，度为2的结点树为n2，则n0=n2+1。 证明：设二叉树中度为1的结点数为n1，结点总数为n，则n = n0 + n1 +n2。同时，度为2的子结
【数据结构篇】手摸手带你学会如何手写一个栈
热爱编程、热爱生活、热爱探索
08-04 895
什么是栈？栈（stack）又名堆栈，它是一种运算受限的线性表，它只允许再表的一端进行插入和删除操作，这一端也称作栈的栈顶（Top），另一端称作栈底（Bottom）。栈的特点：栈中的数据元素先进后出（Last In First Out），所以也称栈为LIFO表栈的分类顺序栈和链栈顺序栈是指使用顺序存储结构实现的栈链栈是指使用链式存储结构实现的栈栈的应用：表达式求值、回溯功能的实现栈的基本操作出栈，获取栈顶的元素（栈中元素减一）入栈，向栈中添加一个元素E peek()取栈顶元素。
【数据结构】常用数据结构及其手写实现
qq_40900926的博客
11-01 328
1，常用数据结构 List：有序的线性存储结构； Set：元素不重复的存储结构，JDK有基于HashMap和TreeMap分别实现无序和有序Set； Queue：先进先出的存储结构； Stack：先进后出的存储结构； Map：Key-Value存储结构； Tree：树状存储结构；本文不展开分析此类 2，ArrayList和LinkedList简单实现 （1）ArrayList核心思想是利用数组，动态扩展大小；最大为2^32。通过数据实现，查找/修改时间复杂度为O(1)是删除/增加为O(n
算法（第四版）——栈
Finley.Hwang‘s Blog
09-18 433
定义 栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。  代码实现 链表实现 public class St...
手写栈stack
chenmi123321的博客
05-25 247
模板数据类型实现栈以下是一个基于C++的手写栈的示例代码，包括了栈的初始化、入栈、出栈、获取栈顶元素和判断栈是否为空等常用功能。以上示例代码中，我们使用了一个vector来存储栈中的元素。栈的入栈和出栈操作分别使用了vector的push_back和pop_back方法。获取栈顶元素和判断栈是否为空的操作也很简单，直接使用vector的back和empty方法即可。
手写栈（c++）
fclkx的博客
07-25 1274
手写栈
手写数据结构算法.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
Java_note：Java手写各数据结构，有效的Java笔记，Java基础知识
02-24
:cherry_blossom: DSLearning :cherry_blossom:总结线性表基本树堆高级树图 :cherry_blossom: Java闲杂点 :cherry_blossom: :cherry_blossom: 框架 :cherry_blossom: 弹簧靴 :cherry_blossom: IO :cherry_blossom:
java基础实现手写服务器
10-25
本教程将探讨如何利用Java基础知识来实现一个简单的服务器。首先，确保你的开发环境已经安装了Java Development Kit (JDK)，并且版本不低于1.9。这是因为自JDK 9开始，Java引入了一些重要的新特性，如模块系统，这对...
数据结构笔记
04-04
NULL 博文链接：https://masw123.iteye.com/blog/1497099
java手写识别超级准确
11-30
在手写识别项目中，Swing可以用来设计一个友好的用户界面，让用户能够方便地输入手写数据，展示识别结果，并进行其他操作。 "KNN"全称为K近邻算法（K-Nearest Neighbors），是一种简单而实用的监督学习算法。在手写...
手写 栈操作
浪人的专栏
05-04 301
stack.h #pragma once #include <iostream> using namespace std; class MyStack { public: MyStack(void); ~MyStack(void); MyStack(int size);//分配内存 初始化栈空间，设定栈最大容量，栈顶 bool st...
【数据结构篇】手写双向链表、单向链表（超详细）
热爱编程、热爱生活、热爱探索
08-05 2672
什么是链表？链表（Linked List）是用链式存储结构实现的线性表。链表的组成数据域引用域（数据域和引用域合称结点或元素）数据域存放数据元素自身的数据引用域存放相邻结点的地址链表的特点链表中元素的联系依靠引用域具有线性结构的特点，链表所使用的逻辑结构是线性结构具有链式存储结构的特点，所使用的物理存储结构是链式存储链表的分类单向链表：单链表是一种最简的链表，只有一个引用域1next特点：通过next可以访问到后继结点，终端结点的引用域指向null双向链表：具有两个引用域prev和next。
Java集合篇之逐渐被遗忘的Stack，手写一个栈你会吗？
JavaBuild的博客
02-18 409
其实在List的继承关系中，除了ArrayList和LinkedList之外，还有另外一个集合类stack（栈），它继承自vector，线程安全，先进后出，随着Java并发编程的发展，它在很多应用场景下被逐渐替代，成为了Java的遗落之类。入栈表示将元素放入栈顶，而出栈表示从栈顶取出元素。在Java的工具包中其实帮我们封装好了一个类，java.util.Stack，它所提供的方法并不多，我们通过一个小示例感受一下。通过上面的代码示例我们了解了一个栈所具备的功能特点，根据它的特点，我们尝试一下手写一个栈！
数据结构:线性表(代码 最详细最全 纯手写 纯C语言)ing
weixin_44954896的博客
06-08 561
线性表所有代码
常用数据结构讲解与案例分析
Lansonli（蓝深李）的博客
11-05 2799
数据结构是算法的基石，如果没有扎实的数据结构基础，想要把算法学好甚至融会贯通是非常困难的，而优秀的算法又往往取决于你采用哪种数据结构。 所以，接下来两节课的主题是，在算法面试中经常会被用到的数据结构以及一些实用技巧。同时穿插一些经典的题目，加深理解。这节课主要讲： 数组、字符串 链表 栈 队列 双端队列 树 数组、字符串（A...
数据结构(5.3_3)——由遍历序列构造二叉树
最新发布
m0_65240792的博客
07-25 103
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一只藏羚吖

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

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

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

打赏作者

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

抵扣说明：

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

余额充值