210116数据结构与算法_rush 算法-CSDN博客

本文链接：https://blog.csdn.net/imrush2019/article/details/112717612

1.数据结构与算法包括
1.2.算法分析
1.3.排序
1.4.线性表
1.5.符号表
1.6.树
1.7.堆
1.8.优先队列
1.9.并查集
1.10.图

什么是数据结构？
数据结构就是把数据元素按照一定的关系组织起来的集合，用来组织和存储数据

数据结构分成哪几类呢？
数据结构分为逻辑结构和物理结构两大类

逻辑结构
a.集合结构：除了在一个集合里，没别的关系了
b.线性结构：一对一的关系
c.树形结构：树形结构存在一对多的层次关系
d.图形结构：图形结构的数据元素是多对多的关系

物理结构
物理结构就是逻辑结构在计算机中真正的表示方式，包括了，顺序存储结构和链式存储结构。

顺序存储结构：
到底什么是顺序？地址连续的存储单元就是顺序，此时逻辑关系和物理关系是一致的。例如：数组[1,2,3,4,5,6,7,8,9,10]
这种存储方式有什么弊端呢？
生活中排时也会有人插队也可能有人有特殊情况突然离开，也就是元素突然发生变化，这时候整个结构都变了，所以引入链式存储结构。

链式存储结构：
元素任意的放置在不同的存储单元中，地址可以连续可以不连续，竟然都随便放了，就不存在逻辑关系了。那我们怎么去找这个元素呢？引入一个叫做指针的东西，用来存放数据元素的地址，通过指针就知道地址，知道地址就知道元素了。

什么是算法呢？
一系列指令，就是一条条代码组成的指令集。能够对一定规范的输入，在有限的时间内得到所要求的输出
难道设计的每一条算法都是好的么？未必！这也是研究算法的目的，如何花费更少的时间，占用更少的内存去完成相关的需求。也就是时间和空间的复杂度。

怎么去度量呢？
考虑核心代码的执行次数，这个东西比较玄乎，那么到底什么是核心代码呢？求和就看sum。知道了核心代码了之后，如何去分析一个算法的运行时间呢：
把核心操作次数和输入规模关联起来即可
下图的横坐标就是输入规模，纵坐标就是复杂度
一次循环就是一个n，循环的嵌套就是n^2
在这里插入图片描述

算法时间复杂度的表示方法？
大O计法。只标记最高阶数，比如，n^2+1 ,记为n ^2 就可以了。
那么有哪些大O阶呢？
线性阶 n
平方阶 n^2 比如嵌套循环
立方阶 n^3 三个嵌套循环
对数阶 logn 对数表示的时候底数去掉
复杂度排序：1 < logn < n < nlogn< n^2<n3
所有的时间复杂度按最坏的情况进行计算

时间复杂度说完了，空间复杂度怎么算呢？
常见的内存占用
基本类型
byte = boolean 1字节 1字节 = 8位
char = short = 2
int = float = 4
long = double = 8
计算机访问内存的时候都是1个字节1个字节访问的
引用类型
一个引用也是8个字节
Data date = new Date() new 出来的这个对象是8个字节

排序算法
1.简单排序
套路，把数据结构和算法封装到一个类中。排序的场景一般都是对对象进行排序，所以对象对应的类中就应该有排序规则。
案例：
为了理解Comparable接口的使用：
定义一个学生类，有姓名和年龄两个属性，把年龄较大的那个给找出来。

1.定义一个学生类

public class Student implements Comparable<Student>{
private String username;
private int age;
public String getUsername(){
	return username;
}
public void setUsername(){
	this.username = username;
}
public int getAge(){
	return age;
}
public void setAge(){
	this.age = age;
}

public String toString() {
return "Student{" +
"username='" + username + '\'' +
", age=" + age +
'}';
}
//定义比较规则：重写了Comparable中的compareTo方法
	public int compareTo(Student o){
	return this.getAge() - o,getAge();
}

2.定义测试类

package algorithm.day01.test;

import algorithm.day01.sort.Student;

public class TestComparable {

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setUsername("张三");
        s1.setAge(18);

        Student s2 = new Student();
        s2.setUsername("李四");
        s2.setAge(15);

        Comparable max = getMax(s1,s2);
        System.out.println(max);

    }

    public static Comparable getMax(Comparable c1, Comparable c2) {
//        Comparable里面都有compareTo()
        int result = c1.compareTo(c2);
        if (result >= 0) {
            return c1;
        } else {
            return c2;
        }
    }

}

3.返回值

Student{username='张三', age=18}

2.冒泡排序
多少个元素就冒几次泡，比较相邻的元素的大小
怎么实现呢?首先定义三个方法
1.可是先要比较大小，定义一个greater方法

    private static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }

2.交换数组元素，只要听到交换，立马想到临时变量

private static void exch(Comparable[] a, int i, int j) {
        /*只要是数组的交换，立马创建临时变量*/
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

3.排序的主程序

public static void sort(Comparable[] a) {
        /*每次冒泡会少一个元素*/
        /*for循环控制多少个元素参与冒泡*/
        /*嵌套循环 算法复杂度n^2*/
        for (int i = a.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                //内部需要比较索引j和索引j+1处的值
                if (greater(a[j], a[j + 1])) {
                    exch(a, j, j + 1);
                }
            }
        }

4.定义测试类

package algorithm.day01.test;

import algorithm.day01.sort.Bubble;

import java.util.Arrays;

public class BubbleTest {
    public static void main(String[] args) {
        Integer[] arr = {4, 5, 6, 3, 2, 1};
        Bubble.sort(arr);
        System.out.println(Arrays.toString(arr));

    }

}