数据结构：java实现链表，并用链表实现栈和队列

最新推荐文章于 2024-08-17 08:59:42 发布
最新推荐文章于 2024-08-17 08:59:42 发布
阅读量189 收藏 2
点赞数
分类专栏： 笔记 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45649686/article/details/111418607
版权

1.链表

1.概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
在这里插入图片描述
头指针：
（1）标识链表，即链表的名字；
（2）存储链表中的第一个结点的地址。
尾指针：
尾指针即链表的最后一个结点，没有后继，因此指针域必须置空，即NULL。

2.java实现链表

public class LinkedArray<T> {
    //内部类
    private class Node<T>{
        T ele;
        Node next;
        public Node(T ele){
            this.ele = ele;
            this.next = null;
        }
        public Node(){
            this(null);
        }

        public Node(T ele,Node next){
            this.ele = null;
            this.next = null;
        }
        @Override
        public String toString(){
            return this.ele.toString();
        }
    }
    //链表长度
    private int size;
    //虚拟头结点
    private Node dummyHead;
    //获得链表长度
    public int getSize(){
        return size;
    }
    //判断链表是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    public LinkedArray(){
        this.size = 0;
        this.dummyHead = new Node(null,null);
    }

    //向链表头部添加元素
    public void addHead(T ele) throws IllegalAccessException {
        //add(ele,0);
        Node node = new Node(ele);
        if(node == null){
            throw new IllegalAccessException("节点为空");
        }
        node.next = dummyHead.next;
        dummyHead.next = node;
        size++;
    }

    public void add(T ele,int index) throws IllegalAccessException{
        Node node = new Node(ele);
        if(node == null){
            throw new IllegalAccessException("结点为空");
        }
        if(index<0 || index>size){
            throw new IllegalAccessException("索引越界！");
        }
        Node prev = dummyHead;
        for(int i=0;i<index;i++){
            prev = prev.next;
        }
        //插入操作
        node.next = prev.next;
        prev.next = node;
        size++;
    }

    public void addTail(T ele) throws IllegalAccessException{
        //add(ele,size);
        Node node = new Node(ele);
        if(node == null){
            throw new IllegalAccessException("节点为空");
        }
        Node prev = dummyHead;
        for(int i=0;i<size;i++){
            prev = prev.next;
        }
        prev.next = node;
        size++;
    }

    //获取头节点元素
    public T getHead() throws IllegalAccessException{
        return get(0);
    }

    //获取最后一个元素
    public T getTail() throws IllegalAccessException{
        return get(size-1);
    }

    //获取任意位置上的元素
    public T get(int index) throws IllegalAccessException{
        if(index<0 || index>=size){
            throw new IllegalAccessException("索引错误！");
        }
        Node current = dummyHead.next;
        for(int i=0;i<index;i++){
            current = current.next;
        }
        return current == null?null:(T)current.ele;
    }

    //判断链表中是否含有指定元素
    public boolean contains(T ele){
        Node current = dummyHead.next;
        while (current != null){
            if(current.ele.equals(ele)){
                return true;
            }else {
                current = current.next;
            }
        }
        return false;
    }

    //更新节点
    public void set(int index,T ele) throws IllegalAccessException{
        if(index<0 || index>=size){
            throw new IllegalAccessException("索引越界!");
        }
        Node current = dummyHead.next;
        for(int i=0;i<index;i++){
            current = current.next;
        }
        current.ele = ele;
    }

    //删除指定位置元素
    public T remove(int index) throws IllegalAccessException{
        if(index<0 || index>=size){
            throw new IllegalAccessException("索引越界！");
        }
        Node prev = dummyHead;
        for(int i=0;i<index;i++){
            prev = prev.next;
        }
        Node delNode = prev.next;
        prev.next = delNode.next;
        delNode.next = null;
        T ele = (T)delNode.ele;
        size--;
        return ele;
    }

    @Override
    public String toString(){
        StringBuffer sb = new StringBuffer();
        Node current = dummyHead.next;
        while (current!=null){
            sb.append(current.ele+"--->");
            current = current.next;
        }
        sb.append("NULL");
        return sb.toString();
    }
}

3. 链表实现栈


public class LinkedStack<T> implements Stack<T> {
    private LinkedArray<T> data; //数据容器
    private int size;
    public LinkedStack(){
        data = new LinkedArray<>();
        size = 0;
    }

    @Override
    public T pop() throws IllegalAccessException {
        T ele = data.remove(0);
        size--;
        return ele;
    }

    @Override
    public void push(T ele) throws IllegalAccessException {
        data.addHead(ele);
        size++;
    }

    @Override
    public T peek() throws IllegalAccessException {
        return data.getHead();
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return data.isEmpty();
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("栈顶");
        sb.append("[");
        sb.append(data.toString());
        sb.append("]");
        return sb.toString();
    }
}

4.链表实现队列


public class LinkedQueue<T> implements Queue<T> {
    private LinkedArray<T> data;
    private int size;
    public LinkedQueue(){
        data = new LinkedArray<>();
        size = 0;
    }
    @Override
    public void enqueue(T ele) throws IllegalAccessException {
        data.addTail(ele);
        size++;
    }

