第二章 线性表-顺序表

最新推荐文章于 2020-10-19 16:14:03 发布
最新推荐文章于 2020-10-19 16:14:03 发布
阅读量131 收藏 1
点赞数
分类专栏： Java方面 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/isaiah282485068/article/details/89704054
版权

提出问题

顺序表，它是基于数组的对线性表的一种实现。

抽象数据类型

很多时间数组并不能满足我们的需求，比如，所以基于数组要进行封装，也就是我们的顺序表

getSize()

 

 

代码实现


public class ArrayList {
    /** 使用数组存储数据 */
    private int[] data;
    /** size记录当前数组data中实际元素个数 */
    private int size;

    public ArrayList(int capacity) {
        this.data =  new int[capacity];
        this.size = 0;
    }
    public ArrayList() {
        this(10);
    }

    /**
     * 获取顺序表中元素个数
     * @return
     */
    public int getSize(){
        return this.size;
    }

    /**
     * 获取顺序表容器
     * @return
     */
    public int getCapacity(){
        return this.data.length;
    }

    /**
     * 判断顺序表是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }


    /**
     * 向顺序表中index位置上添加元素
     * @param index
     * @param e
     */
    public void add(int index, int e){
        if (index < 0 || index > this.size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index < size");
        }
        if (this.size == this.data.length){
            throw new IllegalArgumentException("Add failed. Array is full.");
        }
        for (int i = size - 1; i >= index; i--){
            this.data[i + 1] = data[i];
        }
        this.data[index] = e;
        this.size ++;
    }

    /**
     * 在所有元素后添加一个新元素
     * @param e
     */
    public void addLast(int e){
        /*
        if (this.size == this.data.length){
            throw new IllegalArgumentException("Add failed. Array is full.");
        }
        this.data[size] = e;
        this.size ++;
        */
        this.add(size, e);
    }

    /**
     * 在所有元素前添加一个新元素
     * @param e
     */
    public void addFirst(int e){
        this.add(0, e);
    }

    /**
     * 获取指定索引位置上的元素e
     * @param index
     * @return
     */
    public int get(int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal");
        }
        return this.data[index];
    }

    /**
     * 修改指定索引位置上的元素e
     * @param e
     * @param index
     */
    public void set(int e, int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal");
        }
        this.data[index] = e;
    }

    /**
     * 查询顺序表中是否包含指定的元素e
     * @param e
     * @return
     */
    public boolean contains(int e){
        for (int i = 0; i < size; i++){
            if (data[i] == e){
                return true;
            }
        }
        return false;
    }

    /**
     * 查找顺序表中元素e所在的索引，如果元素e不存在返回-1
     * @param e
     * @return
     */
    public int find(int e){
        for (int i = 0; i < size; i++){
            if (data[i] == e){
                return i;
            }
        }
        return -1;
    }

    /**
     * 删除顺序表中index位置上的元素，返回删除的元素
     * @param index
     * @return
     */
    public int remove(int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Remove failed. Index is illegal");
        }
        int ret  = this.data[index];
        for (int i = index + 1; i < this.size; i++){
            this.data[i - 1] = this.data[i];
        }
        this.size --;
        return ret;
    }

    /**
     * 删除顺序表中第一个元素，返回删除的元素
     * @return
     */
    public int removeFirst(){
        return this.remove(0);
    }

    /**
     * 删除顺序表中最后一个元素，返回删除的元素
     * @return
     */
    public int removeLast(){
        return this.remove(this.size -1);
    }

    /**
     * 删除指定的元素
     * @param e
     */
    public boolean removeElement(int e){
        int index = this.find(e);
        if (index != -1){
            this.remove(index);

        }
        return false;
    }

    @Override
    public String toString() {
        StringBuffer rs = new StringBuffer();
        rs.append(String.format("Array List: size = %d, capacity = %d\n", this.size, this.data.length));
        rs.append("[");
        for (int i = 0; i < this.size; i ++){
            rs.append(this.data[i]);
            if (i != size -1){
                rs.append(", ");
            }
        }
        rs.append("]");
        return rs.toString();
    }
}

 

代码优化：

加入范型支持

