数据结构第二篇【关于java线性表（顺序表）的基本操作】

【关于java线性表（顺序表）的基本操作】

- - 线性表是什么？🐵🐒🦍
  - 顺序表的定义🦧🐶🐵
  - 创建顺序表
  - 新增元素,默认在数组最后新增
  - 在 pos 位置新增元素
  - 判定是否包含某个元素
  - 查找某个元素对应的位置
  - 获取 pos 位置的元素
  - 给 pos 位置的元素设为 value 更新
  - 删除第一次出现的关键字key
  - 获取顺序表长度
  - 清空顺序表
  - 打印顺序表

本文主要讲解关于顺序表的基本操作，希望大家能够自己动手敲一敲🐒🦍🦧🐶

在这里插入图片描述

线性表是什么？🐵🐒🦍

线性表是一种数据结构，是由零个或多个数据元素的有限序列组成的。每个元素除了第一个元素外，都有一个直接前驱元素，除了最后一个元素外，都有一个直接后继元素。线性表的数据集合为{a1,a2,…,an}，每个元素的类型均为DataType。线性表是存储逻辑关系为"一对一"的数据的最简单一种存储结构。线性表的物理结构不一定是连续的。

顺序表的定义🦧🐶🐵

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表：可动态增长的数组，要求数据是连续存储的，动态顺序表就是使用动态开辟的数组存储，我会通过代码来给大家讲解

以下顺序表中的方法是需要掌握的

public interface IList2 {
    //新增元素,默认在数组最后新增
    public void add(int data);
    // 在 pos 位置新增元素
    public void add(int pos, int data);
    // 判定是否包含某个元素
    public boolean contains(int toFind) ;
    // 查找某个元素对应的位置
    public int indexOf(int toFind);
    // 获取 pos 位置的元素
    public int get(int pos);
    // 给 pos 位置的元素设为 value  更新
    public void set(int pos, int value);
    //删除第一次出现的关键字key
    public void remove(int toRemove) ;
    // 获取顺序表长度
    public int size();
    // 清空顺序表
    public void clear() ;
    // 打印顺序表
    public void display();

    boolean isFull();
	//数组是否满了
    public boolean isEmpty();
    //数组是否为空
}

创建顺序表

public class MyArrayList {
   public int[] elem;
   public int usedSize;                    
   public static final int DEFAULT_SIZE=10;
   public MyArrayList(){
       this.elem = new int[DEFAULT_SIZE];  
   }
   public MyArrayList(int capacity){
       this.elem = new int[capacity];     
   }

首先我们创建一个顺序表（看做一个数组），有两个属性，第一个elem为数组，第二个为usedSize表示有效数据的个数。数组的长度我们通过构造方法来初始化，第一种是创建一个数组长度为10（用常量DEFAULT_SIZE表示）的数组,第二种是通过传参数来自定义数组的长度。

新增元素,默认在数组最后新增

在敲代码以前，我们需要考虑一个情况，如果数组满了，怎么才能添加元素，所以我们在添加元素之前，检查一下数组是否满了，如果满了，我们将进行扩容，再添加元素。而检查数组我们定义一个方法以后用到直接调用即可。我们需要用到两个方法一个为检查是否满了，一个方法来扩容。

 public void add(int data) {
 		 checkCapacity();  //检查容量
         this.elem[this.usedSize] = data;
         this.usedSize++;
    }

 private void checkCapacity(){  
        if(isFull()){
            //扩容
            elem = Arrays.copyOf(elem,elem.length*2);//将elem数组的长度扩容为原来的两倍
        }
 }
  public boolean isFull() {
        return usedSize==elem.length; //数组长度是否等于有效数据的长度
 }

在 pos 位置新增元素

我们首先需要思考，pos位置是否合法，pos如果为-1，或者超多数组长度，则不再新增，那么我们使用自定义异常来处理，如果pos合法，在检查数组的容量，最后在新增元素，新增元素时，我们将从最后一个有效元素向后移动，依次向前，直到i<pos，pos位置为空，将elem[pos] 位置插入数据

public void add(int pos, int data) {
        try {
            checkPosOnAdd(pos);
        }catch (PosILLegality e){
            e.getStackTrace();
            return;
        }
        checkCapacity();
        for(int i = usedSize-1;i>=pos;i--){
            elem[i+1]=elem[i];
        }
        elem[pos] = data;
        usedSize++;
    }
    private void checkPosOnAdd(int pos)throws PosILLegality{
        if(pos<0&&pos>usedSize){
            System.out.println("不符合法");
            throw new PosILLegality("插入元素下标异常"+pos);
        }
    }
    public class PosILLegality extends RuntimeException{
    public PosILLegality(String msg){
        super(msg);
    }
}

判定是否包含某个元素

首先需要考虑如果数组为空，没有元素则不查找，直接返回false,其次，遍历数组查看是否存在

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

查找某个元素对应的位置

首先判断数组是否为空，然后在进行查找，找到返回下标

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

获取 pos 位置的元素

首先，判断pos位置是否合法，与新增元素不同（新增元素可以在数组最后新增）查找元素（只能在有效数据中查找），范围有差异，如果pos不合法直接抛出自定义异常，其次判断数组是否为空，最后在返回pos位置的元素。

 public int get(int pos) throws MyArrayListEmpty{
        checkPosOnGetAndSet(pos);
        if(isEmpty()){
            throw new MyArrayListEmpty("获取指定下标元素时"+"顺序表位空");
        }
        return elem[pos];
    }

    private void checkPosOnGetAndSet(int pos) throws PosILLegality {
        if (pos < 0 || pos >= usedSize) {
            System.out.println("不符合法");
            throw new PosILLegality("获取制定下标的元素异常" + pos);

        }
    }
    public class PosILLegality extends RuntimeException{
    public PosILLegality(String msg){
        super(msg);
    }
}
public class MyArrayListEmpty extends RuntimeException{
    public MyArrayListEmpty(String msg){
        super(msg);
    }
}

给 pos 位置的元素设为 value 更新

首先，判断pos位置是否合法，与新增元素不同（新增元素可以在数组最后新增）查找元素（只能在有效数据中查找），范围有差异，如果pos不合法直接抛出自定义异常，如果合法，在进行修改元素

public void set(int pos, int value) {
            checkPosOnGetAndSet(pos);
            elem[pos]=value;
    }
private void checkPosOnGetAndSet(int pos) throws PosILLegality {
        if (pos < 0 || pos >= usedSize) {
            System.out.println("不符合法");
            throw new PosILLegality("获取制定下标的元素异常" + pos);

        }
    }
 public class PosILLegality extends RuntimeException{
    public PosILLegality(String msg){
        super(msg);
    }
}

删除第一次出现的关键字key

首先用java自带函数找到关键字的下标，如果存在，那么如何删除呢，我们通过要删除的元素的后一个往前盖，元素i范围小于usedSize-1，如果等于usedSize-1，elem[i-1]将会越界

 public void remove(int toRemove) {
        int index = indexOf(toRemove);
        if(index==-1){
            System.out.println("没有这个数字");
            return;
        }
        for(int i =index;i<usedSize-1;i++){
            elem[i]=elem[i+1];
        }
        usedSize--;
    }

获取顺序表长度

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

清空顺序表

public void clear() {
            this.usedSize=0;
    }

打印顺序表

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