【Java数据结构实现二】-- 线性表 -- 顺序表＋单链表+双向链表（增删改查遍历等）

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

参考视频： 【黑马程序员】2020最新数据结构与算法教程（求职面试必备）
参考leetcode学习资料： 图解算法数据结构

注意 目录结构呦！！！按本文目录 在src文件夹下 创建项目和文件，直接粘代码即可运行

文章目录

算法和数据结构简述+排序的笔记

【Java数据结构笔记一】-- 数据结构与算法概述–【时间复杂度+空间复杂度】
【Java数据结构笔记三】-- 线性表

Mywrite

linear

SequenceList（顺序表）
package Mywrite.linear;

import java.util.Iterator;

// 线性表——顺序表——基本实现
public class SequenceList<T> implements Iterable<T> {
    // 测试
    public static void main(String[] args) {
        // 创建顺序表对象
        SequenceList<String> SL = new SequenceList<>(10);
        // 测试插入
        SL.insert("会的传教士这部分");
        SL.insert("要命");
        SL.insert("zhaznmusi");
        SL.insert(1,"我的对我的");

        for(String s: SL){
            System.out.println(s);
        }
        // 测试获取
        String getResult = SL.get(1);
        System.out.println("获取1处的索引值为："+getResult);
        // 测试删除
        String removeResult = SL.remove(0);
        System.out.println("删除的元素是" + removeResult);
        // 清空测试,以及返回长
        SL.clear();
        System.out.println("清空后的线性表中得到元素个数为"+SL.length());
    }

    // 存储元素的数组
    private T[] eles;
    // 记录当前顺序表中的元素个数
    private int N;

    //构造方法
    public SequenceList(int capacity) {
        // 初始化数据
        this.eles = (T[]) new Object[capacity];
        // 初始化长度
        this.N = 0;
    }

    // 将一个线性表置为空表
    public void clear() {
        this.N = 0;
    }

    // 判断当前线性表是否为空表
    public boolean isEmpty() {
        return N == 0;
    }

    // 获取线性表的长度
    public int length() {
        return N;
    }

    //获取指定位置的元素
    public T get(int i) {
        return eles[i];
    }

    // 向线性表中添加元素t
    public void insert(T t) {
        eles[N++] = t;
    }

    //在i元素处插入元素t
    public void insert(int i, T t) {
        if (N == eles.length) {
            resize(2*eles.length);
        }
        // 先把i索引的元素及其后面的元素依次后移一位
        for (int index = N; index > i; index--) {
            eles[index] = eles[index - 1];
        }
        //将t元素放到i索引处即可
        eles[i] = t;

        // 元素个数 +1
        N++;
    }

    // 删除指定位置i处的元素，并返回该元素
    public T remove(int i) {
        //  记录索引i处的值
        T current = eles[i];
        for (int index = i; index < N - 1; index++) {
            eles[index] = eles[index + 1];
        }
        // 元素个数 -1
        N--;
        if(N<eles.length/4) {
            resize(eles.length/2);
        }
        return current;
    }

    //查找t元素第一次出现的位置
    public int indexOf(T t) {
        for (int index = 0; index < N; index++) {
            if (eles[index].equals(t)) {
                return index;
            }
        }
        return -1;
    }

    //根据参数newSize , 重置eles的大小
    public void resize(int newSize) {
        // 定义一个临时数组，指向原数组
        T[] temp = eles;
        // 创建新数组
        eles = (T[]) new Object[newSize];
        // 把原数组的数据拷贝到新数组即可
        for (int i = 0; i < N; i++) {
            eles[i] = temp[i];
        }
    }


    //提供便利
    @Override
    public Iterator<T> iterator() {
        // 内部类不能遍历
        return new SIterator();
    }

    private class SIterator implements Iterator {
        private int cursor;

        public SIterator() {
            this.cursor = 0;
        }

        @Override
        public boolean hasNext() {
            return cursor < N;
        }

        //获取当前元素的下一个方法
        @Override
        public Object next() {
            return eles[cursor++];
        }
    }
}
LinkList（单链表）
package Mywrite.linear;

import java.util.Iterator;


