java实现的数据结构

最新推荐文章于 2024-01-11 12:08:16 发布
最新推荐文章于 2024-01-11 12:08:16 发布
阅读量130 收藏 1
点赞数
分类专栏： java 文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alaskan_Husky/article/details/134469869
版权

数据结构是计算机科学中用于组织和存储数据的方式，通常涉及在计算机上执行的各种操作。以下是一些常见的数据结构：

1.数组

由相同类型的元素组成的有序集合，通过索引访问

public class ArrayFeatures {
    public static void main(String[] args) {
        // 声明和初始化整数数组
        int[] intArray = {1, 2, 3, 4, 5};

        // 访问数组元素
        int firstElement = intArray[0];
        int lastElement = intArray[intArray.length - 1];

        // 修改数组元素
        intArray[2] = 30;

        // 获取数组长度
        int arrayLength = intArray.length;

        // 遍历数组
        System.out.println("Array elements:");
        for (int num : intArray) {
            System.out.println("Element: " + num);
        }

        // 声明和初始化二维数组
        int[][] twoDArray = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
        int element = twoDArray[1][2];

        // 数组的拷贝
        int[] copiedArray = Arrays.copyOf(intArray, intArray.length);

        // 数组排序
        Arrays.sort(intArray);
    }
}

2.链表

链表（Linked List）是一种基本的数据结构，它由节点（Node）组成，每个节点包含数据和指向下一个节点的引用。Java中的链表可以通过LinkedList类实现，以下是链表的一些主要特性：

  • 动态大小： 链表的大小可以动态增长或缩小，不像数组在创建时需要指定大小。

  • 节点结构： 每个节点包含数据和指向下一个节点的引用。

class Node {
    int data;
    Node next;

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}
  • 单链表和双链表： 单链表中每个节点只有一个指向下一个节点的引用，而双链表中每个节点有一个指向前一个节点和一个指向后一个节点的引用。

  • 头结点： 链表的开头通常有一个特殊的节点称为头结点，它不包含实际的数据，仅用于标识链表的起始位置。

  • 尾节点： 链表的末尾通常有一个特殊的节点称为尾节点，它的next指向null，表示链表的结束。

  • 插入和删除操作： 链表的插入和删除操作效率较高，只需调整节点的引用。

// 在链表末尾插入新节点
Node newNode = new Node(42);
lastNode.next = newNode;

// 删除指定节点
previousNode.next = currentNode.next;

  • 遍历： 可以通过循环遍历整个链表，访问每个节点的数据。

Node current = head;
while (current != null) {
    System.out.println(current.data);
    current = current.next;
}

  • 搜索： 可以按值或索引搜索链表中的节点。

// 搜索具有特定值的节点
Node current = head;
while (current != null) {
    if (current.data == targetValue) {
        // 找到了
        break;
    }
    current = current.next;
}

  • 反转： 可以反转整个链表，改变节点的引用方向。

Node prev = null;
Node current = head;
Node next = null;

while (current != null) {
    next = current.next; // 保存下一个节点的引用
    current.next = prev; // 反转当前节点的引用方向
    prev = current;      // 移动到下一个节点
    current = next;      // 移动到下一个节点
}

head = prev; // 新的头节点

  • 循环检测： 可以检测链表中是否存在循环。

boolean hasCycle(Node head) {
    Node slow = head;
    Node fast = head;

    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;

        if (slow == fast) {
            return true; // 链表中存在循环
        }
    }

    return false; // 链表中不存在循环
}

3.栈

栈（Stack）是一种后进先出（Last In First Out，LIFO）的数据结构，它具有以下主要特性：

  • 动态大小： 栈的大小可以动态增长或缩小。

  • 基本操作： 栈支持两个基本操作：push（入栈）和pop（出栈）。

    • push(element): 将元素压入栈顶。
    • pop(): 弹出栈顶元素。

  • 栈顶和栈底： 栈顶是最后压入栈的元素，栈底是最先压入栈的元素。

  • 空栈： 栈可以为空，即不包含任何元素。

  • 栈的实现： 可以使用数组或链表实现栈

      --用数组实现：

