最常见数据结构实现

最新推荐文章于 2023-07-14 22:44:46 发布
置顶 最新推荐文章于 2023-07-14 22:44:46 发布
阅读量174 收藏 3
点赞数 1
分类专栏： 后台 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41157684/article/details/100094425
版权

最常见数据结构

1.栈（先进后出，后进先出）

在这里插入图片描述

   package stack;
    
    public class Mystack {
        private long[] arr;
        private int top;
    
        public Mystack(){
            arr = new long [10];
            top = -1;
        }
        public Mystack(int maxSize){
            arr = new long[maxSize];
            top = -1;
        }
    
        public void push(int value){
            arr[++top] = value;
        }
        
        public long pop(){
            return arr[top--];
        }
    
        public long peek(){
            return arr[top];
        }
    
        public boolean isEmpty(){
            return top==-1;
        }
        public boolean isFull(){
            return top == arr.length-1;
        }
    }
2.队列（先进先出）

在这里插入图片描述

package Queue;

public class MyQueue {
    private long[]arr;
    private int elements;//有效数据大小

    private int front;//队头
    private int end;//队尾

    public MyQueue(){
        arr = new long[10];
        elements = 0;
        front = 0;
        end = -1;
    }

    public MyQueue(int maxSize){
        arr = new long[maxSize];
        elements = 0;
        front = 0;
        end = -1;
    }

    //从队尾插入
    public void insert(long value){
        arr[++end] = value;
        elements++;
    }

    public long remove() {
        elements--;
        return arr[front++];
    }

    /**
     * 查看数据，从队头查看
     */
    public long peek() {
        return arr[front];
    }

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

    /**
     * 判断是否满了
     */
    public boolean isFull() {
        return elements == arr.length;
    }
}
3.循环队列（先进先出）

在这里插入图片描述


package Queue;

public class MyCycleQueue {
    private long[]arr;
    private int elements;//有效数据大小

    private int front;//队头
    private int end;//队尾

    public MyCycleQueue(){
        arr = new long[10];
        elements = 0;
        front = 0;
        end = -1;
    }

    public MyCycleQueue(int maxSize){
        arr = new long[maxSize];
        elements = 0;
        front = 0;
        end = -1;
    }

    //从队尾插入
    public void insert(long value){
        if(end == arr.length -1){
            end = -1;
        }
        arr[++end] = value;
        elements++;
    }

    public long remove() {
        long value = arr[front++];
        elements--;
        if(front == arr.length){
            front = 0;
        }
        return value;
    }

    /**
     * 查看数据，从队头查看
     */
    public long peek() {
        return arr[front];
    }

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

    /**
     * 判断是否满了
     */
    public boolean isFull() {
        return elements == arr.length;
    }
}
4.链表

在这里插入图片描述

节点Node

package LinkList;

public class Node {
    public long data;//数据域
    public Node next;//指针域

    public Node(long value){
        this.data = value;
    }

    public void display(){
        System.out.print(data+"");
    }
}
链表LinkList

package LinkList;

public class LinkList {
    /**
     * 链表
     */
    //头节点
    private Node first;

    public LinkList(){
        first = null;//可以不做，编译器默认为null
    }

    /**
     *
     * 插入节点，在头节点插入
     */
    public void insertFirst(long value){
        Node node = new Node(value);
        node.next = first;
        first = node;
    }

    /**
     * 删除一个结点，在头结点后进行删除
     */
    public Node deleteFirst() {
        Node tmp = first;
        first = tmp.next;
        return tmp;
    }

    /**
     * 显示方法
     */
    public void display() {
        Node current = first;
        while (current != null) {
            current.display();
            current = current.next;
        }
    }
    /**
     * 查找方法
     */
    public Node find(long value){
        Node current = first;
        while(current.data != value){
            if(current.next == null){
                return null;
            }
            current = current.next;
        }
        return current;
    }