    @Override
    public T dequeue() throws IllegalAccessException {
        T ele = data.remove(0);
        size--;
        return ele;
    }

    @Override
    public T getFront() throws IllegalAccessException {
        return data.getHead();
    }

    @Override
    public boolean isEmpty() {
        return data.isEmpty();
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("对首");
        sb.append("[");
        sb.append(data.toString());
        sb.append("]");
        sb.append("队尾");
        return sb.toString();
    }
}

5.测试


public class Test {
    public static void main(String[] args) throws IllegalAccessException {
        Test test = new Test();
        //test.linkedTest();
       //test.stackTest();
        test.queueTest();
    }

    public void linkedTest() throws IllegalAccessException {
        LinkedArray<Integer> linked = new LinkedArray<>();
        System.out.println(linked.isEmpty());//true
        for(int i=0;i<100;i++){
            if(i%10 == 0){
                linked.addTail(i);
            }
        }
        System.out.println(linked);//0--->10--->20--->30--->40--->50--->60--->70--->80--->90--->NULL
        System.out.println(linked.isEmpty());//false
        linked.remove(2);
        System.out.println(linked);//0--->10--->30--->40--->50--->60--->70--->80--->90--->NULL
        linked.set(4,12);
        System.out.println(linked);//0--->10--->30--->40--->12--->60--->70--->80--->90--->NULL
        linked.addHead(12);
        System.out.println(linked);//12--->0--->10--->30--->40--->12--->60--->70--->80--->90--->NULL
        linked.add(22,2);
        System.out.println(linked);//12--->0--->22--->10--->30--->40--->12--->60--->70--->80--->90--->NULL
    }

    public void stackTest() throws IllegalAccessException {
        LinkedStack<Integer> linkedStack = new LinkedStack<>();
        System.out.println(linkedStack.isEmpty());//true
        for(int i = 0;i<100;i++){
            if(i%10 == 0){
                linkedStack.push(i);
            }
        }//栈顶[90--->80--->70--->60--->50--->40--->30--->20--->10--->0--->NULL]
        linkedStack.pop();//栈顶[80--->70--->60--->50--->40--->30--->20--->10--->0--->NULL]
        System.out.println(linkedStack.peek());//80
        System.out.println(linkedStack.getSize());//9
        System.out.println(linkedStack);
    }

