Java--顺序表

Java–顺序表

package pers.xu.ds2.linertable;

/**自定义线性表接口
 * @author a_apple
 * @create 2019-11-13 13:57
 */
public interface List {
    /**
     * 返回线性表大小
     */
    int size();

    /**
     * 返回线性表中序号为i的数据元素
     */
    Object get(int index);

    /**
     * 判断线性表是否有有元素
     */
    boolean isEmpty();

    /**
     * 是否包含元素e
     */
    boolean contains(Object e);

    /**
     * 返回元素e在线性表的位置
     */
    int indexOf(Object e);

    /**
     * 将元素e插入到第i个位置
     */
    void add(int i, Object e);

    /**
     * 将元素e插入到末尾
     */
    void add(Object e);

    /**
     * 将元素e插入到元素Obj之前
     */
    boolean addBefore(Object obj, Object e);

    /**
     * 将元素e插入到元素Obj之后
     */
    boolean addAfter(Object obj, Object e);

    /**
     * 删除坐标为i的元素，并返回
     */
    Object remove(int i);

    /**
     * 删除第一次出现的obj
     */
    Object remove(Object obj);
}

package pers.xu.ds2.linertable;

import pers.xu.ds2.List;

/**顺序表.[简易仿写ArrayList
 * 底层采用数组，但是长度可以动态变化
 * @author a_apple
 * @create 2019-11-13 14:09
 */
public class ArrayList implements List {

    //底层数组
    private Object[] elementData;
    //元素个数
    private int size;

    //初始指定大小
    public ArrayList(int initSize){
        //分配空间
        elementData = new Object[initSize];
        //指定顺序表元素个数
        size = 0;
    }

    //无参
    public ArrayList(){
        this(4);
    }

    @Override
    public int size() {
        return size;
    }

    //数组长度
    public int arrLen(){
        return elementData.length;
    }

    @Override
    public Object get(int index) {
        if(index<0 || index>=size){
            throw new RuntimeException("数组越界异常："+index);
        }
        return elementData[index];
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public boolean contains(Object e) {
        for (Object data : elementData) {
            if(data.equals(e)){
               return true;
            }
        }
        return false;
    }

    //返回某个元素第一次出现的坐标,允许null
    @Override
    public int indexOf(Object e) {
        //非空判断
        if(e == null){
            for (int i = 0; i < size; i++) {
                if(null == elementData[i]){
                    return i;
                }
            }
        }
        for (int i = 0; i < size; i++) {
            if(e.equals(elementData[i])){
                return i;
            }
        }
        return -1;
    }

    /***
     * 将元素e插入到第i个位置
     * 重要：扩容规则
     */
    @Override
    public void add(int i, Object e) {
        //1.有效判断
        if(i<0 || i>size){
            throw new RuntimeException("数组越界异常:"+i);
        }
        //.判断是否需要扩容
        if(elementData.length == size){
            grow();
        }
        //3.先从最后一个元素后移，把i的位置空出来
        for (int j = size; j >i ; j--) {
            elementData[j] = elementData[j-1];
        }
        //4.插入i
        elementData[i] = e;
        //3.size++
        size++;
    }

    /**
     * 在末尾添加元素
     * 动态扩容
     */
    @Override
    public void add(Object e) {
        this.add(size,e);
    }

    private void grow(){
        //新的数组大小   [+的运算优先级大于>>]  半倍增长
        int newLen = elementData.length+(elementData.length>>1);
        Object[] newArr = new Object[newLen];
        //复制oldArr -> newArr
        for (int i = 0; i < elementData.length; i++) {
            newArr[i] = elementData[i];
        }
        //将elementData指向newArr
        elementData = newArr;
        
        //Arrays.copyOf(被扩容数组,新数组长度)=上面的过程，就是一个数组扩容的过程
        //elementData = Arrays.copyOf(elementData, newLen);
    }

    /**
     * 将e添加到obj前面
     */
    @Override
    public boolean addBefore(Object obj, Object e) {
        //先找到那个元素的坐标
        int index = indexOf(obj);
        //使用add(i,e)
        if(index >0){
            add(index,e);
            return true;
        }
        return false;
    }

    /**
     * 将e添加到obj后面
     */
    @Override
    public boolean addAfter(Object obj, Object e) {
        //先找到那个元素的坐标
        int index = indexOf(obj);
        //使用add(i,e)
        if(index >0){
            add(index+1,e);
            return true;
        }
        return false;
    }

    /**
     * 删除坐标为i的元素，并返回
     */
    @Override
    public Object remove(int i) {
        //有效判断
        if(i<0 || i>size || size<=0){
            throw new RuntimeException("数组越界异常:"+i);
        }
        //先把要删的元素保存一下
        Object element = elementData[i];
        //从坐标为i，后面所有元素前移
        for (int j = i; j < size; j++) {
            elementData[j] = elementData[j+1];
        }
        //size--
        size--;
        return element;
    }

    @Override
    public Object remove(Object obj) {
        return null;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < size; i++) {
            if(i != size-1){
                sb.append(elementData[i]).append(",");
            }else {
                sb.append(elementData[i]);
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

测试demo

package pers.xu.ds2.test;

import pers.xu.ds2.linertable.SingleLinkedList;

/**
 * @author a_apple
 * @create 2019-11-13 23:10
 */
public class SingleLLTest {

    public static void main(String[] args) {

        SingleLinkedList list = new SingleLinkedList();
        list.add("a");
        list.add("b");
        list.add(4);
        list.add("h");

        System.out.println(list);

        list.add(1,"c");
        System.out.println(list);
        System.out.println("------------------------");

        Object o = list.get(2);
        System.out.println("坐标为2的元素= "+o);

        System.out.println("isEmpty: "+list.isEmpty());

        System.out.println("------------------------");
        System.out.println(list);
        System.out.println("------------------------");
        System.out.println("contains 'b' ?: "+list.contains("b"));
        System.out.println("contains 'e' ?: "+list.contains("e"));


        System.out.println("------------------------");
        System.out.println(list);
        System.out.println("------------------------");
        System.out.println("indexOf 'h' = "+list.indexOf("h"));
        System.out.println("indexOf 'b' = "+list.indexOf("b"));

        System.out.println("-------------------------");
        //System.out.println("remove 坐标为8的元素 = "+list.remove(8));
        System.out.println("remove 坐标为2的元素 = "+list.remove(2));
        System.out.println(list);
        System.out.println("-------------------------");

        System.out.println("在元素c后面添加'A'");
        boolean b = list.addAfter("c", "A");
        System.out.println(list);
        System.out.println("--------------------------");

        System.out.println("在元素h前面添加'B'");
        boolean d = list.addBefore("h", "B");
        System.out.println(list);
        System.out.println("--------------------------");

        System.out.println("size = "+list.size());
        System.out.println("--------------------------");

        System.out.println("删除元素'A' :"+list.remove("A"));
        System.out.println(list);
        System.out.println("---------------------------");
    }
}

输出结果：

当前长度len=4
当前长度len=9
当前长度len=13
-------------------
[123,234,5,100,23,999,345,13,994,3545] size=10
元素5的位置：2
------------
被删除的元素:23
[123,234,5,100,999,345,13,994,3545] size=9
---------------
向5后面添加一个元素6
[123,234,5,6,100,999,345,13,994,3545] size=10
-----------------
向999前面添加一个10000
[123,234,5,6,100,10000,999,345,13,994,3545] size=11
是否存在999?:true

Process finished with exit code 0