Java学习笔记（十三）数据结构 —— 线性表（数组方式实现）

蓝色为后补入完善部分

根据了解的基础的数据结构知识框架

今天尝试实现的就是线性表，用数组的方法来实现。

为啥明明有现成的数组还要“自作多情”造车轮

• 现成数组固定大小，不能更改，不灵活
• 现成数组功能简单，没有增删改查、排序等buff
• 知道一些底层的实现方法，有利于锻炼代码能力，全面思维能力
• 磨刀不误砍柴工，自己写很麻烦，有需求的时候用起来很好用，很香（）

模板类设置

public interface ByInterface<E> {

}

public class ByList<E> implements ByInterface<E>{

}

//E为通配符

//需要用到类型值的地方就可以设置为E，之后创建对象时，传入什么类型就是什么类型的List

功能框架罗一罗

interface ：声明方法

class      ：声明属性+方法实现

属性

maxSize ：线性表可以申请的最大长度，一般为Integer的最大表示范围 2^31，也可以自己设置。

length：当前线性表的长度。等于byArray.length。

size        ：现在元素的个数。

defaultSize ：默认线性表的长度，可以自己设置。

curr ：当前游标指向的二维数组索引。

byArray：（object或者int类型都可以）一位数组，用来储存元素。

方法

所有方法都注意越界判断：越界：游标不>size，不<0。长度不>maxSize，不<=0。

get方法：maxSize，size，defaulSize，curr

set方法：curr

init（）：无参数初始化，长度为默认长度，游标为0。

init（int size）：有长度的初始化，指定长度合法：长度为指定长度，游标为0。

init（Object[] list）：根据传入数组初始化。（也可以是二维数组）

grow（）：扩容函数，扩容倍数可以自己设定，初步设计为原来的1.5倍，向下取整。扩容范围合

                   法，扩容后元素导入新的大数组，数组改变，长度改变。

insert（object value）：默认在游标处插入value。扩容。

insert（int index ，object value）：在index处插入值value。扩容。

add（object value）：在末尾插入value。扩容。

remove（object value）：删除所有等于value的元素，元素前移，size-个数。

remove（int index）：删除下标为index的元素，元素前移，size--。

replace（object value1，object value2）：用value2代替所有值为value1的元素。

replace（int index，object value2）：用value2代替下标为index的元素。

find（object value）：查找值为value的元素，返回下标数组。

find（int index）：查找下标为index的值，返回这个元素。

sort（int type）：类型为0，从小到大排序，类型为1，从大到小排序。（问题在于object类型无法排序。。待解决）

解决方案：

在方法框架里面先判断传入参数byArray是不是Interger（int的包装类）类型，如果是就实现排序算法，不是则先不管。

判断方法instanof。

判断是int类型，向下转型，创建新数组，一个一个元素转。

排序算法quickSort，调用即可。

排序之后再转回去赋值给byArray。

如果不是interger

就先记录hashcode，按照hashcode的排序结果给byArray元素排序。

merge（ByList list2）：本list和list2合并，本在前，list2在后。

mergeNoRepeat（ByList list2）：本list和list2去重合并，本在前，list2在后。

代码

//ByInterface.java

public interface ByInterface {
    public void init();
    public void init(int initLength);
    public void init(Object[] initArray);
    public void grow();                //扩容
    public void insert(Object value);  //curr插入 值
    public void insert(int index,Object value);     //index插入 下标
    public void add(Object value);     //末尾插入
    public void remove(Object value);  //移除 值
    public void remove(int index);     //移除下标
    public void replace(Object value1,Object value2); //改 值1改为2
    public void replace(int index,Object value);      //下标index 改为value
    public int[] find(Object value);   //根据值传输下标数组
    public Object find(int index);     //根据下标找值
    public void sort(int type);
    public ByList merge(ByList list2);
    public ByList mergeNoRepeat(ByList list2);
}



//ByList.java

import java.lang.module.FindException;

public class ByList implements ByInterface{
    private int maxSize = Integer.MAX_VALUE; //最大规模，可以为MAX_SIZE
    private int length;  //当前数组规模
    private int size;    //当前元素个数
    private int curr;    //当前下标
    private int defaultSize = 20; //默认规模
    private Object[] byArray;


    public void setCurr(int index){ this.curr = index; }

    public int getCurr() {
        return curr;
    }

    public int getMaxSize() {
        return maxSize;
    }

    public int getSize() {
        return size;
    }

    public int getLength() { return length; }

    public int getDefaultSize() {
        return defaultSize;
    }

    @Override
    public void init() {
        length = defaultSize;
        byArray = new Object [length];
        size = 0;
        curr = 0;
    }
    public void init(int initLength) {
        if(initLength<=0){
            System.err.println("申请长度<=0,不属于合法范围！");
            return;
        }
        if(initLength>maxSize){
            System.err.println("申请长度>maxSize,不属于合法范围！");
            return;
        }
        if(initLength <= defaultSize){
            init();
        }
        if (initLength > defaultSize){
            this.length = initLength;
            byArray = new Object [this.length];
            this.size =0;
            this.curr = 0;
        }
    }

    @Override
    public void init(Object[] initArray) {
        size = length = initArray.length;
        curr=0;
        byArray = new Object[length];
        for (int i=0;i<size;i++){
            byArray[i] = initArray[i];
        }
    }

    @Override
    public void grow() {
        int oldSize = length;
        if((oldSize >> 1) + oldSize >maxSize)
            System.err.println("超过最大长度，扩容失败！");
        int newSize = (oldSize >> 1) + oldSize;
        length = newSize;
        Object[] tempArray = new Object[length];
        for (int i=0;i<oldSize;i++){
            tempArray[i] = byArray[i];
        }
        byArray = tempArray;
        tempArray = null;
    }

