数据结构（2）/ 顺序表+链表

已于 2023-01-28 14:32:09 修改
阅读量324 收藏 1
点赞数 3
分类专栏： java 文章标签： 数据结构 java 链表
于 2022-09-16 12:33:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62260160/article/details/126884980
版权

目录

一、顺序表（ArrayList<>）

 Ⅰ、数据域：存放方式

Ⅱ、ArrayList()：构造方法

Ⅲ、void add()：添加元素，默认在最后添加

Ⅳ、void add(int pos,int data)：在pos位置新增元素

Ⅴ、boolean checkPosIndex()：判断查找的位置是否合法

Ⅵ 、boolean isFull()：判断当前数组是不是满的

Ⅶ、boolean contain(int tofind)：判断顺序表是否包含指定元素

Ⅷ、int indexOf()：查找指定元素的位置

Ⅸ、boolean checkPosInGet(int pos)：判断指定位置是否合法

Ⅹ 、int get(int pos)：获取指定位置的元素

ⅠⅠ、set(int pos,int value)：将pos位置元素跟新为value

ⅠⅡ、remove(int key)：删除第一次出现的元素key

ⅠⅢ、boolean isEmpty()：判断顺序表是否为空

ⅠⅣ、int size()：返回顺序表的长度

ⅠⅤ、void clear()：清空顺序表

ⅠⅥ、void display()：打印顺序表

 二、链表（LinkedList<>）

Ⅰ、链表的概念

Ⅱ、void addFirst(int val)：头插法

Ⅲ、void addLast(int val)：尾插法

Ⅳ、boolean addIndex(int Index,int data)：指定位置插入，第一个有效元素的下标为0

Ⅴ、void checkIndexAdd(int index)：检查index位置是否合法

Ⅵ、ListNode findIndexSubOne(int index)：返回index-1的节点

Ⅶ、boolean contains(int key)：判断链表是否包含key元素

Ⅷ、void remove(int key)：删除第一次出现key的节点

Ⅸ、void removeAll(int key)：删除所有key的节点

Ⅹ、int size()：返回数据元素个数

ⅠⅠ、void display()：打印链表

ⅠⅡ、void clear()：清空链表

前言

本章节是在IntelliJ IDEA集成开发环境测试的结果，内容多适用于学习Java方向数据结构的学者

一、顺序表（ArrayList<>）

读前须知

本章中会用到两个自定义异常：

MyArrayListEmptyException：顺序表为空异常

MyArrayListIndexOutOfException：指定位置超出顺序表有效范围

 Ⅰ、数据域：存放方式

 顺序表的底层其实就是一个数组（泛型），另外还有一个记录数组有效长度的标记。

排除数组长度不够，和标记大小太小的因素就是以下基本结构。另外加了一些初始常量，表示数组的初始大小。这里就使用int来代替泛型的思想，我们只需要知道内部结构是怎么样子的就行了。

泛型通道————<泛型>

int[]  elem;
//顺序表的有效长度
int useSize ;
//表示数组初始化的默认容量
private static final int DEFAULT_SIZE = 10

Ⅱ、ArrayList()：构造方法

 使用默认容量初始化数据域

public MyArrayList() {
        this.elem = new int[DEFAULT_SIZE];
    }

Ⅲ、void add()：添加元素，默认在最后添加

    public void add(int data) {
        //1、判断是否是满的，如果满的，那么进行扩容
        if (isFull()) {
            //扩容
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
        }
        //2、不满进行插入
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }

Ⅳ、void add(int pos,int data)：在pos位置新增元素

    public void add(int pos, int data) throws MyArrayListIndexOutOfException{
        //判断下标是否是合法的
        if (!checkPosInAdd(pos)) {
            throw new MyArrayListIndexOutOfException("添加方法的pos不合理！");
        }
        //判断是否是满的
        if (isFull()) {
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);

        }
        //挪数据
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        //挪完了数据
        this.elem[pos] = data;
        this.usedSize++;
    }

Ⅴ、boolean checkPosIndex()：判断查找的位置是否合法

    private boolean checkPosInAdd(int pos) {
        if (pos < 0 || pos > this.usedSize) {
            System.out.println("pos位置不合法");
            return false;
        }
        return true;//合法
    }