以上我们实现的顺序表只能存储int类型的数据，为了让我们以上实现的顺序表能够支持存储更多的数据类型，加入范型


public class ArrayList<T> {
    /** 使用数组存储数据 */
    private T[] data;
    /** size记录当前数组data中实际元素个数 */
    private int size;

    public ArrayList(int capacity) {
        this.data = (T[]) new Object[capacity];
        this.size = 0;
    }
    public ArrayList() {
        this(10);
    }

    /**
     * 获取顺序表中元素个数
     * @return
     */
    public int getSize(){
        return this.size;
    }

    /**
     * 获取顺序表容器
     * @return
     */
    public int getCapacity(){
        return this.data.length;
    }

    /**
     * 判断顺序表是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }


    /**
     * 向顺序表中index位置上添加元素
     * @param index
     * @param e
     */
    public void add(int index, T e){
        if (index < 0 || index > this.size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index < size");
        }
        // 如果当前data数组元素个数为整个数组容量时，进行扩容
        if (this.size == this.data.length){
            resize(2 * this.data.length);
        }
        for (int i = size - 1; i >= index; i--){
            this.data[i + 1] = data[i];
        }
        this.data[index] = e;
        this.size ++;
    }


    /**
     * 在所有元素后添加一个新元素
     * @param e
     */
    public void addLast(T e){
        this.add(size, e);
    }

    /**
     * 在所有元素前添加一个新元素
     * @param e
     */
    public void addFirst(T e){
        this.add(0, e);
    }

    /**
     * 获取指定索引位置上的元素e
     * @param index
     * @return
     */
    public T get(int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal");
        }
        return this.data[index];
    }

    /**
     * 修改指定索引位置上的元素e
     * @param e
     * @param index
     */
    public void set(T e, int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal");
        }
        this.data[index] = e;
    }

    /**
     * 查询顺序表中是否包含指定的元素e
     * @param e
     * @return
     */
    public boolean contains(T e){
        for (int i = 0; i < size; i++){
            if (data[i] == e){
                return true;
            }
        }
        return false;
    }

    /**
     * 查找顺序表中元素e所在的索引，如果元素e不存在返回-1
     * @param e
     * @return
     */
    public int find(T e){
        for (int i = 0; i < size; i++){
            if (data[i].equals(e) ){
                return i;
            }
        }
        return -1;
    }

    /**
     * 删除顺序表中index位置上的元素，返回删除的元素
     * @param index
     * @return
     */
    public T remove(int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Remove failed. Index is illegal");
        }
        T ret  =  this.data[index];
        for (int i = index + 1; i < this.size; i++){
            this.data[i - 1] = this.data[i];
        }
        this.size --;
        this.data[size] = null;
        // 如果当前data数组元素个数为整个数组容量的1/2时，进行缩容
        if (this.size == this.data.length / 2){
            resize(this.data.length / 2);
        }
        return ret;
    }

    /**
     * 删除顺序表中第一个元素，返回删除的元素
     * @return
     */
    public T removeFirst(){
        return this.remove(0);
    }

    /**
     * 删除顺序表中最后一个元素，返回删除的元素
     * @return
     */
    public T removeLast(){
        return this.remove(this.size -1);
    }

    /**
     * 删除指定的元素
     * @param e
     */
    public boolean removeElement(T e){
        int index = this.find(e);
        if (index != -1){
            this.remove(index);

        }
        return false;
    }

    /**
     * 返回最后一个元素
     * @return
     */
    public T getLast(){
        return this.get(this.size -1);
    }

    /**
     * 返回第一个元素
     * @return
     */
    public T getFirst(){
        return this.get(0);
    }


    private void resize(int newCapacity) {
        T[] newData = (T[]) new Object[newCapacity];
        for (int i = 0; i < this.size; i++){
            newData[i] = this.data[i];
        }
        this.data = newData;
    }

    @Override
    public String toString() {
        StringBuffer rs = new StringBuffer();
        rs.append(String.format("Array List: size = %d, capacity = %d\n", this.size, this.data.length));
        rs.append("[");
        for (int i = 0; i < this.size; i ++){
            rs.append(this.data[i]);
            if (i != size -1){
                rs.append(", ");
            }
        }
        rs.append("]");
        return rs.toString();
    }
}

 

