顺序表的实现

目录

前言

一、线性表与顺序表

二、顺序表的实现

1.注意问题

2.顺序表的实现

---

前言

线性表的基本概念

线性表的增删改查以及完整实现

一、线性表与顺序表

 线性表是n个具有相同数据类型的元素集合（逻辑上连续，物理上不一定连续）

线性表包括：顺序表（动态数组）、链表、栈、队列、字符串

 顺序表是基于动态数组实现的线性表

二、顺序表的实现

1.注意问题

（1）在数组的插入方法中要注意进行数组的扩容

（2）用Index进行位置索引时，要注意判断索引的合法性

（3）Index的公共方法在插入和查询、设置、删除中是不同的

/**
 * 判断index的合法性(用在查询，设置，改，删除操作中）
 */
private boolean rangeCheck(int index){
    if(index < 0 || index >= size){
        System.out.println("当前index非法，index >= 0 && index < size");
        return false;
    }
    return true;
}

//先判断边界条件 index是否合法
//index = 0 ->头插
//index = data ->尾插
if (index < 0 || index > size){
    System.out.println("index非法，无法进行插入");
    return;
}

//数组内部扩容
private void grow(){
    int oldlength = elementData.length;
    int newlength = oldlength << 1;
    elementData = Arrays.copyOf(elementData,newlength);
}

2.顺序表的实现

package sqelist;

import java.util.Arrays;


public class DynamicArray {
    private int[] elementData;
    private int size;

    public DynamicArray() {
        this.elementData = new int[10];
    }

    public DynamicArray(int size){
        elementData = new int[size];
    }

    /**
     * 在数组头部添加元素
     * @param data
     */
    public void addFirst(int data){
        //此时内部小数组已满需要扩容
        if (size == elementData.length){
            grow();
        }
        for (int i = size - 1; i >= 0; i--) {
            elementData[i+1] = elementData[i];
        }
        elementData[0] = data;
        size ++;
    }


    /**
     * 在数组尾部插入元素
     * @param data
     */
    public void addLast(int data){
        if(size == elementData.length){
            grow();
        }
        elementData[size] = data;
        size ++;
    }

    /**
     * 在数组索引位置添加元素
     * @param Index
     * @param data
     */
    public void addIndex(int index,int data) {
        //先判断边界条件 index是否合法
        //index = 0 ->头插
        //index = data ->尾插
        if (index < 0 || index > size){
            System.out.println("index非法，无法进行插入");
            return;
        }
        //判断当前数组是否已满
        //扩容
        if(size == elementData.length){
            grow();
        }
        //数据插入
        if(index == 0){
            addFirst(data);
        }
        if(index == size){
            addLast(data);
        }else{
            //在数组的中间插入
            for (int i = size -1; i >= index ; i--) {
                elementData[i+1] = elementData[i];
            }
            elementData[index] = data;
            size ++;
        }
    }
    //数组内部扩容
    private void grow(){
        int oldlength = elementData.length;
        int newlength = oldlength << 1;
        elementData = Arrays.copyOf(elementData,newlength);
    }
    /**
     * 取得数组长度
     * @return
     */
    public int getsize(){
        return size;
    }

    /**
     * 将动态数组转化为字符串
     * @return
     */
    public String toString(){
        String ret = "[";
        for (int i = 0; i < size; i++) {
            ret += elementData[i];
            if(i != size - 1){
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }

    /**
     * 将指定位置index的元素修改为newdata
     * @param index
     * @param newData
     * @return 修改前的元素
     */
    public int set(int index,int newData){
        if(rangeCheck(index)){
            int oldValue = elementData[index];
            elementData[index] = newData;
            return oldValue;
        }
        return -1;
    }



    /**
     *取得数组当前索引位置的元素
     * @param index
     * @return
     */
    public int get (int index){
        if(rangeCheck(index)){
            return elementData[index];
        }
        return -1;
    }

    /**
     * 判断index的合法性(用在查询，设置，改，删除操作中）
     */
    private boolean rangeCheck(int index){
        if(index < 0 || index >= size){
            System.out.println("当前index非法，index >= 0 && index < size");
            return false;
        }
        return true;
    }


    /**
     *判断当前集合中是否包含指定元素data
     * @param data
     * @return
     */
    public boolean contains (int data){
        //遍历一遍数组
        for (int i = 0; i < size; i++) {
            if(elementData[i] == data){
                return true;
            }
        }
        return false;
    }

    /**
     * 删除集合中下标为index的元素
     */
    public void remove (int index){
        if (rangeCheck(index)){
            //从index位置开始，将之后的元素统一前移一位
            for (int i = index; i < size; i++) {
                elementData[i]=elementData[i+1];
            }
            size --;
        }
    }

    /**
     * 按置删除，删除线性表中所有值等于value的元素
     * @param value
     */
    public void removeValue(int value){
        for (int i = 0; i < size; i++) {
            while(elementData[i]==value){
                remove(i);
            }
        }
    }



    public static void main(String[] args) {
        DynamicArray dynamicArray = new DynamicArray();
        dynamicArray.addLast(1);
        dynamicArray.addLast(2);
        dynamicArray.addFirst(2);
        dynamicArray.addLast(4);
        dynamicArray.addIndex(1,2);
        //[2,2,1,2,4]
        System.out.println(dynamicArray);
        dynamicArray.removeValue(2);
        System.out.println(dynamicArray);
    }
}