数据结构与算法线性表的定义与中缀表达式

最新推荐文章于 2024-09-10 21:54:53 发布

灵魂的价值

最新推荐文章于 2024-09-10 21:54:53 发布

阅读量471

点赞数

分类专栏：数据结构文章标签：数据结构算法链表

本文链接：https://blog.csdn.net/MJ6666666/article/details/122414371

版权

数据结构专栏收录该内容

5 篇文章 0 订阅

订阅专栏

数据结构主要学习的是什么

数据们之间的关系，将离散的数据规整划一

如何将这个关系具体实现并存储到计算机中

基于关系之上对数据的具体操作，增删改查等

数据结构的具体使用场景

逻辑结构

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

线性结构：线性结构中的数据元素之间是一对一的关系

树形结构：树形结构中的数据元素之间存在一种一对多的层次关系

图形结构：图形结构的数据元素是多对多的关系

物理结构

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

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

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

链式存储结构：开辟一组随机空间存储数据

通常用节点来表示，节点不仅要存储数据还要存储下一个节点的位置以保证数据之间的关系

线性结构的物理存储方式

请添加图片描述

树形结构的物理存储方式

请添加图片描述

$l e f t C h i l d = 2 * p a r e n t + 1 r i g h t C h i l d = 2 * p a r e n t + 2 p a r e n t = (C h i l d - 1) / 2$
树形结构的链式存储结构

请添加图片描述

图形结构的物理存储方式

请添加图片描述

什么是算法

是解决特定问题求解的步骤

分析问题，一步一步求解，并得到结果

这一系列的步骤就称之为算法

请添加图片描述

常数阶O(1)

就是那些无循环，无递归，与问题输入规模N无关的，逐行执行的代码

请添加图片描述

线性阶O(n)

与问题输入规模有关系的，主要是一层循环代码，多个一层循环可以并列但不能包括

请添加图片描述

线性阶O(n+m)

和线性阶O(n)一样，只不过我们有两种数据的输入规模

请添加图片描述

平方阶O(n^2)

与问题输入规模有关，主要是二层嵌套循环的代码

请添加图片描述

平方阶O(nm)

和平方阶O(n^2)一样，只不过我们有两种数据输入规模

请添加图片描述

对数阶O(log^n)

与问题输入规模有关，主要是一层循环迭代或递归的代码

请添加图片描述

常数阶比较

请添加图片描述

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

请添加图片描述

静态数组与动态数组

java内置数组的特点：

数组的长度一旦确定则不可更改

数组只能存储同一类型的数据

数组中每个存储空间地址是连续的且相等的

数组提供角标的方式访问元素

java内置数组的缺点：

长度不可变，容量不够用怎么办

地址连续且提供角标访问很快，但增删元素怎么办

数组只有length这个属性，没有其他办法

其实，动态数组就是顺序存储结构具体实现的核心思想。

线性表的定义

零个或多个元素的有限序列

请添加图片描述

线性表的长度表示有效元素的个数

List接口的定义

既然线性结构可以由顺序存储结构的链式结构实现

那么将两者对线性结构共同的操作进行抽取，定义出线性结构的接口

public interface List<E> extends Iterable<E>{
    public void add(E element);//默认在结尾添加
    //在指定角标下添加元素
    public void add(int indext,E element);
    //删除指定元素
    public void  remove(E element);
    //删除指定角标的元素，并返回原先的值
    public  E remove(int indext);
    //获取指定角标处的元素
    public E get(int indext);
    //修改指定角标index处的值为element并返回原先的值
    public E set(int indext ,E 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);
    //获取子线性表 原线性表中[formIndex，toIndex]这个部分
    public List<E> subList(int fromIndex,int toIndex);
}

实现子类ArrayList

//自定义的线性表的顺序存储结构
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");
        }
        DEFAULT_CAPACITY = capacity;
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }
    //指定数组的构造函数：传入一个数组 将该数组封装成为一个线性表
    //[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
    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 ofrange");
        }
        //先保存要删除的值
        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("get index out of range");
        }
        E ret = data[index];
        data[index] = element;
        return ret;
    }

    @Override
    public int size() {

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

    @Override
    public int indexOf(E element) {
        /*
        == 比的是啥？ 主要看等号的两边是啥
        == 两边是基本数据类型的话 比的是值
        byte short int long
        float double
        char boolean
        == 两边是引用数据类型的话 比的是地址
        数组 字符串 其他的类对象
         */
        for (int i = 0; i<size; i++){
            if (data[i].equals(element)){
                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");
        }
        for(int i = 1;i < size; i++){
            E e = data[i];
            int j = 0;
            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 <= formIndex <=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) {
        //判空
        if (o == null){
            return false;
        }
        //判自己
        if (this == o){
            return true;
        }
        //判类型
        if (o instanceof ArrayList){
            //按照自己的逻辑进行比较
            ArrayList<E> other = (ArrayList<E>) o;
            //先比有效元素的个数
            if (this.size != other.size){
                return false;
            }
            //有效元素个数相等的情况下 逐个比较元素
            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]
     */
    @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++];
        }
    }
}

栈的定义

栈是限定仅在表尾进行插入和删除操作的线性表

我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom）

不含任何数据元素的栈称为空栈

栈又称为后进先出（Last In First Out）的线性表，简称为LIFO结构

栈本身是一个线性表，其数据元素具有线性关系，只不过它是一种特殊的线性表而已

栈的插入操作，叫做进栈，也称压栈，入栈

栈的删除操作，叫做出栈，也称弹栈

Stack栈接口的定义

同样栈可以顺序存储实现也可以链表存储实现

所以将共性抽取定义处Stack接口

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+4）

与前缀表达式（例：+34）或后缀表达式（例：34+）相比中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法

与前缀或后缀记法不同的是，中缀记法中括号是必须的

格式化表达式

如果原封不动的遍历表达式字符串（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

中缀计算器

public class InfixCalculator1 {
    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]
            //过滤空串
            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) {
        char op = operatorStack.pop();
        int num1 = numberStack.pop();
        int num2 = numberStack.pop();
        //num2 op num1
        if (op == '+') {
            numberStack.push(num2 + num1);
        } else if (op == '-') {
            numberStack.push(num2 - num1);
        } else if (op == '*') {
            numberStack.push(num2 * num1);
        } else {
            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();
    }
}

灵魂的价值

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构与算法线性表的定义与中缀表达式

数据结构主要学习的是什么数据们之间的关系，将离散的数据规整划一如何将这个关系具体实现并存储到计算机中基于关系之上对数据的具体操作，增删改查等数据结构的具体使用场景逻辑结构是指数据元素之间的相互关系，是我们想象出来的，并没有实质性的将其存储在计算机中线性结构：线性结构中的数据元素之间是一对一的关系树形结构：树形结构中的数据元素之间存在一种一对多的层次关系图形结构：图形结构的数据元素是多对多的关系物理结构是指数据的逻辑结构在计算机中的具体存储形式顺序存储结构：开辟一组连续的空间存储数据
复制链接

扫一扫

专栏目录