public class Stack {
    private int maxSize;
    private int[] stackArray;
    private int top;

    public Stack(int size) {
        maxSize = size;
        stackArray = new int[maxSize];
        top = -1;
    }

    public void push(int value) {
        if (top < maxSize - 1) {
            stackArray[++top] = value;
        } else {
            System.out.println("Stack overflow. Cannot push " + value);
        }
    }

    public int pop() {
        if (top >= 0) {
            return stackArray[top--];
        } else {
            System.out.println("Stack underflow. Cannot pop.");
            return -1; // Error code indicating underflow
        }
    }

    public int peek() {
        if (top >= 0) {
            return stackArray[top];
        } else {
            System.out.println("Stack is empty. Cannot peek.");
            return -1; // Error code indicating empty stack
        }
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public boolean isFull() {
        return top == maxSize - 1;
    }
}

      --链表实现 

public class LinkedStack {
    private Node top;

    private class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    public void push(int value) {
        Node newNode = new Node(value);
        newNode.next = top;
        top = newNode;
    }

    public int pop() {
        if (!isEmpty()) {
            int value = top.data;
            top = top.next;
            return value;
        } else {
            System.out.println("Stack is empty. Cannot pop.");
            return -1; // Error code indicating empty stack
        }
    }

    public int peek() {
        if (!isEmpty()) {
            return top.data;
        } else {
            System.out.println("Stack is empty. Cannot peek.");
            return -1; // Error code indicating empty stack
        }
    }

    public boolean isEmpty() {
        return top == null;
    }
}

  • 应用场景： 栈常用于需要后进先出操作的场景，如表达式求值、括号匹配、深度优先搜索（DFS）等。

  • 调用栈： 在编程中，栈用于管理函数调用过程，保存函数的局部变量、返回地址等信息。

  • 递归： 递归函数的调用过程也涉及栈的使用。

 

4.队列

队列（Queue）是一种先进先出（First In First Out，FIFO）的数据结构，具有以下主要特性：

  • 动态大小： 队列的大小可以动态增长或缩小。

  • 基本操作： 队列支持两个基本操作：enqueue（入队）和dequeue（出队）。

    • enqueue(element): 将元素加入队列尾部。
    • dequeue(): 从队列头部移除元素。

  • 队头和队尾： 队头是最先进队的元素所在位置，队尾是最后进队的元素所在位置。

  • 空队列： 队列可以为空，即不包含任何元素。

  • 队列的实现： 可以使用数组或链表实现队列。

    • 数组实现： 使用固定大小的数组，队列的大小有限。

public class Queue {
    private int maxSize;
    private int[] queueArray;
    private int front;
    private int rear;

    public Queue(int size) {
        maxSize = size + 1; // One extra space for the rear pointer to maintain the circular nature
        queueArray = new int[maxSize];
        front = 0;
        rear = 0;
    }

    public void enqueue(int value) {
        if (!isFull()) {
            queueArray[rear] = value;
            rear = (rear + 1) % maxSize;
        } else {
            System.out.println("Queue is full. Cannot enqueue " + value);
        }
    }

    public int dequeue() {
        if (!isEmpty()) {
            int value = queueArray[front];
            front = (front + 1) % maxSize;
            return value;
        } else {
            System.out.println("Queue is empty. Cannot dequeue.");
            return -1; // Error code indicating empty queue
        }
    }

    public int peek() {
        if (!isEmpty()) {
            return queueArray[front];
        } else {
            System.out.println("Queue is empty. Cannot peek.");
            return -1; // Error code indicating empty queue
        }
    }

    public boolean isEmpty() {
        return front == rear;
    }

    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }
}

  • 链表实现： 使用链表作为底层结构，队列的大小可以动态变化。

 

public class LinkedQueue {
    private Node front;
    private Node rear;

