java设置表influx表的保存时间

数据表结构与算法（java版）持续更新中

• 一、概述

• 1.数据结构概述
• 2.算法概述

• 二、动态数组

• 1.动态数组与静态数组

• 三.线性表的实现

• 1.线性表：
• 2.List接口的定义：
• 3.ArrayList方法的实现：

• 四、栈的实现

• 1.栈：
• 2.Stack接口的定义:
• 3.ArrayStack方法的实现：
• 4.栈的应用——中缀计算器：

一、概述

1.数据结构概述

数据结构主要学习的是：

1. 数据们之间的关系，将离散的数据规整划一
2. 如何将这个关系具体实现并存储到计算机中
3. 基于关系之上对数据的具体操作，增删查改等
4. 数据结构的具体使用场景

逻辑结构： 是指数据元素之间的相互关系，是我们想象出来的，并没有实质性的将其存储在计算机中。

1. 线性结构：线性结构中的数据元素之间是一对一的关系。
2. 树形结构：树形结构中的数据元素之间存在一种一对多的层次关系。
3. 图形结构：图形结构的数据元素是多对多的关系。

物理结构： 是指数据的逻辑结构在计算机中的具体存储形式。

顺序存储结构：开辟一组连续的空间存储数据。

通常用数组来实现，数组中空间本身是连续的，保证了数据之间的关系。

链式存储结构：开辟一组随机的空间存储数据。
通常用节点来实现，节点不仅要存储数据还要存储下一个节点的位置以保证数据之间的关系。

线性结构的物理存储方式：

1. 线性结构的顺序存储方式：

2. 线性结构的链式存储方式：

树形结构的物理存储方式

2. 树形结构的顺序存储结构：



3. leftChild = 2* parent + 1
   rightChild = 2* parent + 2
   parent = (child – 1) / 2
4. 树形结构的链式存储结构：
   图形结构的物理存储方式：

1. 图形结构的顺序存储结构：邻接矩阵
2. 图形结构的链式存储结构：邻接表

2.算法概述

什么是算法？

1. 是解决特定问题求解步骤的描述
2. 分析问题，一步一步求解，并得到结果
3. 这一系列的步骤就称之为算法
4. 同一个问题，可以有多种不同的解决方案，也就是说可以用不同的算法去解决同一个问题

算法的描述方式：

1. 自然语言描述
2. 流程图描述
3. 伪代码描述
4. 程序代码描述

评价算法好坏的方法：

设计算法要提高程序运行的效率，这里效率大都指算法的执行时间
如何去度量一个算法的执行时间呢？

1. 事后统计法：
   这种方法主要是通过设计好的程序和数据，利用计算机计时器对不同算法程序的运行时间进行比较，从而确定算法效率的高低。
   弊端：

1. 必须事先编好程序，再进行运行，如果程序处理的数据量较大，则会花费大量的时间和精力
2. 时间的比较主要依赖于计算机硬件和软件环境
3. 算法的测试数据设计困难，在数据量较小的时候，不管什么算法其运行时间都是很微小的，相差几乎为零。如果数据量大了，算法的优越性就出来了，但是这样又会耗费时间。

2. 事前分析法：
   这种方法主要在计算机程序编制前，依据统计方法对算法进行估算。
   一个高级程序语言编写的程序在计算机上运行时所消耗的时间取决于下列因素：

1. 算法采用的策略、方法
2. 编译产生的代码质量
3. 问题的输入规模
4. 机器执行指令的速度
   第1条当然是算法好坏的根本
   第2条取决于具体的编程语言
   第4条取决于硬件性能

一个程序的运行时间依赖于算法的好坏和问题的输入规模。所谓问题输入规模是指输数据入量的多少。

例如：1到100求和的问题

算法时间复杂度

在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T(n)=O(f(n))。它表示随着问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐进时间复杂度。简称时间复杂度。其中f(n)是问题规模n的某个函数。