    public void queueTest() throws IllegalAccessException {
        LinkedQueue<Integer> linkedQueue = new LinkedQueue<>();
        System.out.println(linkedQueue.isEmpty());//true
        for(int i = 0;i<100;i++){
            if(i%10 == 0){
                linkedQueue.enqueue(i);
            }
        }//对首[0--->10--->20--->30--->40--->50--->60--->70--->80--->90--->NULL]队尾
        System.out.println(linkedQueue.dequeue());//0   对首[10--->20--->30--->40--->50--->60--->70--->80--->90--->NULL]队尾
        System.out.println(linkedQueue.getFront());//10
        System.out.println(linkedQueue.getSize());//9
        System.out.println(linkedQueue);
    }
}
段茜琳
关注
专栏目录
JAVA 系列——＞数据结构（栈、队列、数组、链表和红黑树）
JAVA求生之路——博主406766467
01-13 2312
点进来的朋友先点个赞再点个关注好不好，求支持！一直往后更新。 数据结构有什么用？ 当你用着java里面的容器类很爽的时候，你有没有想过，怎么ArrayList就像一个无限扩充的数组，也好像链表之类的。好用吗？好用，这就是数据结构的用处，只不过你在不知不觉中使用了。 现实世界的存储，我们使用的工具和建模。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还...
C/C++ - 数据结构（链表、栈、队列、树（二叉树））、动态数组
LawssssCat的博客
11-09 897
用递归 减少运行时间 通过递归，缩小问题的范围。O（logN） 不用递归 1.递归调用之后，实际上没有必要知道存在的值 比如： //(尾递归) 尾递归可以通过将代码放到一个while循环中并用每个方法参数的一次赋值代替递归调用而被手工能消除。 //(尾递归) public static <T> void printList(Iterator<T> itr){ if(!...
数据结构——队列的java实现(三)-使用单向链表以及实现
weixin_38927257的博客
01-08 421
文章目录队列的链式存储结构及实现代码实现：Queue.classLinkedListQueue.classMain.class测试结果： 队列的链式存储结构及实现 定义：队列的链式存储结构，其实就是线性表的单链表，只不过，它只能尾进头出。我们把它简称为链队列。 队头指针指向链队列的头结点，队尾指针指向链队列的终端节点。 当队列为空时，front和rear都指向头结点，如图： 队列的链式存储结构-...
用链表实现栈数据结构(JAVA版）
weixin_37632716的博客
09-03 253
链表实现栈 链表也可以实现栈，通过在表头插入元素的方式实现push操作，删除链表的表头结点的方式实现pop操作 链表结构 /** * 单向链表 */ public class ListNode { private int data; private ListNode next; public ListNode(int data) { this.data = data; } public void setData(int data) {
Java“链表“——数据结构（这一篇就够了）
最新发布
m0_73158088的博客
08-17 1354
本篇对数据结构中的"链表"进行详细的讲解 本期会分成一下五部分进行讲解： 1.链表的概念 2.链表的种类 3.链表的实现方法 4.代码实现链表 5.链表的常见使用场景
数据结构用链表实现栈java_Java数据结构——用链表实现栈
weixin_34832116的博客
02-28 302
//=================================================// File Name :LinkStack_demo//------------------------------------------------------------------------------// Author :Common//类名：Link...
java的链表实现队列_Java用链表实现栈和队列
weixin_36354131的博客
02-25 122
1、用链表实现栈package stack;/**** @author denghb**/class Link {public long dData;public Link next;public Link(long dd) {dData = dd;}public void displayLink() {System.out.print(dData + " ");}}class LinkList ...
Java数据结构之——栈：用链表实现
IT界的小清流
01-11 580
class Node&lt;E&gt;{ E data; Node&lt;E&gt; next = null; public Node(E data){ this.data = data; } } public class ListStack&lt;E&gt;{ Node&lt;E&gt; top = null; public b...
数据结构（java版本）
05-27
总的来说，《数据结构（Java版本）》是一本适合程序员入门的教材，通过学习，你可以系统地掌握数据结构和算法，并用Java语言进行实现，为今后的软件开发打下坚实的基础。无论你是准备面试，还是想要提升编程技能，这...
2022王道考研数据结构笔记--第三章 栈和队列
weixin_41170125的博客
06-09 754
第三章 栈和队列 3.1栈（Stack） 3.1.1 栈的基本概念 栈的定义 栈是特殊的线性表：只允许在一端进行插入或删除操作， 其逻辑结构与普通线性表相同 栈是特殊的线性表：只允许在一端进行插入或删除操作， 其逻辑结构与普通线性表相同； ...
Java数据结构——队列
NoBug
12-24 999
1. 队列的基础************** 2. C语言下的队列********* 3. Java语言下的队列****** 4. LinkQueue类*********
数据结构 栈&队列 -（java）链表实现
qq_42711376的博客
03-11 220
1.栈 1.前一篇介绍了链表是什么，怎么实现，今天肝一个小时，顺便把栈和队列的这种基础线性表介绍一下； 2.什么是栈？ 栈是一种先进后出的线性结构（FILO）,“fist In last out”我是这么理解这个单词缩写,就像你往一个槽里面放砖头，最先放进去的，永远都是最后取出来，栈分为压（入）栈（push）和弹(出)栈（pop）；如下图： 基于这个特点我直接上代码,由于之前出了一期链表，那这个栈也用链表实现，当然也能用数组实现（留给各位大佬了） package com.data.stru.
Java数据结构——用链表实现栈
weixin_33835103的博客
03-30 95
//================================================= // File Name : LinkStack_demo //------------------------------------------------------------------------------ // Author : C...
java用链表实现栈_Java数据结构——用链表实现栈
weixin_39598796的博客
02-16 113
//=================================================// File Name :LinkStack_demo//------------------------------------------------------------------------------// Author :Common//类名：Link...
Java 实现一个链表
小地盘的诺克萨斯
06-04 1054
public class MyList { static class Node {// 节点类 Object data; Node next; public Node(Object data) {// 构造方法，为data赋值 this.data = data; this.next = null;
JAVA中实现链表
nieguohui94的博客
08-25 846
由于数据本身不具备先后的关系，所以使用Node类来封装数据，同时利用Node来指向下一个节点。 1 简单链表的实现 节点类（Node）： package com.test; /** * @author 1 * 定义节点类Node */ public class Node { private String data ; //保存数据 private Node next ; //
JAVA实现链表
W_ILU的博客
04-14 408
前言前面我们学习了顺序表，了解到了顺序表的操作方便，也便于理解，但顺序表也有缺点，比如在插入或者删除结点的时候，需要移动大量的数据，如果表比较大，有时还难以分配足够的连续的存储空间，往往导致内存分配失败，这也是这里我们为什么学习链表结构的原因引入链表结构，一种动态存储分配的结构，可以根据需要动态申请内存单元，在逻辑上相邻的结点在物理内存上不一定相邻 链表结构的缺点 * 浪费存储空间 * 顺序
Java实现链表
m0_53455348的博客
10-05 102
1、Node.java(链表结点类实现） package test2; public class Node { // 为了避免外部对象直接访问Node的成员 // 建议尽量降低访问权限 private int value; // 节点的值 private Node next; // 节点的 next对象 // 为Node类型提供必要的构造器和get、set方法 public Node(int value){ this.va...
Java实现最小生成树：数据结构入门
- **第4章**：栈和队列，这两个基础数据结构在程序设计中扮演重要角色，包括它们的工作原理和应用场景。 - **第5章**：链表，详细解释单链表、双向链表等不同类型的链表及其操作，这是实现动态数据结构的基础。 -...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值