数组、链表v0.0.0

数组，查询快、增删慢

例子：int[] arr = { 2, 33, 78, 5 };

   /***
     * 数据插入指定位置
     * @param arr      被插入的数组
     * @param index   待插入的位置
     * @param value   插入的数据
     */
    private void addValueIndex(int[] arr,int index,int value) {
        int[] brr=new int[5];
        for(int i=0;i<arr.length;i++) {
            brr[i]=arr[i];
        }
        for (int j = 0; j < brr.length; j++) {
            if(j==index) {    //  找到要插入的位置
                for(int i=brr.length-2;i>index-1;i--) {
                    brr[i+1]=brr[i];    //   index+1位置开始到brr.length-1，全部向后移一个位置
                }
                brr[index]=value;  //把插入的值，放在index的位置
            }
        }
        for (int i : brr) {
            System.out.println(i);
        }
    }

   /***
     * 删除数组中指定位置的元素
     * 
     * @param arr 删除指定元素的数组
     * @param i   删除的位置
     * @return
     */
    private void delIndex(int[] arr, int index,int size) {
        // 遍历数组
        for (int j = 0; j < arr.length; j++) {
            if(j==index) { //找到要删除的位置
                for(int i=index;i<arr.length-1;i++) {
                    arr[i]=arr[i+1];
                }
                size--;
            }
        }
        //删除数据后的数组
        for (int i=0;i<size;i++) {
            System.out.println(arr[i]);
        }
    }

链表：增删快，查询慢

           链表{单向链表[可以实现栈]、双端链表[可以实现队列]、双向链表}

我的参考：https://www.cnblogs.com/ysocean/p/7928988.html

v0.0.1单向链表

public class SingleLinkedListMy {
    private int size;//链表的节点个数
    private Node head;//头结点
    
    public SingleLinkedListMy(){
        size=0;
        head=null;
    }
    
    private class Node{
        private Object data;//每个节点的数据
        private Node next;//每个节点指向下一个节点的连接
        
        public Node(Object data) {
            this.data=data;
        }
    }
    /***
     * 在head后添加节点
     * @param data
     */
    public void add(Object data) {
        Node temp=head;
        if(size==0) {
            head=new Node(data);
        }else {
            while(temp.next!=null) {
                temp=temp.next;
            }
            temp.next=new Node(data);
        }
        size++;
    }
    /***
     * 
     * @param index
     * @return
     */
    public Node delIndex(int index) {
        int count=0;
        Node newNode=head;
        
        while(newNode.next!=null) {
            if(count==index) {
                newNode=newNode.next;
            }
            newNode=newNode.next;
            count++;
        }
        return null;
    }
    public Object delHead() {
        Object data = head.data;
        head=head.next;
        size--;
        return data;
    }
    public Node get(int index) {
        int count=-1;
        Node newNode=head;
        
        while(newNode.next!=null) {
            if(count==index) {
                return newNode;
            }
            newNode=newNode.next;
            count++;
        }
        return null;
    }
    //查找
    public Node find(Object data) {
        Node current=head;
        int tempSize=size;
        while(tempSize>0) {
            if(data.equals(current.data)) {
                return current;
            }else {
                current=current.next;
            }
            tempSize--;
        }
        return null;
    }
}