    public Node delete(long value){
        Node current = first;
        Node previous = first;
        while (current.data!=value){
            if(current.next == null){
                return null;
            }
            previous = current;
            current = current.next;
        }
        //找到了
        if(current == first){
            first = first.next;
        }
        else{
            previous.next = current.next;
        }
        return current;
    }
}
5.双向链表

在这里插入图片描述

package LinkList.doublyLinklist;
public class Node {
    public long data;//数据域
    public Node next;//后一个node
    public Node previous;//前一个node
    public Node(){}
    public Node(long value){
        this.data = value;
    }
    public void display(){
        System.out.print(data+"");
    }
}

package LinkList.doublyLinklist;
public class Node {
    public long data;//数据域
    public Node next;//后一个node
    public Node previous;//前一个node
    public Node(){}
    public Node(long value){
        this.data = value;
    }
    public void display(){
        System.out.print(data+"");
    }
}


package LinkList.doublyLinklist;

public class LinkList {
    private Node head;//头节点
    private Node tail;//尾节点

    public Node getHead() {
        return head;
    }

    public void setHead(Node head) {
        this.head = head;
    }

    public Node getTail() {
        return tail;
    }

    public void setTail(Node tail) {
        this.tail = tail;
    }

    public LinkList(){
        head = null;
        tail = null;
    }

    //插入一个节点，在头节点插入

    public void insert(long value){
        Node node = new Node(value);
        if(isEmpty()){
            head = node;
            tail = node;
            head.next = null;
            head.previous = null;
        }
        else{
            head.next = node;
            node.previous = head;
            head = node;
            head.next = null;
        }
    }
    //从头部删除
    public Node delete(){
        Node node = new Node();
        if(head.next == null && head.previous ==null){
            head = null;
            tail = null;
            return null;
        }
        else {
            node = head;
            head = head.previous;
            head.next.previous =null;
            head.next = null;
            return node;
        }
    }
    public boolean isEmpty(){
        return (head == null);
    }
    public void display() {
        if (!isEmpty()) {
            head = tail;
            if (head.next == null && head.previous == null) {
                System.out.println(head.data);
            }else {
                while (head != null) {
                    System.out.print(head.data + " ");
                    if(head.next!=null)
                    head = head.next;
                    else break;
                }
            }
        } else {
            System.out.println("empty");
        }
    }
}
6.循环链表

在这里插入图片描述
循环链表是将普通链表的头节点的后续指针指向尾，把尾节点的前驱指针指向头节点。

7.双向循环链表

在这里插入图片描述
双向循环链表是将双向链表的头节点的后续指针指向尾，把尾节点的前驱指针指向头节点。

8.二叉树

背景：有序数组插入数据项和删除数据项太慢，链表查询速度太慢
树中能非常快速的查找数据项、插入数据项跟删除数据项

前序遍历：

1.访问根节点
2.前序遍历左子树
3.前序遍历右子树

/**
 *  前（先）序遍历
 */
public void preOrder(Node node){
    if(node != null) {
        System.out.print(node.getData()+" ");
        preOrder(node.getLeftChild());
        preOrder(node.getRightChild());
    }
}
中序遍历：

1.中序遍历左子树
2.访问根节点
3.前序遍历右子树

/**
 * 中序遍历
 */

public void inOrder(Node node){
    if(node != null) {
        inOrder(node.getLeftChild());
        System.out.print(node.getData()+" ");
        inOrder(node.getRightChild());

    }
}
后序遍历：

1.后序遍历左子树
2.后序遍历右子树
3.访问根节点

/**
 * 后续遍历
 */
public void postOrder(Node node){
    if(node != null) {
        postOrder(node.getLeftChild());
        postOrder(node.getRightChild());
        System.out.print(node.getData()+" ");
    }

}

二叉树的基本构造以及其操作

节点构造：
package tree.binaryTree;

public class Node {
    private int data;
    private Node leftChild;//左子节点
    private Node rightChild;//右子节点

