数据结构和算法

算法(Algorithm):
就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。
简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

相关java知识
1. 泛型 Generic 
2. 自动装箱 autobox 和自动拆箱 autounbox 
3. Object 的 equals 方法
4. Comparable 和 Comparator 接口

1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

最坏情况：任意输入规模的最大运行次数(上界)
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

要观察代码的思路而不只是代码，有些循环达到某个条件就会跳出去所以主要是看思路

 例子：

// 计算func2的时间复杂度？ 
void func2(int N) { 
int count = 0; 
for (int k = 0; k < 2 * N ; k++) {
count++; 
}
int M = 10; 
while ((M--) > 0) {
count++; 
}
System.out.println(count); 
}

O（N）

void func3(int N, int M) { 
int count = 0; 
for (int k = 0; k < M; k++) {
count++; 
}for (int k = 0; k < N ; k++) {
count++; }
System.out.println(count); 
}

O（N+M)

void func4(int N) { 
int count = 0; 
for (int k = 0; k < 100; k++) {
count++; }
System.out.println(count); 
}

O（1）

递归的时间复杂度 

递归次数当前的不算，第二次进入才算。

每次递归执行次数主要取决于递归程序有没有循环代码 

主要看创建（不是必须的变量）有多少

void bubbleSort(int[] array) { 
for (int end = array.length; end > 0; end--) {
boolean sorted = true; 
for (int i = 1; i < end; i++) { 
if (array[i - 1] > array[i]) { 
Swap(array, i - 1, i); 
sorted = false; 
}

常数个不是必须的变量直接O（1）

int[] fibonacci(int n) {
 
long[] fibArray = new long[n + 1]; //创建了N+1个非必须变量

fibArray[0] = 0; 
fibArray[1] = 1; 
for (int i = 2; i <= n ; i++) { 
fibArray[i] = fibArray[i - 1] + fibArray [i - 2]; 
}return fibArray; 
}

O（N）

递归的空间复杂度和时间复杂度一样

long factorial(int N) { 
return N < 2 ? N : factorial(N-1)*N; }

递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)

引用数据类型有：类、接口、数组、包装类

 泛型就是传参，参数可以是类型，不是一个确定的值。传类型的作用只是动态进行了强制类型转换并不是把T换成传参类型。

ublic class SimpleGeneric {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    public static void main(String[] args) {
        SimpleGeneric gs = new SimpleGeneric<>();
        gs.setT("hello");
        String string = gs.getT();
    }
}

 擦除后

public class SimpleGeneric {
    private Object t;

    public Object getT() {
        return t;
    }

    public void setT(Object t) {
        this.t = t;
    }

    public static void main(String[] args) {
        SimpleGeneric gs = new SimpleGeneric();
        gs.setT("hello");
        String string = (String)gs.getT();
    }
}

比对了一下编译前后的代码我们会发现其中所有T的部分都会被置换为了Obejct。
同时，由于我们传入的类型参数是String，所以在取值时，编译器为我们动态添加了(String)的强制转换

不管怎么样擦除后泛型T换成Object与传参类型无关

由于类型出现了参数，因此我们会发现，
在泛型类中，我们只能通过T来调用一些Object拥有的方法，
我们无法通过泛型类型去获取任何有关类型参数的信息。
我们在使用泛型时完全可以将泛型类中的泛型参数当作Object使用

class FruitContainer{
    private T t;

    public void setFruit(T t){
        this.t = t;
        t.f();
    }

    public T getFruit(){
        return t;
    }
}

 擦除后

class FruitContainer{
    private Fruit t;

    public void setFruit(Fruit t){
        this.t = t;
        t.f();
    }

    public Fruit getFruit(){
        return t;
    }
}

通过上面的编译前后的对比，我们可以这么认为，擦除就会将类型参数在编译时擦除为对应的边界

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，
也可以根据成员方法返回数组中某个下标的值

class MyArray {
public Object[] array = new Object[10];

public Object getPos(int pos) { 
return this.array[pos]; 
}
public void setVal(int pos,int val) { 
this.array[pos] = val; 
} 
}

public class TestDemo {
public static void main(String[] args) { 
MyArray myArray = new MyArray();
myArray.setVal(0,10);
myArray.setVal(1,"hello");//字符串也可以存放 String ret = myArray.getPos(1);//编译报错 System.out.println(ret); 
} 
}

任何类型数据都可以存放
1号下标本身就是字符串，但是确编译报错。必须进行强制类型转换

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，
我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。
所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。
让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

泛型类<类型实参> 变量名; // 定义一个泛型类引用 
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

在写泛型数组时尽量用这个方法 

可能会造出编译错误，所以尽量使用上面这个方法

class MyArray {
    public T[] array = (T[]) new Object[10];
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos, T val) {
        this.array[pos] = val;
    }
    public T[] getArray() {
        return array;
    }
}
public class Main {
    public static void main(String[] args) {
        MyArray myArray1 = new MyArray<>();
        Integer[] strings = myArray1.getArray();//错误 不安全
    }
}


数组和泛型之间的一个重要区别是它们如何强制执行类型检查。
具体来说，数组在运行时存储和检查类型信息。然而，泛型在编译时检查类型错误。
通俗讲就是：返回的Object数组里面，可能存放的是任何的数据类型，
可能是String，可能是Person，运行的时候，直接转给Intefer类型的数组，编译器认为是不安全的

继承了Object类E就可以调用Object方法，继承了这个接口就能实现这个接口 

我们发现在FruitContainer类中声明了，这表示我们传入的参数类型必须继承自Fruit或者Fruit本身，
也就是说，FruitContainer中不关持有的是什么类型，它都必然是Fruit的子类或者Fruit本身，
因此，这个类也必然可以安全的向上转型为Fruit，也就是说，我们完全可以通过T来调用属于Fruit的方法

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

class 泛型类名称<类型形参 extends 类型边界> {
...
}

MyArray l1; 
// 正常，因为 Integer 是 Number 的子类型 MyArray l2; 
// 编译错误，因为 String 不是 Number 的子类型

<>里面的只是虚拟的，泛型编译时用来检查数组内部是不是<>里面的类型

实际上T都换成泛型的上界 

接口如果有 或抽象方法有T时，就把T换成你要使用的类，因为类也是引用数据类型可以存放在<>里面。

 

 

 

---

 

通配符

通配符可以接收任何<>里面的类型数据 

通配符默认继承object

 

通用符的上界 

 

通用符的下界 

引用类型的==

如果数值在[-128, 127]之间，就会从缓冲池中取出对象。
毫无以为，对于对象而言，==其实比较的是地址值。
由于num1~num4都在[-128, 127]范围内，所以从缓存中取，只要值相同，对象就相同，所以两者相等。
而当数值超出[-128, 127]之外，就会new Integer(i)，此时就会分别new一个对象，自然地址值不同。