java顺序表详解

1. 顺序表的框架

class Myarraylist<E> {
    private E[] element;
    private static final int n=3;//数据的长度
    private int size; //数据当前个数
    public Myarraylist() {
        element=(E[])new Object[n];
    }
    private E[] dilatation(E[] arr) { //扩容}
    public int index(E key) { //查找元素返回元素下标}
    public boolean idEmpty() { //判断是否为空}
    public int size() { //返回元素个数}
    public  E search(E key) { //查找并返回个与key相等的元素,若查找不成功则返回null}
    public E get(int i) { //返回第i个元素}
    public E set(int i,E x) { //设置第i个元素为x}
    public int insert(E x) { //在表尾插入x元素}
    public int insert(int i,E x) { //插入x,作为第i个元素}
    public String toString() { //返回所有元素的描述字符}
    public E remove(int i){ //删除第i个元素,返回并删除元素}
    public E remove(E key) { //查找并删除首个与key相等的元素,返回被删除的元素}
    public void clear() { //删除所有元素}
}

2. 顺序表的具体实现

1 .顺序表的初始化

先定义构造一个顺序表

    private E[] element;
    private static final int n=3;//数据的长度
    private int size; //数据当前个数

再利用构造方法对顺序表进行初始化

    public Myarraylist() {
        element=(E[])new Object[n];
    }

2.顺序表的扩容

这里新建了一个数组,在将之前数组的内容拷贝到新数组当中后,在进行返回

  private E[] dilatation(E[] arr) { //扩容
        E[] tmp=(E[])new Object[element.length*2]; //获取一个更大的数组 
        for(int i=0;i<size;i++) {  //将之前的数组拷贝到这个新数组当中
            tmp[i]=element[i];
        }
        return tmp; //把新数组返回返回
    }

3.查找元素并且返回下标

对每个元素进行遍历,使用equals进行比较,当存在元素则返回下标,不存在则返回-1

    public int index(E key) { //查找元素返回元素下标
        for (int i = 0; i < size; i++) {
            if(element[i].equals(key)) {
                return i;
            }
        }
        return -1;
    }

4.判断顺序表是否为空

为空返回true否则false

    public boolean idEmpty() { //判断是否为空
        if(size==0) {
            return true;
        }
        return false;
    }

5.返回顺序表元素个数

      public int size() { //返回元素个数
        return size;
      }

6.查找首个与key相等的元素

利用index方法找到与key相等元素的下标,如果存在则返回该元素,否则返回null

    public  E search(E key) { //查找并返回个与key相等的元素,若查找不成功则返回null
        int i=index(key);
        if(i!=-1) {
            return element[i];
        }else {
            return null;
        }
    }

7.返回第以i为下标的元素

判断i的值是否合法,合法返回元素否则返回null

    public E get(int i) { //返回第i个元素
        if(i<size&&i>=0)  {
            return element[i];
        }else {
            return null;
        }
    }

8.设置第i个元素为x

判断i的值是否合法,合法则设置其内容为x 否则返回null

    public E set(int i,E x) { //设置第i个元素为x
        if(i<size&&i>=0)  { //判断下标是否合法
            return element[i]=x;
        }else {
            return null;
        }
    }

9.在表尾插入元素

先判断顺序表是否满了,满了时需要进行扩容在进行插入

    public void insert(E x) { //在表尾插入x元素
        if(size==element.length) { //判断顺序表是否满了
            element=dilatation(element);
        }
        element[size++]=x;
    }

10.在i下标插入一个元素x

检查数组容量,满了进行扩容 在判断i的值是否合法,合法则进行插入并且返回1,不合法则返回-1

    public int insert(int i,E x) { //插入x,作为第i个元素
        if(size==element.length) {
            element=dilatation(element);
        }
        if(i<size&&i>=0) {
            for (int j = size - 1; j >= i; j--) {
                element[j + 1] = element[j];
            }
            element[i] = x;
            size++;
            return 1;
        }else {
            return -1;
        }

    }

11.打印顺序表内容

    public String toString() { //返回所有元素的描述字符
        String tmp=new String();
        int i;
        for (i = 0; i < size-1; i++) {
            tmp+=element[i]+" ";
        }
        tmp+=element[i];
        return tmp;
    }

12.删除第i个元素

判断i下标值是否合法,合法则讲i后面的元素向前移动一步

    public E remove(int i){ //删除第i个元素,返回并删除元素
        E tmp=element[i];
        if(i<size&&i>=0) {
            for (int j = i; j < size-1; j++) { //i后面的所有数据向前移动1步
                element[j]=element[j+1];
            }
            element[size-1]=null;
            size--;
            return tmp;
        }else {
            return null;
        }
    }

13.删除首个与key相等的元素

先查找该元素下标,判断是否存在,存在则将i后面的元素往前移动一步,在将最后一个设置为null

    public E remove(E key) { //查找并删除首个与key相等的元素,返回被删除的元素
        int i=index(key);
        if(i==-1) {
            return null;
        }
        E tmp = element[i];
        for (int j = i; j < size; j++) {
             element[j]=element[j+1];
        }
        element[--size]=null;
        return tmp;
    }

14.清空顺序表

    public void clear() { //删除所有元素
        for (int i = 0; i <size ; i++) {
            element[i]=null;
        }
        size = 0;
    }

3. 全部代码

class Myarraylist<E> {
    private E[] element;
    private static final int n=3;//数据的长度
    private int size; //数据当前个数
    public Myarraylist() {
        element=(E[])new Object[n];
    }
    private E[] dilatation(E[] arr) { //扩容
        E[] tmp=(E[])new Object[element.length*2]; //获取一个更大的数组 
        for(int i=0;i<size;i++) {  //将之前的数组拷贝到这个新数组当中
            tmp[i]=element[i];
        }
        return tmp; //把新数组返回返回
    }
    public int index(E key) { //查找元素返回元素下标
        for (int i = 0; i < size; i++) {
            if(element[i].equals(key)) {
                return i;
            }
        }
        return -1;
    }
    public boolean idEmpty() { //判断是否为空
        if(size==0) {
            return true;
        }
        return false;
    }
    public int size() { //返回元素个数
        return size;
    }
    public  E search(E key) { //查找并返回个与key相等的元素,若查找不成功则返回null
        int i=index(key);
        if(i!=-1) {
            return element[i];
        }else {
            return null;
        }
    }
    public E get(int i) { //返回第i个元素
        if(i<size&&i>=0)  {
            return element[i];
        }else {
            return null;
        }
    }
    public E set(int i,E x) { //设置第i个元素为x
        if(i<size&&i>=0)  { //判断下标是否合法
            return element[i]=x;
        }else {
            return null;
        }
    }
    public void insert(E x) { //在表尾插入x元素
        if(size==element.length) { //判断顺序表是否满了
            element=dilatation(element);
        }
        element[size++]=x;
    }
    public int insert(int i,E x) { //插入x,作为第i个元素
        if(size==element.length) {
            element=dilatation(element);
        }
        if(i<size&&i>=0) {
            for (int j = size - 1; j >= i; j--) {
                element[j + 1] = element[j];
            }
            element[i] = x;
            size++;
            return 1;
        }else {
            return -1;
        }

    }
    public String toString() { //返回所有元素的描述字符
        String tmp=new String();
        int i;
        for (i = 0; i < size-1; i++) {
            tmp+=element[i]+" ";
        }
        tmp+=element[i];
        return tmp;
    }
    public E remove(int i){ //删除第i个元素,返回并删除元素
        E tmp=element[i];
        if(i<size&&i>=0) {
            for (int j = i; j < size-1; j++) { //i后面的所有数据向前移动1步
                element[j]=element[j+1];
            }
            element[size-1]=null;
            size--;
            return tmp;
        }else {
            return null;
        }
    }
    public E remove(E key) { //查找并删除首个与key相等的元素,返回被删除的元素
        int i=index(key);
        if(i==-1) {
            return null;
        }
        E tmp = element[i];
        for (int j = i; j < size; j++) {
             element[j]=element[j+1];
        }
        element[--size]=null;
        return tmp;
    }
    public void clear() { //删除所有元素
        for (int i = 0; i <size ; i++) {
            element[i]=null;
        }
        size = 0;
    }
}

4.运行结果

---

内容完结