    public int getData() {
        return data;
    }

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

    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 Node(int data) {
        this.data = data;

    }

    public Node() {

    }
}
二叉树构造：
public class BinaryTree {
    private Node root;//根节点

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }
  }
插入二叉树的节点：原则：左边比右边小
public void insert(int value){//构造二叉搜索树，二叉排序树，
    Node newNode = new Node(value);
    Node parent;
    Node current = root;
    if (current == null){
        root = newNode;
        return;
    }
    else{
        while (true){
            parent = current;
            if(current.getData() >= value){
                if(current.getLeftChild() != null){
                    current = current.getLeftChild();
                }
                else {
                    current.setLeftChild(newNode);
                    return;
                }
            }
            else {
                if(current.getRightChild() != null){
                    current = current.getRightChild();
                }
                else {
                    current.setRightChild(newNode);
                    return;
                }
            }
        }
    }
}
查找节点
public Node find(int value){
    Node current = root;
    while (current.getData()!= value){
        if (current.getData()>value){
            current = current.getLeftChild();
        }
        else{
            current = current.getRightChild();
        }
        if (current == null){
            return null;
        }
    }
    return current;
}
删除二叉树的节点：

1.该节点是叶子节点
只需要改变该节点父节点的引用值，设置其为null就行了
2.该节点有一个子节点
改变父节点的引用，将其直接指向要删除节点的子节点
3.该节点有两个子节点
需要使用他的中序后继来替代该节点。

中序后继：该节点的右子树节点的左子树的左子树的左子树的最后一个左节点，如果该节点只有一个右节点，则为该右节点

