【数据结构】——顺序表Java

实现自己的顺序表

import java.util.Arrays;

/**
 * @Author
 * @Description
 */
public class MyArrayList implements IList {

    private int[] elem;
    private int usedSize;

    // 默认的容量
    public static final int DEFAULT_CAPACITY = 5;

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

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

    /**
     * 查找当前元素是否存在
     * @param toFind
     * @return
     */
    @Override
    public boolean contains(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if (toFind == elem[i]) {
                return true;
            }
        }
        return false;
    }

    /**
     * 查找当前元素的下标
     * @param toFind
     * @return
     */
    @Override
    public int indexOf(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if (toFind == elem[i]) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 默认放在尾部
     * @param data
     */
    @Override
    public void add(int data) {
        // 判断是不是满了，满了要扩容
        if (isFull()) {
            elem = Arrays.copyOf(elem,2*elem.length);
        }
        // 放元素
        elem[usedSize] = data;
        usedSize++;
    }

    @Override
    public boolean isFull() {
        return usedSize == elem.length;
    }

    /**
     * 向指定位置添加元素
     * @param pos 位置下标
     * @param data 数据
     */
    @Override
    public void add(int pos, int data) {
        //1. 检测添加位置是否在范围内:
        /* 会有两个问题:
             1、下标小于0
             2、所放的位置不连续：数组一定是连续存储，不能隔开放
         */
        /* 自己写的
        if (!checkPosOfAdd(pos)) {
            throw new RuntimeException("位置错误，所选位置为：" + pos);
        }
        */
        checkPosOfAdd(pos);
        //2. 判断是否满了
        if (isFull()) {
            elem = Arrays.copyOf(elem,2*elem.length);
        }
        //3. 移动元素
        for (int i = usedSize-1; i >= pos; i--) {
            elem[i+1] = elem[i];
        }
        //4.添加元素
        elem[pos] = data;
        usedSize++;
    }

    private void checkPosOfAdd(int pos) {
        if (pos < 0 || pos > usedSize) {
            throw new RuntimeException("位置错误，所选位置为：" + pos);
        }
    }

    /* 自己写的
    private boolean checkPosOfAdd(int pos) {
        if (pos < 0 || pos > usedSize) {
            return false;
        } else {
            return true;
        }
    }
    */

    /**
     * 获取指定位置的元素
     * @param pos 位置下标
     * @return 元素值
     */
    @Override
    public int get(int pos) {
        // 1、判断顺序表是否为空
        if (isEmpty()) {
            throw new EmptyException("顺序表为空！");
        }
        // 2、判断合不合法
        checkPosOfGet(pos);
        return elem[pos];
    }

    public boolean isEmpty() {
        return usedSize == 0;
    }

    private void checkPosOfGet(int pos) {
        if (pos < 0 || pos >= usedSize) {
            throw new RuntimeException("位置错误，所选位置为：" + pos);
        }
    }

    /**
     * 更新pos位置的元素值
     * @param pos
     * @param data
     */
    @Override
    public void set(int pos, int data) {
        if (isEmpty()) {
            throw new EmptyException("顺序表为空");
        }
        checkPosOfGet(pos);
        elem[pos] = data;
    }

    @Override
    public void remove(int toRemove) {
        if (isEmpty()) {
            throw new EmptyException("顺序表为空，不能删除");
        }
        int index = indexOf(toRemove);
        for (int i = index; i < usedSize - 1; i++) {
            elem[i] = elem[i+1];
        }
        usedSize--;
    }

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

    /**
     * 清空顺序表，防止内存泄漏
     */
    @Override
    public void clear() {
        usedSize = 0;
    }
}

研究ArrayList源码

构造方法

第三个构造方法较为特殊，它传入的参数是一个集合

顺序表的遍历

顺序表的遍历有6种方式

// 6种遍历方式
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(10);
        list.add(15);
        list.add(20);
        
        // 1、直接遍历
        System.out.println(list);
        
        // 2、for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        
        // 3、for-each
        for (Integer x : list) {
            System.out.print(x + " ");
        }
        System.out.println();
        
        // 4、迭代器遍历
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
        
        // 5、listIterator迭代遍历，ListIterator是Iterator的子类
        ListIterator<Integer> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.print(listIterator.next() + " ");
        }
        System.out.println();
        
        // 6、反向遍历
        ListIterator<Integer> listIterator1 = list.listIterator();
        while (listIterator.hasPrevious()) {
            System.out.print(listIterator.previous() + " ");
        }

    }

练习

CVTE面试题：
给两个字符串
str1 = “welcome to cvte”
str2 = “come”
删除在str1中存在的str2的字符
要求使用ArrayList
结果应该为：“wl to vt”

解决方案： 遍历str1中的每一个字符，如果str2中不存在该字符，则将这个字符放入顺序表当中

/*
    CVTE面试题：
    给两个字符串
    str1 = "welcome to cvte"
    str2 = "come"
    删除在str1中存在的str2的字符
    结果应该为："wl to vt"
     */
    public static List<Character> func(String str1, String str2) {
        List<Character> list = new ArrayList<>();
        for (int i = 0; i < str1.length(); i++) {
            char ch = str1.charAt(i);
            if (!str2.contains(ch + "")) {
                list.add(ch);
            }
        }
        return list;
    }

    public static void main(String[] args) {
        List<Character> list = func("welcome to cvte", "come");
        System.out.println(list);
        for (char ch: list) {
            System.out.print(ch);
        }
    }

注意事项：这个方法需要的参数是字符串类型，所以不能直接传入字符，解决办法就是拼接一个“空的字符串”