动态扩容：

以上我们虽然实现了顺序表，存储数据是使用的静态数组，容量有限，很多时候我们无法预估往数组中放多少个元素，在这种情况下如果容量太大会浪费空间，容量太小则不够使用，这种情况下我们需要一种解决方案：我们数组容量可伸缩的（动态扩容）


public class ArrayList<T> {
    /** 使用数组存储数据 */
    private T[] data;
    /** size记录当前数组data中实际元素个数 */
    private int size;

    public ArrayList(int capacity) {
        this.data = (T[]) new Object[capacity];
        this.size = 0;
    }
    public ArrayList() {
        this(10);
    }

    /**
     * 获取顺序表中元素个数
     * @return
     */
    public int getSize(){
        return this.size;
    }

    /**
     * 获取顺序表容器
     * @return
     */
    public int getCapacity(){
        return this.data.length;
    }

    /**
     * 判断顺序表是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }


    /**
     * 向顺序表中index位置上添加元素
     * @param index
     * @param e
     */
    public void add(int index, T e){
        if (index < 0 || index > this.size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index < size");
        }
        // 如果当前data数组元素个数为整个数组容量时，进行扩容
        if (this.size == this.data.length){
            resize(2 * this.data.length);
        }
        for (int i = size - 1; i >= index; i--){
            this.data[i + 1] = data[i];
        }
        this.data[index] = e;
        this.size ++;
    }


    /**
     * 在所有元素后添加一个新元素
     * @param e
     */
    public void addLast(T e){
        this.add(size, e);
    }

    /**
     * 在所有元素前添加一个新元素
     * @param e
     */
    public void addFirst(T e){
        this.add(0, e);
    }

    /**
     * 获取指定索引位置上的元素e
     * @param index
     * @return
     */
    public T get(int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal");
        }
        return this.data[index];
    }

    /**
     * 修改指定索引位置上的元素e
     * @param e
     * @param index
     */
    public void set(T e, int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal");
        }
        this.data[index] = e;
    }

    /**
     * 查询顺序表中是否包含指定的元素e
     * @param e
     * @return
     */
    public boolean contains(T e){
        for (int i = 0; i < size; i++){
            if (data[i] == e){
                return true;
            }
        }
        return false;
    }

    /**
     * 查找顺序表中元素e所在的索引，如果元素e不存在返回-1
     * @param e
     * @return
     */
    public int find(T e){
        for (int i = 0; i < size; i++){
            if (data[i].equals(e) ){
                return i;
            }
        }
        return -1;
    }

    /**
     * 删除顺序表中index位置上的元素，返回删除的元素
     * @param index
     * @return
     */
    public T remove(int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Remove failed. Index is illegal");
        }
        T ret  =  this.data[index];
        for (int i = index + 1; i < this.size; i++){
            this.data[i - 1] = this.data[i];
        }
        this.size --;
        this.data[size] = null;
        // 如果当前data数组元素个数为整个数组容量的1/2时，进行缩容
        if (this.size == this.data.length / 2){
            resize(this.data.length / 2);
        }
        return ret;
    }

    /**
     * 删除顺序表中第一个元素，返回删除的元素
     * @return
     */
    public T removeFirst(){
        return this.remove(0);
    }

    /**
     * 删除顺序表中最后一个元素，返回删除的元素
     * @return
     */
    public T removeLast(){
        return this.remove(this.size -1);
    }

    /**
     * 删除指定的元素
     * @param e
     */
    public boolean removeElement(T e){
        int index = this.find(e);
        if (index != -1){
            this.remove(index);

        }
        return false;
    }

    private void resize(int newCapacity) {
        T[] newData = (T[]) new Object[newCapacity];
        for (int i = 0; i < this.size; i++){
            newData[i] = this.data[i];
        }
        this.data = newData;
    }

    @Override
    public String toString() {
        StringBuffer rs = new StringBuffer();
        rs.append(String.format("Array List: size = %d, capacity = %d\n", this.size, this.data.length));
        rs.append("[");
        for (int i = 0; i < this.size; i ++){
            rs.append(this.data[i]);
            if (i != size -1){
                rs.append(", ");
            }
        }
        rs.append("]");
        return rs.toString();
    }
}

 

