数据结构—顺序表

一、概述

顺序表是逻辑结构上连续,物理结构上也连续的,一般由数组的形式存储

二、简单的方法实现

java 复制代码

public class MyArrayList implements IList{
    public int[] elem;
    public int usedSize;
    public static final int DEFAULT_CAPACITY=10;

    public MyArrayList() {
        this.elem = new int[DEFAULT_CAPACITY];
    }

    @Override
    public void set(int pos, int data) {
        if (isEmpty()){
            throw new EmptyListExpection(Constant.EMPTY_LIST);
        }
        checkPosAdd(pos,"位置不合法");
        elem[pos] =data;
    }
    @Override
    public void remove(int toRemove) {
        if (isEmpty()){
            throw new EmptyListExpection(Constant.EMPTY_LIST);
        }
        int index=indexOf(toRemove);
        if (index == -1){
            System.out.println("没有找到需删除的数据");
            return;
        }
        for (int i = index; i <usedSize-1 ; i++) {
            elem[i] = elem[i+1];
        }
        //如果删除的是引用类型,就需要置为空
        //elem[usedSize] = null;
        usedSize--;
    }
    @Override
    public void add(int pos, int data) {
        //判断是不是满的
        if (isFull()){
            grow();
        }
        checkPosAdd(pos,"pos位置不合法");
        //1.判断是否放在最后一位上
        if (pos == usedSize){
            elem[pos] = data;
            usedSize++;
            return;
        }
        //2.如果在中间就需要移动数据
        for (int i =usedSize-1;i>=pos;i--){
            elem[i+1] =elem[i];
        }
        elem[pos] =data;
    }
    private void checkPosAdd(int pos,String msg){
        if (pos< 0||pos >usedSize){
            throw new PosIllegalityException(msg);
        }
    }

    @Override
    public void add(int data) {
        //1.判断顺序表是否满了
        if(isFull()){
            grow();
        }
        //2.如果满了,就进行扩容
        this.elem[this.usedSize]=data;
        this.usedSize++;
    }
    private boolean isFull(){
        return this.usedSize == elem.length;
    }

    private void grow(){

        this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
    }

    @Override
    public int get(int pos) {
        if (isEmpty()){
            throw new EmptyListExpection(Constant.EMPTY_LIST);
        }
        checkPos(pos,"当前给出的位置不合法");
        return this.elem[pos];
    }
    private boolean isEmpty(){
      return usedSize == 0;
    }
    private void checkPos(int pos,String msg){
        if (pos<0 || pos >= usedSize){
            throw new PosIllegalityException(msg);
        }
    }

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

    @Override
    public boolean contain(int toFind) {
        for (int i = 0; i <usedSize ; i++) {
            if (this.elem[i] == toFind){
                return true;
            }
        }
        return false;
    }

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

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

三、顺序表的三种构造方法

无参数的构造方法

java 复制代码

ArrayList<Integer> list = new ArrayList<>();

对于没有参数的构造方法来说,默认分配的数组大小为10;

之后扩容就是1.5倍的扩容

有一个参数的构造方法

(1)参数是填写顺序表的容量

java 复制代码

 ArrayList<Integer> list2 = new ArrayList<>(66);

(2)参数是填写作为实现Collention的接口都可以填写且数据类型必须是该顺序表的本身或者子类

(用其他的集合类来构造一个顺序表)

java 复制代码

 ArrayList<Integer> list3 = new ArrayList<>();
 ArrayList<Integer> list4 = new ArrayList<>(list3);

四、真正顺序表的方法使用

java 复制代码

 ArrayList<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(1,6);
        list.add(7);
        list.add(8);
        List<Integer> sub =list.subList(1,3);
        System.out.println(sub);
        list.add(1,895);
        System.out.println(list);
//        Integer ii =6;
//        list.remove(ii);
//        list.remove(new Integer(6));
//        System.out.println(list);
//        ArrayList<Integer> list2 = new ArrayList<>();
//        list2.add(99);
//        list2.addAll(list);
//        System.out.println(list2);

五、顺序表的三种遍历方式

for循环遍历

java 复制代码

ArrayList<Integer> list =new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        for (int i = 0; i < list.size(); i++) {
            Integer a =list.get(i);
            System.out.print( a +" ");
        }
        System.out.println();

for-each遍历

java 复制代码

 for (int x: list) {
            System.out.print(x+" ");
        }
        System.out.println();

使用迭代器遍历

java 复制代码

Iterator<Integer>  it=list.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
        System.out.println("=========迭代器2==========");
        //从指定位置打印
        ListIterator<Integer> it2 =list.listIterator(2);
        while(it2.hasNext()){
            System.out.print(it2.next()+" ");
        }
        System.out.println();
        System.out.println("=========迭代器3===========");
        //从后往前打印
        ListIterator<Integer> it3 =list.listIterator(list.size());
        while(it3.hasPrevious()){
            System.out.print(it3.previous()+" ");

注:只要实现了Interable接口都可以使用迭代器遍历