public class LinkList<T> implements Iterable<T>{
    public static void main(String[] args) {
        // 创建顺序表对象
        LinkList<String> SL = new LinkList<>();
        // 测试插入
        SL.insert("会的传教士这部分");
        SL.insert("要命");
        SL.insert("zhaznmusi");
        SL.insert(1,"我的对我的");

        for(String s: SL){
            System.out.println(s);
        }
        // 测试获取
        String getResult = SL.get(1);
        System.out.println("获取1处的索引值为："+getResult);
        // 测试删除
        String removeResult = SL.remove(0);
        System.out.println("删除的元素是" + removeResult);
        // 清空测试,以及返回长
        SL.clear();
        System.out.println("清空后的线性表中得到元素个数为"+SL.length());
    }

    
    //记录头结点
    private Node head;
    //记录链表的长度
    private int N;

    //结点类
    private class Node {
        // 存储数据
        T item;
        // 下一个节点
        Node next;
        public Node(T item,Node next){
            this.item = item;
            this.next = next;
        }
    }
    public LinkList(){
        //初始化头结点,默认值指向空的
        this.head = new Node(null,null);
        // 初始化
        this.N = 0;
    }

    // 清空链表
    public  void clear(){
        head.next = null;
        this.N = 0;
    }

    // 获取链表的长度
    public int length(){
        return N;
    }

    // 判断链表是否为空
    public boolean isEmpty(){
        return N == 0;
    }

    // 获取指定位置i的元素
    public T get(int i){
        // 通过循环，从头结点开始往后找，依次找i次，就可以找出对应的元素
        Node n = head.next;
        for(int index = 0; index<i; index++){
            n = n.next;
        }
        return n.item;
    }

    // 向链表中添加元素t
    public void insert(T t){
        //找到链表中的最后一个结点
        Node n = head;
        while(n.next != null){
            n = n.next;
        }

        //创建新的节点
        Node newNode = new Node(t, null);
        n.next = newNode;

        // 元素的个数夹一
        N++;
    }

    // 向指定元素i处添加元素
    public void insert(int i, T t){
        //找到i处的前一个节点
        Node pre = head;
        for(int index=0; index<=i-1; index++){
            pre = pre.next;
        }

        Node curr = pre.next;
        Node newNode = new Node(t,curr);
        pre.next = newNode;

        N++;
    }


    // 删除指定位置i出的元素，并返回被删除的元素
    public T remove(int i){
        Node pre = head;
        for(int index = 0; index<=i-1; index++){
            pre = pre.next;
        }

        Node curr = pre.next;
        pre.next = curr.next;
        N--;
        return curr.item;
    }

    // 查找元素t在链表中第一次出现的位置
    public int search(T t){
        Node n = head;
        for(int i=0; n.next!=null; i++){
            n = n.next;
            if(n.item.equals(t)){
                return i;
            }
        }
        return -1;
    }


    @Override
    public Iterator<T> iterator() {
        return new LIterator();
    }
    private class LIterator implements Iterator{
        private Node n;
        public LIterator(){
            this.n = head;

        }
        @Override
        public boolean hasNext() {
            return n.next!=null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
}
TwoWayLinkList（双向链表）
package Mywrite.linear;

//import org.w3c.dom.Node;


import java.util.Iterator;

public class TwoWayLinkList<T> implements Iterable<T>{
    public static void main(String[] args) {
        // 创建双向链表对象
        TwoWayLinkList<String> sl= new TwoWayLinkList<>();
        // 测试插入
        sl.insert("姚明");
        sl.insert("科比");
        sl.insert("麦迪");
        sl.insert(1,"詹姆斯");
        for(String s: sl){
            System.out.println(s);
        }
        System.out.println("-----------------");

        // 测试获取
        String getResult = sl.get(1);
        System.out.println("获取索引1处的结果为："+getResult);
        // 测试删除
        String removeResult = sl.get(0);
        System.out.println("删除的元素：" + removeResult);



        System.out.println("---------------------");
        System.out.println("第一个元素是"+sl.getFirst());
        System.out.println("最后一个元素是：" + sl.getLast());

        // 测试清空
        sl.clear();
        System.out.println("清空后的线性表中的元素个数为："+sl.length());
    }

    //首结点
    private Node head;
    // 最后一个结点
    private Node last;

    //链表的长度
    private int N;

