数据结构

Posted 2020-11-29 zengqinghong

import java.util.Arrays;

// 案例：NBA球员上场5(主力)+3(替补)。安排一个上场球员的存储
public class FootBallPlayerDemo {
    // 存储场上球员的球员号码
    private static Integer[] elements;
    // 表示场上有几个球员
    private static int size = 0;

    // 1):设置初始量(可以存储多少个球员.)
    static void init(int capacity) {
        if (capacity < 0) {
            throw new RuntimeException("初始量不能小于0");
        }
        elements = new Integer[capacity];
    }

    // 2):安排五个球员上场(11,22,33,44,55).
    static void add(Integer playerNum) {
        //判断当前size和capacity大小关系
        if (size>=elements.length) {
            // 扩容：原始初始容量*2
            int newCapacity = elements.length * 2;
            // Integer[] newElements = new Integer[newCapacity];
            // 把原始数组中的数据拷贝到新数组中，返回的是新数组
            Integer[] newElements = Arrays.copyOf(elements,newCapacity);
            elements = newElements;
        }
        //===========================
        elements[size] = playerNum;
        size++;
    }

    // 3):查询指定球员所在的位置(比如,44球员的位置就是3.).
    static int getIndexByPlayerNum(Integer playerNum) {
        for (int i = 0; i < size; i++) {
            if (playerNum.equals(elements[i])) {
                return i;
            }
        }
        throw new RuntimeException("没有该编号的球员");
    }

    // 4):查询指定位置是哪一个球员(比如,位置为2的球员是33.).
    static Integer get(int index) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界！！！");
        }
        return elements[index];
    }

    // 5):从上场球员中,移除指定球衣号的一个球员.
    static void remove(Integer playerNum) {
        // 找到当前被移除球员所在的位置
        int index = getIndexByPlayerNum(playerNum);
        // 把index之后的元素,整体向前移动一位
        for (int i = index; i < size - 1; i++) {
            elements[i] = elements[i + 1];
        }
        elements[size - 1] = null;
        size--;
    }

    // 6):把指定位置的球员换成另一个球员.
    static void set(int index, Integer newPlatNum) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界！！！");
        }
        elements[index] = newPlatNum;
    }

    // 7):打印出场上的球衣号码(比如:[11,22,33,44,55]).
    static void print() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(elements[i]);
            if (i != size - 1) {
                sb.append(",");
            }
        }
        sb.append("]");
        System.out.println(sb);
    }

    public static void main(String[] args) {
        // 设置场上的球员初始量为6
        init(11);
        // 安排5个球员上场
        add(11);
        add(22);
        add(33);
        add(44);
        add(55);
        add(66);
        // 打印场上球员
        print();
        // 查询33号球员的位置
        System.out.println(getIndexByPlayerNum(33));
        // 位置为2的球员是？
        System.out.println(get(2));
        print();
        // 把4位置的球员换成77号
        set(4,77);
        print();
        // 把33号球员罚下场，不能替换
        // 罚下之前：[11,22,33,44,77]
        remove(33);
        // 罚下之后：[11,22,44,77]
        print();
    }
}

BasketBall

public class BasketBallDemo {
    public static void main(String[] args) {
        //创建一个列表对象
        MyArrayList list = new MyArrayList(5);
        list.add(11);
        list.add(22);
        list.add(33);
        list.add(44);
        list.add(55);
        list.add("55");
        list.add(true);
        System.out.println(list);
        System.out.println("------------------");
        System.out.println(list.size());
        System.out.println(list.isEmpty());
        list.clear(); // 清空
        System.out.println(list);
    }
}

ArrayList

import java.util.Arrays;

// 数组的列表
public class MyArrayList {
    // 存储场上球员的球员号码
    private static Object[] elements;
    // 表示场上有几个球员
    private static int size = 0;

    public MyArrayList(){
        this(10);
    }

    // 1):设置初始量(可以存储多少个球员.)
    public MyArrayList(int capacity) {
        if (capacity < 0) {
            throw new RuntimeException("初始量不能小于0");
        }
        elements = new Object[capacity];
    }

    // 2):安排五个球员上场(11,22,33,44,55).
    public void add(Object ele) {
        //判断当前size和capacity大小关系
        if (size >= elements.length) {
            // 扩容：原始初始容量*2
            int newCapacity = elements.length * 2;
            //Integer[] newElements = new Integer[newCapacity];
            //把原始数组中的数据拷贝到新数组中，返回的是新数组
            Object[] newElements = Arrays.copyOf(elements, newCapacity);
            elements = newElements;
        }
        //===========================
        elements[size] = ele;
        size++;
    }

    // 4):查询指定位置是哪一个球员(比如,位置为2的球员是33.).
    public Object get(int index) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界！！！");
        }
        return elements[index];
    }

    // 5):从上场球员中,移除指定球衣号的一个球员.
    public void remove(Integer index) {
        // 找到当前被移除球员所在的位置
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界！！！");
        }
        // 把index之后的元素,整体向前移动一位
        for (int i = index; i < size - 1; i++) {
            elements[i] = elements[i + 1];
        }
        elements[size - 1] = null;
        size--;
    }

    // 6):把指定位置的球员换成另一个球员.
    public void set(int index, Object ele) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界！！！");
        }
        elements[index] = ele;
    }

    // 7):打印出场上的球衣号码(比如:[11,22,33,44,55]).
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(elements[i]);
            if (i != size - 1) {
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
    //返回存储了几个元素
    public int size() {
        return size;
    }
    //判断该对象是否存储了元素
    public boolean isEmpty() {
        return size == 0;
    }
    //清空所有的元素
    public void clear() {
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size=0;
    }
}

Stack

// 栈
public class MyStack extends MyArrayList {
    // 规定：数组的最后一个位置就是栈顶

    // 进栈：把新添加的数据压入到栈顶
    public void push(Object ele){
        super.add(ele);
    }
    // 出栈：移除栈顶元素
    public void pop(){
        remove(this.size()-1);
    }

    // 获取栈顶的元素
    public Object peek() {
        return get(this.size()-1);
    }
}