    @Override
    public void insert(Object value) {
        if(curr <0){
            System.err.println("小主当前游标位置 <0 ,请重新设置游标！");
            return;
        }
        if(curr >= length){
            System.out.println("小主越界了，现在为您扩容");
            grow();
        }
        for (int i=size;i>curr;i--)
            byArray[i]=byArray[i-1];
        byArray[curr]=value;
        size++;
    }

    @Override
    public void insert(int index,Object value) {
        if(index <0 || index >size){
            System.err.println("小主想要插入的位置越界(<0 或 >最大索引范围<索引范围0-元素个数>)了，请重新选位置插入值");
            return;
        }
        if(index == size){
            System.out.println("小主想要插入的位置为末尾，为您插入");
            add(value);
            return;
        }
        if(size==length)
            grow();
        for (int i=size;i>index;i--)
            byArray[i]=byArray[i-1];
        byArray[index]=value;
        size++;
    }

    @Override
    public void add(Object value) {
        if(size==length)
            grow();
        byArray[size++]=value;
    }

    @Override
    public void remove(Object value) {
        //边找边删
        for(int i=0;i<size;i++){
            if(byArray[i].equals(value)){
                size--;
                for(int j=i;j<size;j++)
                    byArray[j]=byArray[j+1];
            }
        }
        //另一种写法 先找后删
//        int[] indexS =find(value);
//        for (int i=0;i<size;i++){
//            if(indexS[i+1]==-1){
//                for (int j=indexS[i];j<size-i-1;j++){
//                    byArray[j]=byArray[j+1+i];
//                }
//                size =i+1;
//                break;
//            }
//            for (int j=indexS[i];j<indexS[i+1]-i-1;j++){
//                byArray[j]=byArray[j+1+i];
//            }
//        }
    }

    @Override
    public void remove(int index) {
        if(index <0 || index >=size){
            System.err.println("小主想要移除值的位置越界(<0 或 >最大长度)了，请重新选位置移除值");
            return;
        }
        size--;
        for(int i=index;i<size;i++){
            byArray[i]=byArray[i+1];
        }
    }

    @Override
    public void replace(Object value1, Object value2) {
        for(int i=0;i<size;i++){
            if(byArray[i].equals(value1))
                byArray[i]=value2;
        }
    }

    @Override
    public void replace(int index, Object value) {
        if(index <0 || index >=size){
            System.err.println("小主想要移替换的位置越界(<0 或 >最大长度)了，请重新选位置替换值");
            return;
        }
        byArray[index]=value;
    }

    @Override
    public int[] find(Object value) {
        int countSize=0;
        int[] indexS = new int[size];
        for (int i=0;i<size;i++){
            if (byArray[i].equals(value)) {
                indexS[countSize] = i;
                countSize++;
            }
        }
        indexS[countSize]=-1;
        return indexS;
    }

    @Override
    public Object find(int index) {
        if(index <0 || index >=size){
            System.err.println("小主想要移替换的位置越界(<0 或 >最大长度)了，请重新选位置替换值");
            return null;
        }
        return byArray[index];
    }

    @Override
    public void sort(int type) { //0 从小到大  1从大到小
        if(this.byArray[0] instanceof Integer){
            int [] byIntArray = new int[this.size];
            //byIntArray = (int[]) this.byArray;
            for (int i=0;i<this.size;i++) {
                byIntArray[i] = (int) this.byArray[i];
                System.out.print(byIntArray[i]+" ");
            }
            quickSort(0,size-1, byIntArray);  //Object 无法比大小，int无法强转
            for (int i=0;i<this.size;i++)
                this.byArray[i]=byIntArray[i];
            if(type==0){  //快排
                return;
            }
            else {
                Object[] tempArray =new Object[length];
                for(int i=0;i<size;i++) {
                    tempArray[i]=byArray[size-1-i];
                }
                byArray = tempArray;
                tempArray = null;
            }
        }
    }

    @Override
    public ByList merge(ByList list2) {
        int newSize = size+list2.getSize();
        Object[] tempArray = new Object[newSize];
        for(int i=0;i<size;i++){
            tempArray[i]=byArray[i];
        }
        for(int j=size;j<newSize;j++){
            tempArray[j] = list2.byArray[j-size];
        }
        size = newSize;
        length = newSize;
        byArray = tempArray;
        tempArray = null;
        return this;
    }

    @Override
    public ByList mergeNoRepeat(ByList list2) {
        return null;
    }

    public void quickSort(int left,int right,int[] myArray){
        if(left >= right)
            return;
        System.out.println("quicksort inside:"+left+" "+right);
        int i=left,j=right;
        //int realLeft = left,realRight = right;
        while(i<=j) {
            while (myArray[j] > myArray[left] && j > i) {
                j--;
            }
            while (myArray[++i] < myArray[left] && i < j) {
            }
            if(i==j){
                int temp = myArray[left];
                myArray[left] = myArray[i];
                myArray[i] = temp;
                break;
            }
            else if(i<j) {
                int temp = myArray[j];
                myArray[j] = myArray[i];
                myArray[i] = temp;
            }
        }
        quickSort(left,i-1,myArray);
        quickSort(i+1,right,myArray);
    }

    public void print(){
        for(int i=0;i<size;i++)
            System.out.println(byArray[i]);
        System.out.println();
    }
    public static void main(String[] args){
        ByList list = new ByList();
        list.init(12);
        for(int i=0;i<12;i++)
            list.insert(i+1);
        list.print();
        list.insert(10);
        list.print();
        list.sort(0);
        list.print();

//        list.insert(15,20);
        list.remove((Object) 10);
        list.print();
        list.remove(1);
//        System.out.println(list.getSize());
//        System.out.println(list.find(5));
    }
}