    // 结点类
    private class Node {
        public Node(T item, Node pre, Node next) {
            this.item = item;
            this.pre = pre;
            this.next = next;
        }
        //存储数据
        public T item;
        // 指向上一个结点
        public Node pre;
        //  指向下一个结点
        public Node next;
    }

    public TwoWayLinkList() {
        //初始化头节点和尾结点
        this.head = new Node(null, null, null);
        this.last = null;
        // 初始化元素结点
        this.N = 0;
    }

    // 清空链表
    public void clear() {
        this.head.next = null;
        this.head.item = null;
        this.last = null;
        this.N = 0;
    }

    // 获取链表长度
    public int length() {
        return N;
    }

    // 判断链表是否为空
    public boolean isEmpty() {
        return N == 0;
    }

    // 获取第一个元素
    public T getFirst() {
        if (isEmpty()) {
            return null;
        }
        return head.next.item;
    }

    // 获取最后一个元素
    public T getLast() {
        if (isEmpty()) {
            return null;
        }
        return last.item;
    }

    // 插入元素t
    public void insert(T t) {
        // 如果链表为空
        if (isEmpty()) {
            // 创建新的节点
            Node newNode = new Node(t, head, null);
            // 让新结点成为尾结点
            last = newNode;
            // 让头结点指向尾结点
            head.next = last;
        } else {
            // 如果链表不为空
            Node oldLast = last;
            // 创建新的结点
            Node newNode = new Node(t, oldLast, null);
            // 让当前的尾节点 指向新结点
            oldLast.next = newNode;
            // 让新结点成为尾结点
            last = newNode;
        }
        N++;
    }

    //向指定位置i处插入元素t
    public void insert(int i, T t) {
        Node pre = head;
        for (int index = 0; index < i; index++ ){
            pre = pre.next;
        }
        Node curr = pre.next;
        Node newNode = new Node(t, pre, curr);
        pre.next = newNode;
        curr.pre = newNode;

        N++;
    }
    // 获取指定位i处的元素
    public T get(int i){
        Node n = head.next;
        for(int index = 0; index < i; index++){
            n = n.next;
        }
        return n.item;
    }

    // 找到元素t在链表中第一次出现的位置
    public int indexOf(T t){
        Node n = head;
        for(int index = 0; index<N; index++){
            n = n.next;
            if(n.next.equals(t)){
                return index;
            }
        }
        return -1;
    }

    // 删除位置i处的元素，并返回该元素
    public T remove(int i){
        Node pre = head;
        for(int index = 0; index < i; index++){
            pre = pre.next;
        }
        Node curr = pre.next;
        Node nextNode = curr.next;
        pre.next = nextNode;
        nextNode.pre = pre;

        // 元素个数减一
        N--;
        return curr.item;
    }

