(java实现)顺序表-ArrayList

什么是顺序表

顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。

在使用顺序表存储数据前,会先申请一段连续的内存空间(即数组),然后把数组依次存入内存,中间没有一点空隙。

基本操作

每个数据结构都有集合对数据处理的方法,这能让我们更方便的使用保存在数据结构中的数据。顺序表的基本操作有:增(add),删(remove),改(set),查(find),插(insert)等。

在这里我们只详细讲解remove 和 insert 操作,其他实现可看下面的源码。

顺序表删除元素

从顺序表中删除指定元素,实现起来非常简单,只需找到目标元素,并将其后续所有元素整体前移 1 个位置即可。

后续元素整体前移一个位置,会直接将目标元素删除,可间接实现删除元素的目的。

例如:从顺序表{1,2,3,4,5}中删除元素3的过程如下

时间复杂度分析:从顺序表中删除元素,最好的情况是删除的元素刚好是最后一个元素,这时候不需要移动元素,只需要把顺序表的size-1即可,时间复杂度是O(1)。最坏的情况是删除的元素刚好是第一个元素,这个时候就需要后面的元素全部向前移动一位,同时size-1,时间复杂度是O(N)。我们分析时间复杂度的原则是分析最坏情况,这样才有意义。因此删除操作的时间复杂度为O(N)。

顺序表插入元素

向已有顺序表中插入数据元素,根据插入位置的不同,可分为以下 3 种情况:

  1. 插入到顺序表的表头;
  2. 在表的中间位置插入元素;
  3. 尾随顺序表中已有元素,作为顺序表中的最后一个元素;

虽然数据元素插入顺序表中的位置有所不同,但是都使用的是同一种方式去解决,即:通过遍历,找到数据元素要插入的位置,然后做如下两步工作:

  • 将要插入位置元素以及后续的元素整体向后移动一个位置;
  • 将元素放到腾出来的位置上;

例如,在 {1,2,3,4,5} 的第 3 个位置上插入元素 6,实现过程如下:

时间复杂度分析同删除元素一样,均为O(N).

顺序表的优劣和应用情形

优势
  • 因为数据在数组中按顺序存储,可以通过数组下标直接访问,因此顺序表查找定位元素很快
劣势
  • 插入和删除元素需要大量的操作
  • 因为数组在声明时需要确定长度,因此顺序表的长度是确定的。若需要扩大顺序表长度,有需要大量的操作,不够灵活。(将该数组copy到另外一个数组)
  • 由于数据大小的不可测性,有时会浪费掉大量的空间
应用情形
  • 总而言之,顺序表适用于那些不需要对数据进行大量改动的结构

源码实现(java)

public class MyArrayList<AnyType> {
    public int AMOUNT=10;//初始长度
    public static int index;//表位置
    AnyType[] myList;
    public MyArrayList(){
        initList();
    }

    //初始化顺序表
    public void initList(){
        myList=(AnyType[])new Object[AMOUNT];
        index=0;
    }

    //判断顺序表是否为空
    public boolean listEmpty(){
        if(index==0){
            return true;
        }
        return true;
    }

    //清空顺序表
    public boolean clearList(){
        myList=null;
        index=0;
        return true;
    }

    //返回i位置的元素
    public AnyType get(int i){
        if(i<0||i>=index){
            throw  new ArrayIndexOutOfBoundsException();
        }
        return myList[i];
    }

    //在i位置加入元素,即插入操作,这里我没有用insert命名
    public void add(int i,AnyType a){
        if(i<0||i>index){
            throw new ArrayIndexOutOfBoundsException();
        }
        if (i==index){
            largeList();
        }
        for(int k=index;k>i;k--){
            myList[k]=myList[k-1];
        }
        myList[i]=a;
        index++;
    }

    //在结尾增添元素a
    public void add(AnyType a){
        add(index,a);
    }

    //为i位置元素重新赋值
    public AnyType set(AnyType a,int i){
        if(i<0||i>=index){
            throw new ArrayIndexOutOfBoundsException();
        }
        AnyType old=myList[i];
        myList[i]=a;
        return old;
    }

    //打印遍历顺序表
    public void print(){
        String s="[";
        for(int i=0;i<index;i++){
            s=s+myList[i];
            s=s+" ,";
        }
        System.out.println(s);
    }

    //查找a元素是否在表中,返回位置,没有返回0
    public int locateElem(AnyType a){
        for(int i=0;i<index;i++){
            if(a==myList[i]){
                return i+1;
            }
        }
        return 0;
    }

    //返回表长
    public int length(){
        return index;
    }

    //删除i位置元素
    public AnyType delete(int i){
        if(i<0||i>=index){
            throw new ArrayIndexOutOfBoundsException();
        }
        AnyType old=myList[i];
        for(int k=i;k<index;k++){
            myList[k]=myList[k+1];
        }
        index--;
        return old;
    }

    //扩大表的最大长度
    public void largeList(){
        AnyType[] newList=(AnyType[])new Object[2*length()+1];
        for(int i=0;i<index;i++){
            newList[i]=myList[i];
        }
        myList=newList;
    }

}