算法时间复杂度主要探究的是问题输入规模N的数量级，不是算法的具体执行次数

1. 常数阶O(1)： 就是那些无循环、无递归、与问题输入规模N无关的、逐行执行的代码。
2. 线性阶O(n)： 与问题输入规模有关的，主要是一层循环的代码，多个一层循环可以并列但不能包含。
3. 线性阶O(n+m)： 和线性阶O(n)一样，只不过我们有两种数据的输入规模
4. 平方阶O(n2)： 与问题输入规模有关的，主要是二层嵌套循环的代码。
5. 平方阶O(nm)： 和平方阶O(n2)一样，只不过我们有两种数据输入规模
6. 对数阶O(logn)： 与问题输入规模有关的，主要是一层循环迭代或递归的代码。

常见阶比较：

时间复杂度简单计算：忽略常数、只保留幂高项、且忽略幂高项的系数。

二、动态数组

1.动态数组与静态数组

线性结构 + 顺序存储 = ？

1. 线性表
2. 栈
3. 双端栈
4. 队列
5. 循环队列
6. 双端队列

静态数组与动态数组

Java内置数组的特点：

1. 数组的长度一旦确定则不可更改
2. 数组只能存储同一类型的数据
3. 数组中每个存储空间地址是连续且相等的
4. 数组提供角标的方式访问元素

Java内置数组的缺点：

1. 长度不可变，容量不够用怎么办
2. 地址连续且提供角标访问很快，但增删元素怎么办
3. 数组只有length这个属性，没有其他的方法

而动态数组正是为了解决静态数组的缺点而存在，动态数组就是顺序存储结构具体实现的核心思想。当容量不够时，可进行扩容，在增删元素时，由于线性结构需要保证元素的连续性，可利用元素后移或元素前移来进行。由于静态数组只有length属性，可以利用面向对象的思想再次封装，从而有其他属性。
（size即表示数据的有效个数，也表示新元素将要进入的位置（在表尾添加数据））

三.线性表的实现

1.线性表：

**线性表的定义：**零个或多个元素的有限序列
a_i−1 是 a_i 的直接前驱
a_i+1 是 a_i 的直接后继
除了第1个元素a_1 之外，其他元素都有唯一的直接前驱
除了第n个元素a_n 之外，其他元素都有唯一的直接后继
n表示线性表的长度，当n=0时，称为空表

2.List接口的定义：

List接口：线性结构可以由顺序存储结构和链式存储结构实现，那么将两者对线性结构共同的操作进行抽取，定义出线性结构的接口。

package p1.接口;

import java.util.Comparator;

public interface List<E> extends Iterable<E>{//迭代接口
        public void add(E element);//默认在表尾添加一个元素
        public void add(int index,E element);//在指定角标处添加元素
        public void remove(E element);//删除指定元素
        public E remove(int index);//删除角标处元素，并返回原先值
        public E get(int index);//获取角标处的元素;
        public E set(int index,E element);//修改指定角标index处的值为element 并返回原先的值
        public int size();//获取线性表中的元素个数
        public int indexOf(E element);//查看元素第一次出现的角标位置（从左到右
        public boolean contains(E element);//判断是否包含元素
        public boolean isEmpty();//判断线性表是否为空
        public void clear();//清空线性表
        public void sort(Comparator<E> c);//按照比较器的内容进行排序
        public List<E> subList(int fromIndex,int toIndex);//获取子线性表，原线性表中[fromIndex,toIndex)这个部分
}

3.ArrayList方法的实现：

ArrayList就是线性结构顺序存储方式的具体实现，称为线性表。创建ArrayList类实现List接口，定义相关成员属性和构造函数。

package p2.线性结构;

import p1.接口.List;

import java.util.Comparator;
import java.util.Iterator;

