数据结构——顺序表

最新推荐文章于 2022-08-10 12:41:30 发布
最新推荐文章于 2022-08-10 12:41:30 发布
阅读量3.4k 收藏 12
点赞数 19
分类专栏： java 文章标签： 排序算法 算法 数据结构 顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48838340/article/details/121549684
版权

目录

顺序表的实现

顺序表的遍历

顺序表的容量可变

顺序表的时间复杂度

 java中ArrayList实现

线性表是n个具有相同特性的数据元素的有限序列。常见的线性表有:顺序表、链表、栈、队列等。

线性表的分类：顺序表(数组)和链表

顺序表的实现

顺序表API设计:

类名SeqenceList
构造方法SequenceList(int capacity):创建容量为capacity的SequenceList对象
成员方法

1.public void clear():清除线性表

2.public boolean isEmpty:判断线性表是否为空

3.public int length():获取线性表中元素的个数

4.public T get(i):读取并返回线性表的第i个元素

5.public void insert(int i,T t):在线性表的第i个元素之前插入一个值为t的数据元素

6.public void insert(T t):在线性表中添加一个元素t

7.public T remove(int i):删除并返回线性表中第i个数据元素

8.public int indexOf(T t):返回线性表中首次出现该元素的序号

成员变量

1.private T[] array:存储元素的数组

2.private int N :当前线性表的长度

顺序表的代码实现

//顺序表实现
public class SequenceList<T>{
    private T[] array;  //存储元素的数组
    private int N;      //记录当前顺序表的元素个数
    //构造方法
    public SequenceList(int capacity){
        array=(T[])new Object[capacity];
        N=0;
    }
    //清除线性表
    public void clear(){
        N=0;
    }
    //判断当前线性表是否为空表
    public boolean isEmpty(){
        return N==0;
    }
    //获取线性表的长度
    public int length(){
        return N;
    }
    //获取指定位置的元素
    public T get(int i){
        if(i<0||i>=N){
            throw new RuntimeException("当前元素不存在");
        }
        return array[i];
    }
    //向线性表中添加元素t
    public void insert(T t){
        if(N==array.length){
            throw new RuntimeException("当前表已满");
        }
        array[N++]=t;
    }
    //在i元素处插入元素t
    public void insert(int i,T t){
        if(i==array.length){
            throw new RuntimeException("当前表已满");
        }
        if(i<0||i>N){
            throw new RuntimeException("插入的位置不合法");
        }
        //把i位置空出来, i位置及后面的元素依次向后移动一位
        for(int index=N;index>i;index--){
            array[index]=array[index-1];
        }
        //把t放到i处
        array[i]=t;
        //元素的数量+1
        N++;
    }
    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if(i<0||i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }
        //记录i位置处的元素
        T result=array[i];
        //将后一个元素往前移动
        for(int index=i;index<N-1;index++){
            array[index]=array[index++];
        }
        //元素数量-1
        N--;
        return result;
    }
    //查询t元素第一次出现的位置
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for(int i=0;i<N;i++){
            if(array[i].equals(t)){
                return i;
            }
        }
        return -1;
    }
}
class SequenceListTest{
    public static void main(String[] args) {
        SequenceList<String> s1=new SequenceList<>(10);

        s1.insert("龍弟");
        s1.insert("龍龍");
        s1.insert("龍哥");
        //测试获取
        String getResult = s1.get(1);
        System.out.println("获取索引1处的结果为:"+getResult);
        //测试删除
        String remove = s1.remove(0);
        System.out.println("删除的元素为:"+remove);
        s1.clear();
        System.out.println("清空后的线性表中的元素个数为:"+s1.length());
    }

}

顺序表的遍历

在java中，遍历集合的方式一般都是用的是foreach循环，如果想让我们的SequenceList也能支持foreach循环，则 需要做如下操作：

1.让SequenceList实现Iterable接口，重写iterator方法；

2.在SequenceList内部提供一个内部类SIterator,实现Iterator接口，重写hasNext方法和next方法；