顺序表的各种操作时间复杂度分析

  • 添加操作
    •  addLast(e)：O(1)
    • addFirst(e)：O(n)
    • add(index, e)：O(n)
  • resize：O(n)
  • 修改操作
    • set：O(1)
  • 删除操作
    • removeLast：O(1)
    • removeFirst：O(1)
    • remove：O(n)
  • 查找操作
    • get(index)：O(1)
    • contains(e)：O(n)​​​​​​​
    • find(e)：O(n)

 

A一念執著
关注
专栏目录
第二章 线性表-顺序表.ppt
09-27
详细解释顺序表的内容，适合初学数据结构的同学们使用
c语言 数据结构线性表
qq_45849625的博客
04-15 825
线性表线性表功能以及线性表的接口实现 线性表功能以及 线性表有动态线性表和静态线性表，线性表本质是有限序列。 线性表和数组的区别： 数组的大小是有限的 不可动态增加或减少。 数组的访问可以直接下标引用，效率更高 线性表是通过结构体实现的，线性表本质是一个结构体数组。 线性表的接口实现 接口实现与学籍管理系统，通讯录等无出其右，均是对结构体进行增 删 查 改 看 创建一个结构体 typedef int SLDataType; typedef struct SeqList { SLDataTyp
基于Java实现动态数组
lwbgxd的博客
07-20 1530
动态数组 动态数组的基本原理 实现一个基本的动态数组，需要实现一些基本的功能，增删改查应该是最基本的了，而在此基础之上还需要实现相应的动态扩容与泛型。对于动态扩容来说，我们需要在数组的使用过程中来进行判断，是否需要进行扩容，以及如何更有效的进行扩容，添加长度还是重新申请。而泛型的实现就需要数组能够接受任何类型的数据。 动态扩容 实现动态扩容的方式有很多，但是在数组的后面接上一段内存是明显不行的，我们需要做的就是重新申请一个更大容量的数组，这样才是可行的方法，但是问题又来了用什么方式来申请才能够最有效的扩容，
【数据结构】实现顺序表以及简单的时间复杂度分析
以后我要当村长
09-19 8743
最近在学数据结构，接下来一段时间我将用java来实现所学的各种数据结构，以加深自己的印象。 线性表包括顺序表和链表，其实顺序表就是动态数组，下面我将二次封装实现属于自己的动态数组。 数组类：Array 数组名：data 数组容量：capacity 已存放元素个数：size 方法： ①获取数组中元素个数（getSize） ②获取数组容量（getCapacity） ③返回数组是否为空...
第二章 线性表 顺序表的两种实现方法及9种基本操作的实现
亓官劼的博客
06-13 6389
**文末附完整测试程序代码** ## 2.2 线性表的顺序表示 ### 顺序表的定义 线性表的顺序存储又称为顺序表。它是用一组地址连续的存储空间来依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。顺序表的特点为：表中元素的逻辑顺序与物理顺序相同。 我们顺序表的定义也可以根据数组的分配类型来分为动态分配和静态分配。
顺序表的基本操作
weixin_43479133的博客
04-07 179
下列全是头文件 #pragma once #include<exception> template<class elemType> class seqList :public List<elemType> { private: elemType*data; //动态数组存储数据元素 int curLength; //当前顺序表中存储的元素个数 i...
第二章：线性表-31
08-03
线性链表是线性表的游标实现，与顺序存储结构不同，它不使用连续的内存空间，而是通过节点之间的链接来组织数据。每个节点包含两部分：数据域用于存储元素，以及指针域指向下一个节点。线性链表分为单链表和双向链表...
2第二章 线性表（顺序表 链表）.pdf
04-20
根据提供的文档信息，我们可以深入探讨线性表的相关概念及其两种主要实现形式——顺序表与链表。 ### 线性表定义 线性表是一种基本的数据结构，它由一系列具有相同特性的数据元素组成，这些元素按照一定的顺序排列...
第二章：线性表-11
08-03
顺序存储结构，也称为顺序表，是通过数组来实现的。数组提供了一组连续的存储空间，线性表中的每个元素都占据数组的一个位置。例如，定义了一个最大长度为100的数组，类型为`LIST`，包含一个`data`数组和一个`last`...
第二章：线性表-21
08-03
如果数据访问主要集中在表的前端，顺序表可能更合适。 总之，理解和掌握线性表的各种实现方式对于学习数据结构和算法至关重要，因为线性表是许多其他复杂数据结构的基础，如栈、队列、树等。了解其内部工作原理和...
顺序表
weixin_45309293的博客
10-19 200
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成据的增删查改。 顺序表一般可分为：静态顺序表（使用定长数组存储）；动态顺序表（使用动态开辟的数组存储）。 静态顺序表适用于确定知道需要存多少数据的场景. 静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用，相比之下动态顺序表更加灵活，根据需要动态分配内存大小。 动态顺序表的实现： public class MyArrayList { public int[] elem; publi
顺序表(Sequential List)
Catherine的笔记
03-05 3580
顺序表(Sequential List) 1. 顺序表的概念 1.1 顺序表的定义 顺序表是线性表基于数组的顺序存储表示。 1.2 顺序表中各元素的逻辑及存储关系 顺序表是按照顺序存储方式存储的线性表， 把线性表中的所有表项按照其逻辑顺序依次存储到从计算机存储中指定存储位置开始的一块连续的存储空间中。 顺序表各个表项的逻辑顺序与其存放的物理顺序一致，即第i个表项存储于第i个物理位置(1<=i<=n)。 由于顺
《JSF教程》-02 JSF与Struts2、Springmvc的对比
isaiah的专栏
08-28 2249
                 一提到MVC框架，可能大家最熟悉的是Struts了，当然像我一样90的程序员，可能一开始就是从struts2学起，直接跳过以老版的struts1。还有人可能在公司用到了Springmvc，哪么它们有哪些区别呢？                其 主要的区别是： struts2和springmvc是基于传统的请求处理模型的MVC框架，而JSF是基于事件处理模型...
JAP和Spring整合的三种方式
isaiah的专栏
08-24 1998
JPA EJB
《JSF教程》-03 环境搭建与第一个入门例子
isaiah的专栏
08-31 1911
在前边我们对JSF做了一个初步的了解，接下来我们搭建JSF开发环境，开发我们的第一个JSF应用吧！              java领域常用的IDE有Eclipse、NetBeans和IDEA，其中 Eclipse和NetBeans免费开源，深受开发者喜爱！，哪么对于JSF支持比较好的还是NetBeans，对于JSF代码提示方面配置文件支持方面都做的很到位，毕竟它是Oracle官方推荐的J
JUC-并发集合类
isaiah的专栏
08-19 862
在大家学习Java基础时都知道，ArrayList、LinkedList、HashMap、HashSet等常用的容器类都是线程不安全的，如果有多个线程访问它们时将会出现意外结果，下边我们讲解如果使用线程安全的集合类。 使用java.util包下线程安全的集合类 使用Collections工具类将非线程安全的集合包装成线程安全的集合 使用juc中的并发集合类 Vector与Hashtable ...
JSF-导航规则配置
isaiah的专栏
07-16 835
JSF导航规则配置
多线程-实现一个简单人Echo服务器
isaiah的专栏
08-19 674
  实现一个简单的Echo服务器 服务器端监听服务端的到来，当监听到客户端到来之后，将创建一个线程去处理客户端Socket     服务器端： public class MultiThreadEchoServer { private static ExecutorService es = Executors.newCachedThreadPool(); /**...
JSF中怎么使用Enum生成下拉列表
isaiah的专栏
09-03 662
在开发中常常遇到可以列举的值：如订单状态，处理中（1）、已发货（2）、已完成（3）、已取消（4）。这种可列举的结果专业的做法是将其类型定义成枚举，下面我们就结合JSF的下拉组件将这种枚举类型加载到我们 下位列表上。  定义订单状枚举类型 OrderStateEnum.java： package com.isaiah.app.base; /** * @author HaijunLiu * @em
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值