数据结构之数组和红黑树

数组：

1、创建完成后数组大小确定，不可改变：数据的增删改查不改变内存大小

2、数组中要存储相同类型的数据（大了承载不下，小了无法截取）

3、数组可以通过下标来获取单个数据，下标从0开始

4、数组的内存连续

数组查找，为了减少时间复杂度，首先考虑的是折半查找，折半查找虽然时间复杂度能降到O(logn)，但是只能针对有序数组，现实情况很多时候数组是无序的。这时候优先想到的就是哈希算法，进行存储，但是在存储过程中会存在哈希碰撞，指的是多个值要存储在同一个位置，解决这个问题的办法就是通过拉链法，然而拉链法的时间复杂度也可能会很高；之后又想到通过有序二叉树（左子树

红黑树的特点：

1、根节点永远都是黑色

2、红色节点的子节点一定是黑节点

3、从根节点到任意叶子节点上黑色节点数目是相同的

4、最长路径：黑+红+黑+红+黑+红

5、最短路径：黑+黑+黑

6、红黑树里没有一条路径比其它路径长超过两倍

7、其时间复杂度稳定在O(logn)

import java.util.*;

//数组，长度不可变
int[] arr = new int[]{20,1,12};

//数组列表ArrayList，java封装的数组
ArrayList<Integer> list = new ArrayList<Integer>;
//数组元素添加
list.add();

public class Arraylist {
    int capacity;  //容量
    int[] arr;
    int size;
    double factor;   //因数
    public Arraylist(){
        size=0;
        factor=1.5;
        capacity=10;
        arr = new int[capacity];
    }

    public void add(int element){
        if(size>=arr.length){
            //满了扩容
            int[] temp = new int[capacity];
            for(int i=0; i<arr.length; i++){
                temp[i] = arr[i];
            }
            arr=temp;
        }
        //插入
        arr[size] = element;
        size++;
    }

    @Override
    public String toString(){
        String str = "[";
        for(int i=0; i<size; i++){
            str += arr[i]+" ";
        }
        str += "]";
        return str;
    }
    
    /**
     * 任意位置插入
     * @param value 要插入的值
     * @param index 要插入的位置
     */
    public void insert(int value, int index){
        if(index<0 || index>size){
            System.out.println("插入位置不合理");
            return;
        }

        if(size==arr.length){
            //扩容
            int[] temp = new int[capacity];
            for(int i=0; i<arr.length; i++){
                temp[i] = arr[i];
            }
            arr=temp;
        }
        //插入位置以及之后的数据向后移动
        for(int i=size-1; i>=index; i--){
            arr[i+1] = arr[i];
        }
        //数据插入
        arr[index] = value;
        size++;
    } 
    
    /**
     * 删除第一个符合条件的数据
     * @param value
     * return
     */
    public boolean delFirst(int value){
        boolean isFound=false;
        for(int j=size-1; j>=0; j--){//从头往前删除会导致漏删
            if(arr[j]==value){
                //删除
                for(int i=j; i<size; i++){
                    arr[i] = arr[i+1];
                }
                size--;
                isFound=true;
                break;//去掉break则是删除所有符合条件的数据
            }
           }
        return isFound;
    }   
    /**
     * 有序数组的插入
     * @param value
     */
    public void orderInsert(int value){
        if(size==arr.length){
            //扩容
               capacity *= factor;
            int[] temp = new int[capacity];
            for(int i=0; i<arr.length; i++){
                temp[i] = arr[i];
            }
            arr=temp;
        }

    //插入
        if(size==0){
            arr[0] = value;
        }else if(arr[size-1]<value){
            arr[size] = value;
        }else{
            for(int i=0; i<size; i++){
                if(value<arr[i]){
                    //插入位置以及之后的数据往后移动
                    for(int temp=size-1; temp>=i; temp--){
                        arr[temp+1]=arr[temp];
                    }
                    arr[i]=value;
                    break;
                }
            }
        }
        size++;
    }    
}

使用双指针删除

class Solution {
    public int removeElement(int[] nums, int val) {
        int slow=0;
        for(int fast=0; fast<nums.length; fast++){
            if(nums[fast]!=val){
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
}