    private class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    public void enqueue(int value) {
        Node newNode = new Node(value);
        if (isEmpty()) {
            front = newNode;
            rear = newNode;
        } else {
            rear.next = newNode;
            rear = newNode;
        }
    }

    public int dequeue() {
        if (!isEmpty()) {
            int value = front.data;
            front = front.next;
            if (front == null) {
                rear = null; // 队列为空，重置rear
            }
            return value;
        } else {
            System.out.println("Queue is empty. Cannot dequeue.");
            return -1; // Error code indicating empty queue
        }
    }

    public int peek() {
        if (!isEmpty()) {
            return front.data;
        } else {
            System.out.println("Queue is empty. Cannot peek.");
            return -1; // Error code indicating empty queue
        }
    }

    public boolean isEmpty() {
        return front == null;
    }
}

  • 应用场景： 队列常用于需要先进先出操作的场景，如任务调度、广度优先搜索（BFS）等。

  • 优先队列： 优先队列是一种特殊的队列，其中的元素按照优先级顺序出队。

  • 循环队列： 队列可以采用循环方式实现，当队列满时，新元素可以放到队列头部，形成循环。

  • 阻塞队列： 阻塞队列是在队列为空或满时会阻塞等待的队列，常用于多线程编程。

。。。。

阿狸轰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现数据结构
11-10
Java作为一种广泛使用的编程语言，提供了丰富的库和工具来实现各种数据结构。下面将详细介绍Java中实现链表、栈、队列、优先级队列以及哈希表这些基本数据结构的方法。 首先，我们来看链表。链表是一种线性数据结构...
用java实现数据结构，形成文档以及代码.zip
最新发布
06-16
总的来说，这个"用java实现数据结构，形成文档以及代码.zip"文件对于正在学习数据结构的大学生来说是一份宝贵的资源，它将理论知识与实际编程相结合，有助于提升学生的编程技能和问题解决能力。
java中常见数据结构
gengpengfeiazxl的博客
04-18 4436
java中常见的数据结构
Java数据结构及原理实现
热门推荐
jackhuang17的博客
07-21 1万+
程序设计主要是数据结构+算法，而数据结构在面向对象思维里是“容器”的意思，数据结构主要负责数据的添加，删除，修改，查找及对数据的其他操作。编程里面对着不同问题场景，选择哪种数据结构进行操作就非常重要。试想：如果谷歌是以数组来存储数据的话，还会有那么快的搜索速度？所以下面就简单介绍java数据结构的体系和部分原理实现java集合体系结构图集合父接口Collection，Map和集合工具类Collect
Java-数据结构-动态数组的实现
QWERTYUIef的博客
10-15 119
移除元素的方法，还是先判断是否在合法的区间内，再将当前元素赋值给oldE，因为删除后，当前元素会为空，所以所以要把所有的元素向前覆盖，即通过一个for循环，因为values[size]没有元素，所以for循环中的最大值应该为size-1，因为移除元素后，数组的长度减少了，所以size--，长度减一，即为目前数组的长度。然后将原数组中的所有变量传入到新数组中，然后将新数组的对象变量名中存储的新数组的内存地址赋值给旧数组名，最后再更新一下数组的长度，这样，我们数组的扩容就完成了。数组中存储的元素都是数据元素。
【入门必备】Java数据结构详解
weixin_62633072的博客
03-15 8654
数据结构入门必看！本文整理了稀疏数组、队列、链表、栈这几种经典的数据结构。快来一起敲代码吧！！！
数据结构（Java实现）-Map和Set
qq_43570634的博客
09-03 549
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。那如何寻找下一个空位置呢？由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率。对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。
Java超详细！Java实现数据结构PPT课件
02-24
线性数据结构动态数组（ArrayList） 链表（LinkedList） 单向链表 双向链表 循环链表 静态链表 栈（Stack） 队列（Queue） 双端队列（Deque） 循环队列 哈希表（HashTable） 树形数据结构 二叉树（BinaryTree）、...
java实现数据结构常见排序算法及详解
11-08
详细讲述了8中常见算法的原理及思想，并用JAVA进行了实现，代码中有详细的注释，解释了算法的实现逻辑和一些小技巧。
数据结构java实现
weixin_44333359的博客
04-09 1038
一.数据结构的内容 逻辑结构：关联关系，邻里关系。 存储结构:数据元素+关联方式。 运算：对逻辑结构的加工。 1.算法特性： 有穷性：指令序列是有限的 确定性：每条语句的含义明确，无二义性 可行性：每条语句都应在有限的时间内完成 输入：零个或者多个输入 输出：一个或者多个输出 2.程序 程序=数据结构+算法+程序设计方法+编程语言 **程序是算法用某种程序设计语言的具体实现。**程序可以不满足算...
java-数据结构代码实现
11-15
通过java实现数据结构的一些内容，里面有一些测试，不过没有完全按照书上代码实现，但是值得参考。(jdk1.7+junit 4 编码:utf8)
JAVA基本5种数据结构的实现。
04-26
java中基本的 站 队列等基本数据结构。
Java 算法常用数据结构实现
XiangBing15的博客
05-02 1010
目录线性表数组排序查找List排序队列示例基本方法栈示例树说明堆（完全二叉树）图实现一： HashMap + List实现二：二维数组散列示例 线性表 数组 排序 基础类型排序（升序） Arrays.sort(int[] arr) 自定义排序 //students 按照age升序排序 Arrays.sort(students, new Comparator<Student>() { @Override public int compare(Student o1, Studen
总结java中常用数据结构和实现原理
jiaoyaqiang的博客
01-11 387
哈希表-的实现原理是用数组和链表来实现，它在代码中的体现是使用一个数组来存储哈希值，然后使用链表来存储具有相同哈希值的元素，通过哈希函数来计算元素的哈希值，并根据哈希值来确定元素的存储位置。二叉树-的实现原理是用节点来存储数据，每个节点最多有两个子节点，它在代码中的体现是使用结构体来表示节点，然后通过指针来连接节点，通过递归的方式来遍历二叉树。数组-的实现原理是用连续的内存空间来存储数据，它在代码中的体现是使用一个整数类型的指针来指向数组的首地址，然后通过索引来访问数组中的元素。
Java中常用数据结构及方法
Liususiu的秃头日记
12-18 2536
记录总结Java中常用的结构和方法。
Java实现--数据结构--栈
热爱生活，热爱她
02-14 170
Java语言实现栈数据结构
面试常考的数据结构Java实现
weixin_33770878的博客
10-29 183
1、线性表 2、线性链表 3、栈 4、队列 5、串 6、数组 7、广义表 8、树和二叉树 二叉树：每个结点至多只有两棵子树（即二叉树中不存在度大于2的结点），并且，二叉树的子树有左右之分，其次序不能任意颠倒。 二叉树的性质： 　　性质1：在二叉树的第i层上至多有2i-1个结点。 　　性质2：深度为k的二叉树至多有2k-1个结点（k>=1）。 　　性质3：对任何一颗...
数据结构（java语言实现）
add_del的博客
09-03 8556
                                                 数据结构（java语言实现） 基本概念        数据：信息的载体        数据结构：大量具有特定组织关系的数据在内存中的存储及其使用 组织关系：        数据的前后关系   也就是逻辑结构        1对1  线性关系    线性结构        1对n  非线性...
底层数据结构链表，以及java代码实现
麦田里的守望者
04-30 393
[原文：底层数据结构链表，以及java代码实现]（https://jums.club/java-link/） 1 原理介绍 链表和数组的区别在于，数组的插入和删除操作需要整个数组一起跟着动，这样的效率很低。举个例子：打麻将时，当有一个麻将子，其大小正好在已经排序好的麻将中间，如果需要插入进原来的麻将序列，那么需要将之前或者之后的麻将全部移动，这样很费时间，所以链表可以弥补这种不足。 1.1 增 链...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值