public class ArrayList<E> implements List<E> {
    //定义数组的容器 data.length指当前数组容量
    private E[] data;
    //元素的个数 size==0 线性表为空 size=data.length线性表满了
    //size 新元素默认尾部添加时要去的角标
    private int size;
    //默认容量
    private static int DEFAULT_CAPACITY = 10;
    //默认构造函数：创建一个默认容量为10的线性表
    public ArrayList(){
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }
    //指定默认容量的构造函数：创建一个指定容量的线性表
    public ArrayList(int capacity){
        if(capacity <= 0){
           throw new IllegalArgumentException("capacity must > 0");//java自带参数异常
        }
        DEFAULT_CAPACITY = capacity;
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }
    //指定数组的构造函数：传入一个数组，将该数组封装成一个线性表
    public ArrayList(E[] arr){
        if(arr == null||arr.length==0){
            throw new IllegalArgumentException("arr can not be null");
        }
        data = (E[]) new Object[DEFAULT_CAPACITY];
        for(int i = 0;i < arr.length;i++){
            add(arr[i]);
        }
    }
    @Override
    public void add(E element) {
        add(size,element);
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add index out of range");
        }
        if(size == data.length){//扩容：数组满了
            resize(2* data.length);
        }
        //将元素从最后一个开始向后移动一位
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = element;
        size++;
    }
