顺序表和链表＜1＞

1.线性表是具有相同特征的数据元素的有限序列常见的线性表：顺序表，链表，栈，队列，字符等

通常以数组或者链式存储。

 

                         单链表

 

                     双向链表

2.顺序表

 一般采用数组存储，在数组上实现增删改查

静态顺序表：使用定长数组存储。

动态顺序表：使用动态开辟的数组存储。

 3.动态顺序表支持的接口

public class SeqList {        

// 打印顺序表

public void display() {   }    

// 在 pos 位置新增元素    

public void add(int pos, int data) { }    

// 判定是否包含某个元素    

public boolean contains(int toFind) { return true; }    

// 查找某个元素对应的位置    

public int search(int toFind) { return -1; }    

// 获取 pos 位置的元素    

public int getPos(int pos) { return -1; }    

// 给 pos 位置的元素设为 value    

public void setPos(int pos, int value) {   }  

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

public void remove(int toRemove) {   }  

  // 获取顺序表长度    

public int size() { return 0; }    

// 清空顺序表    

public void clear(){}

}

 4.接口的底层实现

 ArrayList中的代码

import java.util.Arrays;
public class ArrayList {
    int[] elem;//来存储线性表
    int usedSize;//当前线性表的长度

    //构造方法
    public ArrayList(int capcity){
        elem=new int[5];
        usedSize=0;

    }

    //是否满了
    public boolean isFull(){
        if(usedSize==elem.length){
            return true;
        }
        return false;
    }

    // 进行拷贝
    public void resize(){
        elem= Arrays.copyOf(elem,elem.length*2);

    }

    // 在 pos 位置新增元素
    public  void add(int pos,int data){
        //插入位置必须合法
        if(pos<0||pos>usedSize){
            System.out.println("pos位置不合法");
        }
        //插入需要考虑插入位置和数组长度等于使用长度就满了插不了了，可以对数组长度扩充2倍
        if (isFull()){
            resize();
        }

        if(usedSize==elem.length){
            System.out.println("顺序表满了");
        }

        //插入可以把元素从后面开始依次移动
        for(int i=usedSize-1;i>=pos;i--){
            elem[i+1]=elem[i];

        }
        elem[pos]=data;//挪好后把数据放入需要插入的位置
        usedSize++;//数组的使用长度加1

    }

    // 打印顺序表
    public void display(){
        for(int i=0;i<usedSize;i++){
            System.out.println(elem[i]+"");
        }
        System.out.println();
    }

    // 判定是否包含某个元素
    public boolean contains(int toFind){
        //对其进行遍历，看有没有那个数
        for(int i=0;i<usedSize;i++){
            if (elem[i] == toFind) {
                return true;

            }
        }
        return false;
    }

    //查找某个元素对应的位置
    public int search(int toFind){
        //对其进行遍历，看有没有那个数，若有，返回那个数的下标
        for (int i = 0; i <usedSize ; i++) {
            if (elem[i]==toFind){
                return i;
            }
        }
        return -1;
    }

    // 获取 pos 位置的元素
    public int getPos(int pos){
        if(pos<0||pos>=usedSize){
            System.out.println("pos位置不合法");
            return -1;
        }
        return elem[pos];
    }

    // 获取顺序表长度
    public int size(){
        return usedSize;
    }

    //给pos位置设定value值
    public void setPos(int pos,int value) {
        if(pos<0||pos>usedSize){
            System.out.println("pos位置不合法");
            return;
        }
        elem[pos]=value;
    }

    //删除第一次出现关键字的位置
    public void remove(int toRemove){
        //1.找到toRemove 的位置
        int index=search(toRemove);
        if(index==-1){
            System.out.println("没有这个数字");
        }
        // 2.删除 int i=index;
        //删除只需要找到那个位置后，它后面的元素往前移动即可
        for (int i = index; i <usedSize-1 ; i++) {
            elem[i]=elem[i+1];
        }
        //删除元素后它的使用长度也会减1
        usedSize--;
    }
    
    //清空顺序表
    public void clear(){

        usedSize=0;
    }

}

TestArrayList中的代码：

注：测试我只是选了几个测试

public class TestArrayList {
    public static void main(String[] args) {
    //public void(int pos,int data)pos位置新增元素
     ArrayList myArrayList=new ArrayList(5);
     myArrayList.add(0,8);
     myArrayList.add(0,4);
     myArrayList.add(0,7);
     myArrayList.add(0,6);
     boolean t=myArrayList.isFull();
     System.out.println(t);
     myArrayList.display();
     myArrayList.add(1,5);
     myArrayList.add(3,9);
     myArrayList.display();
     boolean s=myArrayList.contains(9);
     System.out.println(s);


    }


}