Ⅵ 、boolean isFull()：判断当前数组是不是满的

    public boolean isFull() {
        return this.usedSize == this.elem.length;
    }

Ⅶ、boolean contain(int tofind)：判断顺序表是否包含指定元素

    public boolean contains(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

Ⅷ、int indexOf()：查找指定元素的位置

    public int indexOf(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

Ⅸ、boolean checkPosInGet(int pos)：判断指定位置是否合法

    private boolean checkPosInGet(int pos) {
        if (pos < 0 || pos >= this.usedSize) {
            System.out.println("pos位置不合法");
            return false;
        }
        return true;//合法
    }

Ⅹ 、int get(int pos)：获取指定位置的元素

    public int get(int pos) throws MyArrayListIndexOutOfException,MyArrayListEmptyException{
        if (!checkPosInGet(pos)) {
            throw new MyArrayListIndexOutOfException("获取pos下标时，位置不合法");
        }
        //不用写判断空不空 没有问题的
        if (isEmpty()) {
            throw new MyArrayListEmptyException("获取元素的时候，顺序表为空！");
        }
        return this.elem[pos];
    }

ⅠⅠ、set(int pos,int value)：将pos位置元素跟新为value

    public void set(int pos, int value) throws MyArrayListIndexOutOfException,MyArrayListEmptyException{
        if (!checkPosInGet(pos)) {
            throw new MyArrayListIndexOutOfException("更新pos下标的元素，位置不合法");
        }
        //如果合法 ，那么其实不用判断顺序表为空的状态了
        if (isEmpty()) {
            throw new MyArrayListEmptyException("顺序表为空！");
        }
        //顺序表为满的情况也可以更新
        this.elem[pos] = value;
    }

ⅠⅡ、remove(int key)：删除第一次出现的元素key

    public void remove(int key) throws MyArrayListEmptyException{
        if (isEmpty()) {
            throw new MyArrayListEmptyException("顺序表为空，不能删除！");
        }
        int index = indexOf(key);
        if (index == -1) {
            System.out.println("不存在你要删除的数据");
            return;
        }

        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        //删除完成
        this.usedSize--;
        // this.elem[usedSize] = null; 如果是引用类型 这里需要置为空
    }

ⅠⅢ、boolean isEmpty()：判断顺序表是否为空

    private boolean isEmpty() {
        return this.usedSize == 0;
    }

ⅠⅣ、int size()：返回顺序表的长度

    public int size() {
        return this.usedSize;
    }

ⅠⅤ、void clear()：清空顺序表

    public void clear() {
        /*
        如果是引用数据类型 得一个一个置为空 这样做才是最合适的
        for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = null;
        }
        this.usedSize = 0;
        */

        this.usedSize = 0;
    }

ⅠⅥ、void display()：打印顺序表

    public void display() {
        //usedSize==0
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
        System.out.println();
    }

 二、链表（LinkedList<>）

读前须知

本章使用了一个自定义类ListNode，用来表示节点。

与一个自定义异常MyListIndexOutOfException，表示指定位置index超出链表范围。异常不做介绍

class ListNode{
    int val;
    ListNode next;
    //指定数据域的构造方法
    public ListNode(int val) {
        this.val = val;
    }
}

Ⅰ、链表的概念

链表的类型其实有8种：比如带头单向循环链表，以下组合总共8种

注：linkedList的底层是带头双向链表，双向链表就是加了一个前驱引用。

 虽然有这么多种类，但是原理都是相通的，这里我们主要介绍单向不带头非循环链表。

单向不带头非循环链表结构如下

 我们把一整个方框叫做一个节点，每个节点有具体的数据域与指向下一个节点的引用，且链表可以使用泛型来确定数据域的类型，下我们使用Int来代替泛型。

Ⅱ、void addFirst(int val)：头插法

public void addFirst(int data){
        ListNode node = new ListNode(data);
        node.next = this.head;
        this.head = node;
    }

Ⅲ、void addLast(int val)：尾插法

public void addLast(int val){
        ListNode node = new ListNode(data);
        if(head == null) {
            head = node;
        }else {
            ListNode cur = head;
            while (cur.next != null) {
                cur = cur.next;
                }
            //运行到这里时cur.next == null;
            cur.next = node;
        }
}

Ⅳ、boolean addIndex(int Index,int data)：指定位置插入，第一个有效元素的下标为0

public void addIndex(int index,int data) throws MyListIndexOutOfException{
        checkIndexAdd(index);
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        ListNode node = new ListNode(data);
        ListNode cur = findIndexSubOne(index);
        node.next = cur.next;
        cur.next = node;
}

Ⅴ、void checkIndexAdd(int index)：检查index位置是否合法

    private void checkIndexAdd(int index) {
        if(index < 0 || index > size()) {
            throw new MyListIndexOutOfException("任意位置插入的时候，index不合法！");
        }
    }

Ⅵ、ListNode findIndexSubOne(int index)：返回index-1的节点

private ListNode findIndexSubOne(int index) {
        ListNode cur = this.head;
        while (index-1 != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
}

Ⅶ、boolean contains(int key)：判断链表是否包含key元素

public boolean contains(int key) {
        //head == null
        ListNode cur = this.head;
        //cur != null 说明 没有遍历完 链表
        while (cur != null) {
            if(cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
}

Ⅷ、void remove(int key)：删除第一次出现key的节点

public void remove(int key){
 
        if(this.head == null) {
            System.out.println("此时链表为空，不能进行删除！");
            return;
        }
 
        if(this.head.val == key) {
            //判断 第一个节点是不是等于我要删除的节点
            this.head = this.head.next;
            return;
        }
 
        ListNode cur = this.head;
        while (cur.next != null) {
            if(cur.next.val == key) {
                //进行删除了
                ListNode del = cur.next;
                cur.next = del.next;
                return;
            }
            cur = cur.next;
        }
}

Ⅸ、void removeAll(int key)：删除所有key的节点

public void removeAllKey(int key){
        if(this.head == null) {
            return;
        }
 
        ListNode cur = this.head.next;
        ListNode prev = this.head;
 
        while (cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        //单独处理了头节点
        if(this.head.val == key) {
            head = head.next;
        }
}

Ⅹ、int size()：返回数据元素个数

public int size(){
        int count = 0;
        ListNode cur = this.head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
}

ⅠⅠ、void display()：打印链表

    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }

ⅠⅡ、void clear()：清空链表

public void clear(){
        //this.head = null;//这种做法 比较粗暴！不建议使用
        ListNode cur = this.head;
        ListNode curNext = null;
        while (cur != null) {
            curNext = cur.next;
            cur.next = null;
            cur = curNext;
        }
        head = null;
}

寒夕君哎
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构顺序表和链表的相关操作
06-30
1.依次从键盘读入数据，建立顺序表和链表；2.求顺序表的长度；3.根据指定条件能获取元素；4.实现在指定位置插入和删除元素的功能 主菜单设计要求： 程序运行后创建顺序表和链表，之后给出9个菜单项的内容和输入提示...
【数据结构-C】顺序表知识点梳理
weixin_44768184的博客
05-13 1780
1.线性表 2.顺序表 概念 结构 问题: 1.中间/头部的插入删除，时间复杂度为O（N） 2.增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。 3.增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。 思考： 如何解决以上的问题？下面我们给出了链表...
顺序表&链表 知识点总结
qq_51471471的博客
11-04 372
线性表之顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。并在数组上完成数据的增删查改 // 顺序表的动态存储 typedef struct SeqList { SQDataType* arr; // 指向动态开辟的数组 size_t size; // 数组中有效元素的个数 size_t capacity; // 数组的最大容量 }SeqList; 使用realloc()函数进行扩容 初始条件，结束条件，迭代过程 顺序表 经典OJ题 给定一个
python 判断表的长度_顺序表与单链表
weixin_29482557的博客
01-30 499
顺序表Python顺序表中基本操作的实现list其他操作list内置操作的时间复杂度单链表python单链表基本操作的实现单个节点实现单链表的实现顺序表与单链表的对比顺序表线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素，这种表示 也称作线性表的顺序存储结构或顺序映像。通常，称这种存储结构的线性表为顺序表（Sequent ial List 其特点是, 逻辑上相邻的数据元素，...
C语言数据结构---顺序表（静态）
刘先生倒了u的博客
07-12 1889
一、头文件与宏定义 标准输入输出头文件 ElemType定义为元素类型int 顺序表静态分配空间长度为6 #include<stdio.h> #define ElemType int #define MAXSIZE 6 二、结构体定义 一个存放元素的数组，长度为MAXSIZE 存放长度为len，len可以随着插入数据而改变 typedef struct{ ElemType data[MAXSIZE]; int len; }Sqlist; 三、函数声明 函数的总体思路为“创
数据结构之顺序表
m0_62878102的博客
08-04 2912
顺序表在内存中以一段连续的地址存储，具有随机性，顺序性，动态性随机性，即首地址随机生成；顺序性，即各元素地址满足等距相邻；动态性，即存储空间可在程序运行时动态生成。
数据结构顺序表和链表（超详细）
08-14
动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的值//销毁2、带头+双向+循环链表增删查改实现// ...
数据结构实验 顺序表和链表
最新发布
10-08
数据结构实验 顺序表和链表
数据结构与算法-顺序表（链表篇）
09-09
代码资源
2.2线性表的顺序表示
qijiuliushisan的博客
06-14 151
#include<cstdio> #include<stdlib.h> typedef int ElemType; #define MaxSize 100 #define InitSize 100 //1.顺序表结构体定义 //1.1静态分配数组 typedef struct SqList { ElemType data[MaxSize]; int length; }; //1.2动态分配数组 typedef struct SeqList { ElemType *data
数据结构【顺序表】
undefined的博客
05-15 379
数据结构中的线性结构及动态顺序表的相关操作
PTA题目：顺序表的查找操作
Tajang的大千世界
10-21 4984
本题要求实现一个函数，要求从顺序表中查找指定元素，并返回第一个查找成功的元素在表中的位置序号，若查找失败，则返回0； 函数接口定义： int LocateElem(SqList L,ElemType e); 其中SqList结构定义如下： typedef struct{ ElemType *elem; int length; }SqList; 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> #define MAXSIZE 5
顺序表的实现及操作【C语言最详细版】
一同进步，一同追梦
09-28 5330
数据结构 线性表中顺序表的实现和测试，让你理解顺序表底层物理逻辑，和实现相应功能的创建。
温故知新——数据结构之顺序表
laosuannai233的博客
12-15 1222
顺序表是数据结构中的基础知识之一，本文带你回顾顺序表的定义和实现，重温计算机学科基础知识。
数据结构与算法--顺序表的表示及基本操作
SONG_YIH的博客
07-27 2361
一、线性表的定义和特点 1.线性表是具有相同特性的数据元素的一个有限序列 2.线性表由n(n>=0)个数据元素(结点)a1,a2,...an组成的有限序列 *其中数据元素的个数n定义为表的长度 *当n=0时称为空表 *将非空的线性表(n>0)记作:(a1,a2,...an) * 这里的数据元素ai(1<=i<=n)只是一个抽象的符号，其具...
数据结构——顺序表
kankanim的博客
04-03 4686
数据结构——顺序表 顺序表是指在计算机内存中以数组的形式保存的线性表；将元素一个接一个的存入一组连续的存储单元，这种方式称为顺序结构。 C语言定义顺序表的结构体 #define MAXSIZE N // N 是可以存储多少个数据 typedef int data_t; // data_t 是数据类型 typedef struct{ data_t data[MAXSIZE]; ...
数据结构——查找
rqc112233的专栏
10-21 265
查找的方法主要有折半查找、二叉排序树、散列表等查找方式，由于二叉排序树、散列表已经有了，现在主要看看折半查找吧。。。 折半查找的思路还是很简单的，对一个序列进行排序，将排序的序列从两端依次递减选择可能出现的区域： 代码如下： #include using namespace std; int find_key(int *a,int n,int key) { int last=n, mid
java常用实用类详解
Clf丶忆笙
12-20 1819
1.      String类（字符串检测） 返回值类型 常用方法 说明 int length() 获取字符串的长度大小 boolean equals(String s) 比较对象的实体是否相同。 ...
数据结构顺序表和链表
09-06
数据结构中，顺序表和链表是两种不同的存储结构。 顺序表是一种线性结构，它通过一段物理地址连续的存储单元来存储数据元素，并且采用数组的形式进行存储。顺序表在数组上完成数据的增删查改操作，同时记录表的长度...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

寒夕君哎

动力+99(*•̀ᴗ•́*)و

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

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

打赏作者

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

抵扣说明：

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

余额充值