//扩容/缩容操作 不应该提供给外界
    private void resize(int newLen) {
        E[] newData = (E[]) new Object[newLen];
        for(int i = 0; i < size; i++){
            newData[i] = data[i];
        }
         data = newData;
    }

    @Override
    public void remove(E element) {//删除指定元素 只删除一次 && 删除所有指令元素
        int index = indexOf(element);
        if(index != -1){
            remove(index);
        }
    }


    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove index out of range");
        }
        //先保存要删除的值
        E ret = data[index];

        //移动元素
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;

        //什么时候缩容
        //1.有效元素是容量的1/4
        //2.当前容量不得小于等于默认容量
        if (size == data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize(data.length / 2);
        }
        return ret;
    }


    @Override
    public E get(int index) {
        if(index < 0||index >= size){
            throw new IllegalArgumentException("get index out of range");
        }
        return data[index];
    }

    @Override
    public E set(int index, E element) {
        if(index < 0||index >= size){
            throw new IllegalArgumentException("set index out of range");
        }
        E ret = data[index];
        data[index] = element;
        return ret;
    }

    @Override
    public int size() {
        return size;
    }
    //额外添加一个函数 获取那个线性表的容量
    public int getCapacity(){
        return data.length;
    }

    @Override
    public int indexOf(E element) {
        for (int i = 0;i < size;i++){
            if(data[i].equals(element)){
                //==两边是基本数据类型比的是值(byte short int long float double char boolean)
                // 两边是引用型变量比的是地址；(数组 字符串 其他的类对象)
                // equals比较值
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void clear() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if(c ==null){
            throw new IllegalArgumentException("comparator can not be null");//传入的比较器定义比较的规则
        }
        int j;
        int i;
        for( i = 1;i < size;i++){
            E e = data[i];
            for(j = i;j > 0 && c.compare(data[j-1],e)>0;j--){//无法确定类型故比较时必须要用户传入的比较器
                data[j] = data[j-1];
            }
            data[j] = e;
        }
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {//左闭合右闭合
        if(fromIndex < 0||toIndex >= size||fromIndex>= toIndex){
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex");
        }
        ArrayList<E> list = new ArrayList<>();
        for(int i = fromIndex;i <= toIndex;i++){
            list.add(data[i]);
        }
        return list;
    }
    @Override
    public boolean equals(Object o){
        //1、判空
        if(o == null){
            return false;
        }
        //2、判自己
        if(this == o){
            return true;
        }
        //3、判类型
        if(o instanceof ArrayList){
           // 4、按照自己的逻辑进行比较
            ArrayList<E> other = (ArrayList<E>) o;
            //5、先比较有效元素个数
            if(size != other.size){
                return false;
            }
            //6、有效元素相等的情况下 逐个比较元素
            for (int i = 0;i < size;i++){
                if(!data[i].equals(other.data[i])){
                    return false;
                }
            }
            return true;
        }
        return false;
    }
    /*
[1, 2, 3, 4, 5, 6]
[]
Arrays.toString(arr);
*/
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if(isEmpty()){
            sb.append(']');
        }else{
            for (int i = 0;i < size;i++){
                sb.append(data[i]);
                if(i == size - 1){
                    sb.append(']');
                }else {
                    sb.append(',');
                    sb.append(' ');
                }
            }
        }
        return  sb.toString();
    }
    //通过迭代器对象 更方便挨个取出每一个元素
    //同时 实现了Iterable 可以让当前的数据结构/容器 被foreach循环遍历
    //获取当前这个数据结构/容器的迭代器
    @Override
    public Iterator<E> iterator() {
        return new ArrayListIterator();
    }
    //创建一个属于ArrayList的迭代器
    class ArrayListIterator implements Iterator<E>{
        private int cur = 0;

        @Override
        public boolean hasNext() {//判断是否有下一个元素
            return cur < size;
        }

        @Override
        public E next() {//如果有下一个元素 则把当前元素返回 并移至下一个元素
            return data[cur++];
        }
    }
}

ArrayList(E[] arr)的问题：

data不能直接引用外部传入的数组arr（即不能表示为data = arr，否则，data会指向arr的地址，外部对arr的修改会引起ArrayList内部改变的一些问题）

四、栈的实现

1.栈：

栈的定义： 栈是限定仅在表尾进行插入和删除操作的线性表
我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom）
不含任何数据元素的栈称为空栈
栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构
栈本身是一个线性表，其数据元素具有线性关系，只不过它是一种特殊的线性表而已
栈的插入操作，叫作进栈，也称压栈、入栈
栈的删除操作，叫作出栈，也称弹栈

2.Stack接口的定义:

同样栈可以顺序存储实现也可以链表存储实现，所以将共性抽取定义出Stack接口

package p1.接口;

public interface Stack<E> extends Iterable<E> {
    public int size();
    public boolean isEmpty();
    //入栈 进栈一个元素 在线性表的表尾添加一个元素
    public void push(E element);
    //弹出
    public E pop();
    public E peek();//查看当前栈顶元素
    public void clear();//清空
}

3.ArrayStack方法的实现：

该类为栈的顺序存储具体实现
因为栈本身就是一种特殊的线性表
所以我们可以借用之前完成的ArrayList来实现我们ArrayStack

package p2.线性结构;

import p1.接口.Stack;

import java.util.Iterator;

public class ArrayStack<E> implements Stack<E> {
    private ArrayList<E> list;

    public ArrayStack(){
        list = new ArrayList<>();
    }
    public ArrayStack(int capacity){
        list = new ArrayList<>(capacity);
    }
    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public void push(E element) {
        list.add(element);
    }

    @Override
    public E pop() {
       return list.remove(list.size()-1);
    }

    @Override
    public E peek() {
        return list.get(list.size()-1);
    }

    @Override
    public void clear() {
        list.clear();
    }

    @Override
    public Iterator iterator() {
        return list.iterator();
    }

    @Override
    public String toString() {
        return list.toString();
    }

    @Override
    public boolean equals(Object o) {
       if(o == null){
           return false;
       }
       if(this == o){
           return true;
       }
       if(o instanceof ArrayList){
           ArrayStack other = (ArrayStack) o;
           return this.list.equals(other.list);
       }
       return false;
    }
}

4.栈的应用——中缀计算器：

中缀表达式： 是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4）
与前缀表达式（例：+ 3 4）或后缀表达式（例：3 4 +）相比，中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法。
与前缀或后缀记法不同的是，中缀记法中括号是必需的。

格式化表达式： 如果原封不动的遍历表达式字符串(10+20/2*3)/2+8
将得到如下结果：
[(, 1, 0, +, 2, 0, /, 2, *, 3, ), /, 2, +, 8]
最好的分隔结果是：
[(, 10, +, 20, /, 2, , 3, ), /, 2, +, 8]
思路：将字符串格式化为如下情形，再进行分隔即可
#(#10#+#20#/#2##3#)#/#2#+#8

栈实现中缀表达式：

1. 当遍历到+或-时，判断符号栈是否为空，当栈非空且栈顶不是（，则将符号栈里的符号一一弹栈进行运算。若栈顶是（或者栈为空时，则直接进栈。
2. 当遍历到乘号或除号时，判断符号栈是否为空，当栈非空且栈顶为是乘号或除号时，则将栈顶弹出进行运算，否则直接进栈。
3. 当遍历到（时，直接进符号栈。
4. 当遍历到）时，将符号栈元素一一弹出计算，直到，栈顶为（。
5. 当遍历到数字时，直接进数字栈。
6. 最后，将符号栈内剩余元素一一弹栈，直到栈为空。
   实现代码如下:

package p2.线性结构;

public class InfixCalculator {
    public static void main(String[] args) {
        String expression = "(10+20/2*3)/2+8";
        try {
            int result = evaluateExpression(expression);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Wrong expression :" + expression);
        }
    }

    private static int evaluateExpression(String expression) {
        //创建两个辅助栈
        ArrayStack<Character> operatorStack = new ArrayStack<>();
        ArrayStack<Integer> numberStack = new ArrayStack<>();
        //格式化表达式
        expression = insertBlanks(expression);
        String[] tokens = expression.split(" ");
        for (String token : tokens) {//token = tokens[i] 把tokens中的每个元素一个个拿进来放进token里面进行迭代
            //过滤空串
            if (token.length() == 0) {
                continue;
                //遍历到+、-号
            } else if (token.equals("+") || token.equals("-")) {
                while (!operatorStack.isEmpty() && (operatorStack.peek() == '*' || operatorStack.peek() == '/'||operatorStack.peek() == '+'||operatorStack.peek() == '-')) {
                    //如果之前是别的+-* / 则需要弹栈 并计算
                    processAnOperator(numberStack, operatorStack);
                }
                operatorStack.push(token.charAt(0));
                //遍历到*/
            } else if (token.equals("*") || token.equals("/")) {
                while (!operatorStack.isEmpty() && (operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
                    processAnOperator(numberStack, operatorStack);
                }
                operatorStack.push(token.charAt(0));
                //遍历到（
            } else if (token.equals("(")) {
                operatorStack.push(token.charAt(0));
                //遍历到）
            } else if (token.equals(")")) {
                while (operatorStack.peek()!='(') {
                    processAnOperator(numberStack, operatorStack);
                }
                operatorStack.pop();
            } else {//遍历到数字
                numberStack.push(new Integer(token));
            }
        }
        while (!operatorStack.isEmpty()) {
            processAnOperator(numberStack, operatorStack);
        }
        return numberStack.pop();
    }

    private static void processAnOperator(ArrayStack<Integer> numberStack, ArrayStack<Character> operatorStack) {
        int num1 = numberStack.pop();
        int num2 = numberStack.pop();
        char op = operatorStack.pop();
        if(op == '+'){
                numberStack.push(num2+num1);
        }else if(op == '-'){
            numberStack.push(num2-num1);
        }else if (op =='*'){
            numberStack.push(num2*num1);
        }else if(op == '/'){
            numberStack.push(num2/num1);
        }
    }

    //对原表达式进行格式化处理，在所有非数字字符两边添加空格
    private static String insertBlanks(String expression) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0;i < expression.length();i++){
            char c = expression.charAt(i);
            if(c == '('||c == ')'||c == '+'||c == '-'||c == '*'||c == '/'){
                sb.append(' ');
                sb.append(c);
                sb.append(' ');
            }else{
                sb.append(c);
            }
        }
        return sb.toString();
    }
}