public void delete(int value){
    Node current = root;
    Node parent = root;
    while (current.getData()!= value){
        if (current.getData()>value){
            parent = current;
            current = current.getLeftChild();
        }
        else{
            parent = current;
            current = current.getRightChild();
        }
        if (current == null){
            System.out.println("该节点不存在，无法删除");
        }
    }
    //叶子节点
    if(current.getLeftChild()==null && current.getRightChild() == null){
        if (current == parent.getLeftChild()){
            parent.setLeftChild(null);
        }
        else{
            parent.setRightChild(null);
        }
    }
    //该节点右节点为空，左节点不为空
    else if(current.getLeftChild()!=null&&current.getRightChild() == null){
        if(current == parent.getLeftChild()){
            parent.setLeftChild(current.getLeftChild());
            current.setLeftChild(null);
        }
        else{
            parent.setRightChild(current.getLeftChild());
            current.setLeftChild(null);
        }
    }
    //该节点左节点为空，右节点不为空
    else if (current.getLeftChild()==null&& current.getRightChild()!=null){
        if(current == parent.getLeftChild()){
            parent.setLeftChild(current.getRightChild());
            current.setRightChild(null);
        }
        else{
            parent.setRightChild(current.getRightChild());
            current.setRightChild(null);
        }
    }
    //该节点左右节点均不为空
    else{
        if(current.getRightChild().getLeftChild() == null){
            if (current == parent.getLeftChild()){
                parent.setLeftChild(current.getRightChild());
            }
            else{
                parent.setRightChild(current.getRightChild());
            }
            current.getRightChild().setLeftChild(current.getLeftChild());
        }
        else{
            Node node = current.getRightChild();
            Node node1 = node;
           while (node.getLeftChild() != null){
               node1 = node;
               node = node.getLeftChild();
           }
           if (parent.getRightChild() == current){
               parent.setRightChild(node);

           }
           else{
               parent.setLeftChild(node);
           }
           node1.setLeftChild(node.getRightChild());
           node.setLeftChild(current.getLeftChild());
           node.setRightChild(current.getRightChild());
        }
    }
}
我不是前端仔
关注
专栏目录
常见数据结构的实现
08-01
内容包括:链表,循环链表,栈，双向队列，队列的链表实现方式,队列的栈实现方式,排序二叉树的创建，插入，删除，显示，销毁，查找等，带测试函数，所有函数均测试通过，参考的是严蔚敏的数据结构与算法跟算法导论
常用数据结构的实现
CSDN_XCS的博客
03-29 188
二叉树 （本来是想使用vector<string>以及智能指针 写出一个二叉树的类 来，暂时没成功。如果有大神愿意帮忙给出思路，欢迎评论留言） 构建二叉树 为什么 必须要使用二级指针？参考博文链接 【结论】：必须使用二级指针的本质原因，是因为我们要改变一级指针的值。 ...
常见数据结构的底层实现
weixin_43680711的博客
03-15 334
数据结构基础知识点： 常见12种数据结构： 面试常考：数组，栈，队列，链表，二分搜索树，堆 线段树，Trie，并查集，AVL，红黑树，哈希表。
常见数据结构的C语言实现
qq_42885747的博客
02-28 772
#include <stdio.h> int main() { int team[10]={0}; int head=0; int tail=0; team[tail++]=1; //在队列尾部插入元素，同时尾部索引后移 team[tail++]=2; team[tail++]=3; head++; ...
数据结构——各种常见算法的实现方法和思路
勇气是明知不可为而为之
07-14 2443
桶排序是一种线性排序算法，它的基本思想是将待排序的元素分到不同的桶中，每个桶内的元素再分别使用其他排序算法进行排序，最后合并所有桶中的元素即可得到有序序列。具体实现中，选择排序从未排序序列中找到最小（或最大）的元素，然后将它与未排序序列的第一个元素交换，这样就可以把该元素放到已排序序列的末尾。最后当增量为1时，整个序列就变成了一个有序序列。选择排序（Selection Sort）是一种简单直观的排序算法，其核心思想是在未排序序列中选择最小（或最大）的元素，放到已排序序列的末尾，直到所有元素都排完为止。
常见数据结构与算法C语言实现
05-04
# 常见数据结构与算法C语言实现 内容包含常见基本数据结构实现（C语言版）如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等 以及包含各个数据结构常见算法题的解答（C语言版...
八种常见数据结构汇总+图解+代码实现.pdf
最新发布
08-21
八种常见数据结构汇总+图解+代码实现.pdf
实现常见算法、数据结构以及 Leetcode 经典题目
08-20
实现常见算法、数据结构以及 Leetcode 经典题目
用go实现常见的数据结构.md
11-02
golang常见数据结构实现 链表，可变数组，栈和队列，字典Map和集合Set
Java常见数据结构实现
08-20
Java常见数据结构实现，队列，二叉树等等
1.各种数据结构简介与实现
Xiaoyc7的博客
07-08 542
本篇文章旨在实现各种数据结构，(或者说基本不介绍)，要看具体详情可以参考《在 JavaScript 中学习数据结构与算法》这篇博客栈(Stack)：后进先出 2.队列 队列(Queue)：先进先出 2.1 优先队列 优先队列是队列的变种，由项的的值决定其在队列中的优先级 2.2 循环队列 循环队列是队列的另一个变种，可以实现队列索引循环 3.链表 链表(LinkedList)：每个元素都有一个保存下一个元素的指针，第一个元素为，如下图所示： 3.1 双向链表 指定最后一个元素为， 4.集合 集合(s
数据结构篇—八大数据结构及代码实现
qq_33451695的博客
04-04 1866
八大数据结构及实现一、简述二、基本的概念三、Array1、介绍2、模拟实现四、Stack1、介绍2、模拟实现五、Queue1、介绍2、模拟实现六、Linked List1、介绍2、模拟实现七、Binary Tree1、介绍2、**模拟实现**八、Heap1、介绍2、堆的应用：3、堆的实现：4、根据数组构建大顶堆5、大顶堆的实现6、小顶堆的实现九、Hashing1、介绍2、实现HashMap十、Graph 一、简述 ​ 在编程过程中，经常会遇到一个问题就是，性能瓶颈，很多时候考虑的都是怎么去做横向扩展，但偏
数据结构的几种基础实现
筱寒小记
05-30 1117
数据结构的几种基础实现 数据结构是计算机专业的一门重要的基础课，它的教学要求大致有三个重要方面：第一就是让学生学会分析研究计算机加工的数据对象的特性，确定数据的逻辑结构和适当的物理结构；第二，根据结构，设计适当的算法，并初步掌握算法的时间分析和空间分析；第三，学习复杂的程序设计。 实验一、有序表的建立、插入与删除 一、实验目的 1 了解有序表的顺序存储结构。 2 掌握有序表元素在内存中是怎样存储的...
C++常用数据结构的实现
WGH100817的博客
11-22 2101
常用数据结构与算法的实现、整理与总结 我将我所有数据结构的实现放在了github中：Data-Structures-Implemented-By-Me 常用数据结构与算法的实现、整理与总结 KMP字符串匹配算法 环状队列 走迷宫算法 中缀表达式转后缀表达式 环装链表 双向链表 树 二叉树 树的广度优先搜索 二叉树的遍历 二叉树的非递归遍历 胜者树与败者树 ALV树 最...
常见数据结构及代码实现
5683的博客
10-23 2053
1 Stack：栈 1.1 介绍 一种线性表，只允许在线性表的一端进行操作，即栈顶允许操作，而栈底不允许，像个桶状物，可以通过桶顶往桶里取放物品，而不能对桶底做什么，而且先放入桶中的物品总是在更底部，这就形成了栈的一个特性：先入后出。 1.2 时间复杂度 因为无论是入栈还是出栈，每次操作的都是栈最顶部的那一个数据，所以出入栈的时间复杂度都是：O(1) 1.3 适用场景 先入而后出的特点和递归的使用十分契合。 1.4 代码实现 1.4.1 实现思路 JDK1.8的Stack类源码中有6个方法，这里我们实现其中
几种常见的数据结构的java实现
wlyrain2011的博客
04-06 3119
常见的数据结构有  栈  队列  链表  二叉树  栈 ：先进先出 队列：先进后出 对数据结构的操作常见的有  增 删 改 查 下面分别介绍这几种数据结构的实现方式: 1)栈   Stack 栈可以用数组实现也可以用列表实现，两种方式均有top变量来标识栈顶，maxSize来标识栈的最大容量，栈的常见方法为push  pop  peek  isEmpty  isFull（通过top
数据结构与算法——常用高级数据结构及其Java实现
weixin_34236869的博客
03-04 725
前文 数据结构与算法——常用数据结构及其Java实现 总结了基本的数据结构，类似的，本文准备总结一下一些常见的高级的数据结构及其常见算法和对应的Java实现以及应用场景，务求理论与实践一步到位。 跳跃表 跳跃列表是对有序的链表增加上附加的前进链接，增加是以随机化的方式进行的，所以在列表中的查找可以快速的跳过部分列表。是一种随机化数据结构，...
常见数据结构与算法整理总结（上）
热门推荐
mrchige的博客
09-24 1万+
数据结构是以某种形式将数据组织在一起的集合，它不仅存储数据，还支持访问和处理数据的操作。算法是为求解一个问题需要遵循的、被清楚指定的简单指令的集合。下面是自己整理的常用数据结构与算法相关内容，如有错误，欢迎指出。 为了便于描述，文中涉及到的代码部分都是用Java语言编写的，其实Java本身对常见的几种数据结构，线性表、栈、队列等都提供了较好的实现，就是我们经常用到的Java集合框架。
数据结构入门与常见问题详解
- 第1章绪论介绍了数据结构的基本概念，包括常见的数据结构类型，如线性结构（如数组和队列）、树形结构（如二叉树）和图形结构（图），以及数据结构中的基本单位——数据元素。此外，还区分了数据结构中的逻辑关系...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值