    @Override
    public Iterator<T> iterator() {
        return new TIterator();
    }
    private class TIterator implements Iterator{
        private Node n;
        public TIterator(){
          this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
}

请添加图片描述

要点赞＋关注+收藏呦👉

笔记在博主本人的博客上也有奥！全套！！！

牛小小小婷～
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习--线性表及其应用--链表
06-25
通过这些基本操作的实践，学生可以深入理解链表的工作原理和操作方式，这不仅有助于掌握链表的实现，还能为后续学习如栈、队列、树等更复杂的数据结构奠定基础。此外，了解链表的优缺点有助于在实际问题中选择合适的...
线性表的插入和删除（Java版）
weixin_43741599的博客
07-27 6379
1、线性表的定义：   (1)、线性表是一种可以在任意位置插入和删除数据元素操作、由n(n≥0)个相同类型数据元素a0, a1,…, an-1组成的线性结构。除了第一个元素没有前驱元素和最后一个元素没有后继元素外，其他元素有且只有一个直接元素和一个直接后继元素。   (2)、在逻辑上，线性结构的特点是数据元素之间存在着“一对一”的逻辑关系，这种关系的数据结构通常称为线性结构；同样，任何一个线性结构...
Java数据结构-线性表的设计与实现
m0_52846268的博客
11-28 1833
线性表： 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 顺序表的实现之增删改查功能 代码实现： public class MyArrayList { private int[] elements;//元素 private int size;//List中当前的元素个数 public MyArrayList() { this(1);//List默认大小为1
Java数据结构之线性表
weixin_44270248的博客
04-18 4770
线性表基本概念 线性表是其组成元素间具有线性关系的一种线性结构，是由n个数据类型相同的元素构成的有限序列。其具有“一对一”的逻辑关系，与位置有关，除了头尾元素之外，每一个元素都有唯一的前驱元素和后继元素，即元素ai前面的元素为ai-1，后面的元素为ai+1。 抽象数据类型 线性表的抽象数据类型可以用接口描述，其中列举了一些基本的功能，可以自己根据需求扩充： package ch02; publi...
线性表和链表的存储和增删改查c++
01-28
线性表的增删改查操作 - **插入**：在线性表的指定位置插入一个新元素，需要找到插入点并更新指针。对于链表，这涉及修改前后两个节点的指针。 - **删除**：根据给定的元素或位置删除一个元素，需要找到要删除的...
数据结构学习--线性表及其应用--顺序表
06-25
线性表按照存储方式可以分为顺序表和链表。顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种存储方式具有随机访问的优势，因为可以通过元素的索引来直接访问数组中的...
数据结构 - 顺序表(Contiguous-List)
10-23
顺序表是数据结构中的一种基本类型，它是线性表的一种具体实现方式。在计算机科学中，数据结构的选择与操作直接影响到程序的效率和性能。理解并掌握顺序表的概念、特点以及其在C语言中的实现，对于学习和使用计算机...
第2章 C语言基础知识
m0_70617423的博客
08-14 2706
C语言
python爬虫爬取某图书网页实例
2301_77698138的博客
08-14 3868
下面是通过requests库来对ajax页面进行爬取的案例，与正常页面不同，这里我们获取url的方式也会不同，这里我们通过爬取一个简单的ajax小说页面来为大家讲解。循环遍历URL（这里为大家提供具体url的获取方法，并循环了1至9页的数据为大家做案例），并发送了带有随机User-Agent的GET请求。设置代码来保存图片到以文章名命名的文件中，并将作者、文章名和简介信息写入到"./biquge.txt"文件中。首先进入网页，点击F12打开自定义与控制工具，点击fecth/XHR，此时显示部分为空白。
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 552
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 791
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1062
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 762
@Transactional中使用线程锁导致了锁失效与解决方案
Java学习_18_Stream流
qq_41136689的博客
08-23 1209
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 159
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
使用Java通过身份证号码匹配省市县名称的技术博客
weixin_41489908的博客
08-21 354
每日自动更新各类学习教程及工具下载合集​​在中国，身份证号码包含了持有人的出生地信息。通过解析身份证号码的前六位，我们可以获取对应的省、市、县（区）信息。在这篇博客中，我们将探讨如何使用Java代码来实现这一功能，并展示详细的代码示例和运行结果。
Java中自定义注解的使用
echola_mendes的博客
08-22 1004
以【记录操作日志】为例，一般在开发中为了记录用户操作，当系统出现问题时，可以追溯日志所提供详细的错误信息，帮助开发者快速定位问题的原因最简单的方法：在每个方法中增加日志信息打印代码，来记录操作日志，但是这样重复代码也很多，也不易扩展，而且易出错使用自定义注解就会方便很多，减少不必要的重复代码，减少非业务代码的侵入性，如果需要扩展操作用户的信息以及IP就会很方便，易于扩展和维护@interface在需要使用自定义注解的地方使用该注解@LogOperation("新增")// 方法实现。
如何用Java SpringBoot+Vue搭建校内跑腿业务系统？实战教程解析
WEIXIN_JSJBCZDS的博客
08-21 988
如何用Java SpringBoot+Vue搭建校内跑腿业务系统？实战教程解析 【毕设攻略】Java SpringBoot+Vue打造校内跑腿系统！从零开始，手把手教你构建完整的业务流程。实战教程，技术难点全解析，让你的毕设项目脱颖而出，校园创业从这里启航！点击视频，开启你的编程之旅！
数据结构与算法-线性表深度解析：顺序表与链表
"《数据结构与算法》-数据结构C++，主要讲解了线性表的概念、抽象数据类型定义以及不同的存储实现，包括顺序表和单链表，同时涉及线性表的其他存储结构，如双链表。本章重点讨论了顺序存储结构和链接存储结构的思想...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值