原文地址:https://www.cnblogs.com/sang-bit/p/11601482.html

时间: 2024-10-14 22:44:09

(java实现)顺序表-ArrayList的相关文章

JAVA模拟顺序表新增,模拟单链表新增

最近在回顾大学学的数据结构,这里给大家用java模拟顺序表和单链表的新增 1顺序表新增 /** * 顺序表 * * @author cjd * */ public class ArrayList { private Object[] elementData; // 底层是一个数组,目前还没有确定长度 private int size; // 不是数组分配了几个空间,而是元素的个数 public ArrayList() { this(4); } public ArrayList(int initi

Java数据结构-线性表之顺序表ArrayList

线性表的顺序存储结构,也称为顺序表,指用一段连续的存储单元依次存储线性表中的数据元素. 根据顺序表的特性,我们用数组来实现顺序表,下面是我通过数组实现的Java版本的顺序表. package com.phn.datestructure; /** * @author 潘海南 * @Email [email protected] * @TODO 顺序表 * @date 2015年7月16日 */ public class FOArrayList<E> { // 顺序表长度 private int

Java实现顺序表

利用顺序存储结构表示的顺序表称为顺序表. 它用一组连续的地址存储单元一次存放线性表中的数据元素. 顺序表的实现是数据结构中最简单的一种. 由于代码中已经有详细注释,代码外不再阐述. 下次再陈上关于顺序表的循环队列和顺序栈的代码. 1 package 线性表.顺序表.普通数组; 2 3 /** 4 * ArrayList 顺序表 5 * JAVA 3.0 6 * 抛异常处理错误的下标 7 * 使用泛型,当然如果要替换成Object也是可以替换 8 */ 9 public class ArrayLi

线性表 及Java实现 顺序表、链表、栈、队列

数据结构与算法是程序设计的两大基础,大型的IT企业面试时也会出数据结构和算法的题目, 它可以说明你是否有良好的逻辑思维,如果你具备良好的逻辑思维,即使技术存在某些缺陷,面试公司也会认为你很有培养价值,至少在一段时间之后,技术可以很快得到提高.同时,它也是软考的重点,我们需要对这部分的内容进行一下总结. 我们先看一下数据结构和算法的整体内容. 1.线性表 概念: 数据元素的排列方式是线性的. 分类: 分类规则是根据上图中元素的存储结构来划分的. (1)顺序表 基本思想:元素的存储空间是连续的.在内

java实现顺序表结构

package com.hephec; import java.util.Arrays; public class SequenceList<T>{ //以指定长度的数组来创建顺序线性表 //@param element 指定顺序线性表中的第一个元素 //@param initSize 指定顺序线性表底层数组的长度 private int DEFAULT_SIZE = 16; //保存数组的长度 private int capacity; //定义一个数组用于保存顺序线性表的元素 privat

数据结构——Java实现顺序表

一.分析 什么是顺序表?顺序表是指用一组地址连续的存储单元依次存储各个元素,使得在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中的线性表.一个标准的顺序表需要实现以下基本操作: 1.初始化顺序表 2.销毁顺序表 3.清空顺序表 4.检测顺序表是否为空 5.返回顺序表的元素个数 6.返回顺序表中指定位置元素的值 7.返回顺序表中第一个与指定值相同的元素的位置 8.返回指定元素的直接前驱 9.返回指定元素的直接后继 10.向指定位置插入元素 11.删除指定位置的元素 12.遍历顺序表 在Java

Java 3:顺序表的操作

顺序表常见操作有插入.删除.查找.修改.一.插入:1.插入有头插.尾插.任意位置插入.在插入时要注意下标的取值在顺序表长度范围内.所以最好在插入之前进行扩容操作.2.在头插时要注意先将原数组的元素从后往前依次向后移动.因为如果从前往后开始移动的话,会造成后一个元素被前一个元素覆盖,而丢失数据且造成重复.arr[i+1]=arr[i],注意此处i的意思是要移动的元素的下标.3.任意位置插入与头插类似,从后往前(要插入的位置元素下标)依次向后移动,再将数据插入二.删除1.删除有头删.尾删.任意位置删

Java算法 -- 顺序表

顺序表结构定义:就是按照顺序存储方式存储的线性表 1 1.定义一个顺序表的基本数据: 2 3 static final int MAXLEN = 100; 4 5 Class Student{ 6 private String number; //学生学号 7 private String name; // 学生姓名 8 private int age; // 学生年龄 9 } 10 11 Class SLT{ 12 Student[] ListData = new Student[MAXLEN

数据结构顺序表Java实现

Java实现顺序表算法:1:首先我们需要定义我们的接口,关于顺序表的一些基本的操作:顺序表中的操作都有增删改查. //List接口 public interface IList { //返回线性表的大小,即数据元素的个数. public int getSize(); //如果线性表为空返回 true,否则返回 false. public boolean isEmpty(); //判断线性表是否包含数据元素 e public boolean contains(Object e); //返回数据元素