//顺序表代码
public class SequenceList<T> implements Iterable<T>{
    //存储元素的数组
    private T[] array;
    //记录当前顺序表中的元素个数
    private int N;
    
    //构造方法
    public SequenceList(int capacity){
        array = (T[])new Object[capacity];
        N=0;
    }
 
    //将一个线性表置为空表
    public void clear(){
        N=0;
    }
 
    //判断当前线性表是否为空表
    public boolean isEmpty(){
        return N==0;
    }
 
    //获取线性表的长度
    public int length(){
        return N;
    }
 
    //获取指定位置的元素
    public T get(int i){
        if (i<0 || i>=N){
            throw new RuntimeException("当前元素不存在！");
        }
        return array[i];
    }
 
    //向线型表中添加元素t
    public void insert(T t){
        if (N==array.length){
            throw new RuntimeException("当前表已满");
        }
        array[N++] = t;
    }
 
    //在i元素处插入元素t
    public void insert(int i,T t){
        if (i==array.length){
            throw new RuntimeException("当前表已满");
        }
        if (i<0 || i>N){
            throw new RuntimeException("插入的位置不合法");
        }
        //把i位置空出来，i位置及其后面的元素依次向后移动一位
        for (int index=N;index>i;index--){
            array[index]=array[index-1];
        }
        //把t放到i位置处
        array[i]=t;
        //元素数量+1
        N++;
    }
 
    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }
        //记录i位置处的元素
        T result = array[i];
        //把i位置后面的元素都向前移动一位
        for (int index=i;index<N-1;index++){
            array[index]=array[index+1];
        }
        //元素数量-1
        N--;
        return result;
    }
 
    //查找t元素第一次出现的位置
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (array[i].equals(t)){
                return i;
            }
        }
        return -1;
    }
 
    //打印当前线性表的元素
    public void showEles(){
        for (int i = 0; i < N; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
 
 
    @Override
    public Iterator iterator() {
        return new SIterator();
    }
 
    private class SIterator implements Iterator{
        private int cur;
        public SIterator(){
            this.cur=0;
        }
        @Override
        public boolean hasNext() {
            return cur<N;
        }
        @Override
        public T next() {
            return array[cur++];
        }
    }
 
}
 
 
//测试代码
public class Test {
    public static void main(String[] args) throws Exception {
        SequenceList<String> squence = new SequenceList<>(5);
        //测试遍历
        squence.insert(0, "龍龍");
        squence.insert(1, "龍弟");
        squence.insert(2, "龍帝");
        squence.insert(3, "龍哥");
        squence.insert(4, "龍龍");
 
        for (String s : squence) {
            System.out.println(s);
        }
    }
}

顺序表的容量可变

1.添加元素时：

 添加元素时，应该检查当前数组的大小是否能容纳新的元素，如果不能容纳，则需要创建新的容量更大的数组，我 们这里创建一个是原数组两倍容量的新数组存储元素。

 2.移除元素时：

 移除元素时，应该检查当前数组的大小是否太大，比如正在用100个容量的数组存储10个元素，这样就会造成内存 空间的浪费，应该创建一个容量更小的数组存储元素。如果我们发现数据元素的数量不足数组容量的1/4，则创建 一个是原数组容量的1/2的新数组存储元素。

//顺序表代码
public class SequenceList<T> implements Iterable<T>{
    //存储元素的数组
    private T[] array;
    //记录当前顺序表中的元素个数
    private int N;
    
    //构造方法
    public SequenceList(int capacity){
        array = (T[])new Object[capacity];
        N=0;
    }
 
    //将一个线性表置为空表
    public void clear(){
        N=0;
    }
 
    //判断当前线性表是否为空表
    public boolean isEmpty(){
        return N==0;
    }
 
    //获取线性表的长度
    public int length(){
        return N;
    }
 
    //获取指定位置的元素
    public T get(int i){
        if (i<0 || i>=N){
            throw new RuntimeException("当前元素不存在！");
        }
        return array[i];
    }
 
    //向线型表中添加元素t
    public void insert(T t){
        if (N==array.length){
            resize(array.length*2);
        }
        array[N++] = t;
    }
 
    //在i元素处插入元素t
    public void insert(int i,T t){
        if (i<0 || i>N){
            throw new RuntimeException("插入的位置不合法");
        }
        //元素已经放满了数组，需要扩容
        if (N==array.length){
            resize(array.length*2);
        }    
        //把i位置空出来，i位置及其后面的元素依次向后移动一位
        for (int index=N-1;index>i;index--){
            array[index]=array[index-1];
        }
        //把t放到i位置处
        array[i]=t;
        //元素数量+1
        N++;
    }
 
    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }
        //记录i位置处的元素
        T result = array[i];
        //把i位置后面的元素都向前移动一位
        for (int index=i;index<N-1;index++){
            array[index]=array[index+1];
        }
        //当前元素数量-1
        N--;
        //当元素已经不足数组大小的1/4,则重置数组的大小
        if (N>0 && N<array.length/4){
            resize(array.length/2);
        }
        return result;
    }
 
    //查找t元素第一次出现的位置
    public int indexOf(T t)
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (array[i].equals(t)){
            return i;
            }
        }
        return -1;
    }
 
    //打印当前线性表的元素
    public void showEles(){
        for (int i = 0; i < N; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
 
    @Override
    public Iterator iterator() {
        return new SIterator();
    }
 
    private class SIterator implements Iterator{
        private int cur;
        public SIterator(){
            this.cur=0;
        }
 
        @Override
        public boolean hasNext() {
            return cur<N;
        }
        @Override
        public T next() {
            return array[cur++];
        }
    }
 
    //改变容量
    private void resize(int newSize){
        //记录旧数组
        T[] temp = array;
        //创建新数组
        eles = (T[]) new Object[newSize];
        //把旧数组中的元素拷贝到新数组
        for (int i = 0; i < N; i++) {
            array[i] = temp[i];
        }
    }
 
    public int capacity(){
        return array.length;
    }
}
 
 
 
 
//测试代码
public class Test {
    public static void main(String[] args) throws Exception {
        SequenceList<String> squence = new SequenceList<>(5);
        //测试遍历
        squence.insert(0, "龍弟");
        squence.insert(1, "龍龍");
        squence.insert(2, "龍弟");
        squence.insert(3, "龍哥");
        squence.insert(4, "龍龍");
        System.out.println(squence.capacity());
        squence.insert(5,"aa");
        System.out.println(squence.capacity());
        squence.insert(5,"aa");
        squence.insert(5,"aa");
        squence.insert(5,"aa");
        squence.insert(5,"aa");
        squence.insert(5,"aa");
        System.out.println(squence.capacity());
        squence.remove(1);
        squence.remove(1);
        squence.remove(1);
        squence.remove(1);
        squence.remove(1);
        squence.remove(1);
        squence.remove(1);
        System.out.println(squence.capacity());
    }
}

顺序表的时间复杂度


get(i):无论数据元素量N有多大，只需要一次array[i]就可以获取到对应的元素，时间复杂度为O(1);

insert(int i,T t):每一次插入，都需要把i位置后面的元素移动一次，随着元素数量N的增大，移动的元素也越多，时间复杂为O(n);

remove(int i):每一次删除，都需要把i位置后面的元素移动一次，随着数据量N的增大,移动的元素也越多，时间复 杂度为O(n);

由于顺序表的底层由数组实现，数组的长度是固定的，所以在操作的过程中涉及到了容器扩容操作。这样会导致顺序表在使用过程中的时间复杂度不是线性的，在某些需要扩容的结点处，耗时会突增，尤其是元素越多，这个问题越明显


 java中ArrayList实现

java中ArrayList集合的底层也是一种顺序表，使用数组实现，同样提供了增删改查以及扩容等功能。

1.是否用数组实现；

2.有没有扩容操作；

3.有没有提供遍历方式；

龍弟-idea
关注
  • 19
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 13
    评论
专栏目录
顺序表创建与遍历
06-25
使用c语言创建一个新的顺序表，并能遍历此顺序表。
顺序表（算法与数据结构）
qq_48757526的博客
05-11 509
1.顺序表 顺序表的特点是逻辑连序，物理连序 即开辟一块连续的内存空间，相当于数组arr 在定义的时候，定义一个length记录下标 所以在尾插和尾删的时候，下标就是length，可以直接进行插入和删除（时间复杂度O（1）） 但是 但是 但是 在其他位置插入和删除的时候，需要挪动数据（时间复杂度O（n）） 在查找的时候时间复杂度也是O（n）因为需要将顺序表遍历到需要查找的位置 2.链表 特点：逻辑连续，物理不一定连续 2.1单链表 ...
顺序表详解——遍历、增添、查找、删除、修改、清除
C、Java知识分享
08-10 2246
Java数据结构顺序表的功能及实现
数据结构之顺序表的删除、查找、遍历
qq_40022596的博客
04-27 4044
一、引言 本篇文章作为顺序表新的篇章延续上一篇文章（）的内容
数据结构 -- 顺序表、图的遍历
weixin_57472404的博客
12-07 919
数据结构
顺序表及其基本操作实现（C语言实现）
qq_38311609的博客
12-16 8437
顺序表及其基本操作实现（C语言实现） 顺序表是最简单的数据结构之一，在计算机中顺序表一般以数组的形式保存，我们都知道数组是线性保存的，因此顺序表也是线性保存的，线性表的连续存储值得是在计算机中用一块连续的存储空间保存线性表的元素，所以线性表的相邻元素是保存在连续的存储单元上的。 地址 Loc（a） Loc（a2） Loc（a3） … Loc（an） … ...
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
数据结构实验——顺序表
12-22
数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
注：分为三个内容：顺序表、单链表、运行结果。代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-...
数据结构——用现有链表转换为顺序表
06-26
用链表创建顺序表，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
图解数据结构（使用Python）——链表
12-21
概念：链表（Linked List）是由许多相同数据类型的数据按特定顺序排列而成的线性表，其特点是各个数据在计算机内存中的位置是不连续且随机的。 优点： 数据的插入和删除都比较方便，不需要移动大量的数据（列表在...
严蔚敏《数据结构》源码 顺序表——二叉树
06-08
目前写在了图，之后的内容会在github上持续更新，数据结构系列更新完之后，可能会更新算法的教程（参考屈婉玲版《算法设计与分析》）希望可以帮到各位！！ InitList.cpp------顺序表 LinkList.cpp------链表 ...
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构——矩阵.docx
07-11
数据结构——矩阵全文共7页，当前为第1页。数据结构——矩阵全文共7页，当前为第1页。 数据结构——矩阵全文共7页，当前为第1页。 数据结构——矩阵全文共7页，当前为第1页。 软件学院 上机实验报告 课程名称： 数据...
算法和数据结构——左程云.zip
最新发布
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
设计顺序表的相关函数库 —— 数据结构课程设计
07-09
数据结构期末课程设计，题目 设计顺序表的相关函数库 要求 设计出顺序表的相关函数库，以便在程序设计中调用。 设计要求： 1. 包括线性表的各种基本函数以及常用函数（自己确定函数、函数形式及理由）。 2. 最好...
数据结构实验——查找（二分查找&顺序查找）
06-15
一、实验目的： 熟悉各种查找算法及其复杂性，能够根据实际情况选择合适的存储结构。 二、实验要求： 1、掌握查找的基本方法。 2、提交实验报告，报告...编程分别对有序顺序表的顺序查找，二分查找算法进行实现。
【考研或自学数据结构2.2】——顺序表（顺序表的定义，顺序表的基本操作）
04-29
【考研或自学数据结构2.2】——顺序表（顺序表的定义，顺序表的基本操作）笔记
Java数据结构——用顺序表编写一个简易通讯录
05-15
好的，下面是用Java顺序表实现简易通讯录的代码： 首先，在Java中需要定义一个类来表示通讯录中的每一个联系人，这个类包含联系人的姓名和电话号码两个属性： ```java public class Contact { private String ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

龍弟-idea

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值