• 基本数据结构与算法JavaAPI【1】--线性表篇

    一、顺序表：顺序表说白了就是对数组的规范使用

    1.结构定义：

    1.     // 存储元素的数组
    2.     private T[] eles;
    3.  
    4.     // 记录当前顺序表中元素个数
    5.     private int N;
    6.  
    7.     // 构造方法
    8.     public MyOrderList(int capacity) {
    9.         // 初始化数组
    10.         this.eles = (T[])new Object[capacity];
    11.  
    12.         // 初始化长度
    13.         this.N=0;
    14.     }

    2.顺序表的各种操作

    1.     // 将每一个线性表置为空表
    2.     public void clear(){
    3.         this.N=0;
    4.     }
    5.  
    6.     // 判断当前线性表是否为空表
    7.     public boolean isEmpty(){
    8.         return this.N==0;
    9.     }
    10.  
    11.     // 获取线性表长度
    12.     public int Length(){
    13.         return this.N;
    14.     }
    15.  
    16.     // 获取指定位置的元素
    17.     public T getFrom(int i){
    18.         return eles[i-1];
    19.     }
    20.  
    21.     // 向线性表中添加元素
    22.     public void insertInto(T t){
    23.         if(N==eles.length){
    24.             resize(2*eles.length);
    25.         }
    26.         eles[this.N++]=t;
    27.     }
    28.  
    29.     //在i元素处插入元素t（查询极端位置）
    30.     public void insertInto(int i,T t){
    31.  
    32.         if(N==eles.length){
    33.             resize(2*eles.length);
    34.         }
    35.  
    36.         i--;
    37.         //先把i索引处的元素及其以后的元素向后移动一位
    38.         for (int j = this.N; j >i; j--) {
    39.             eles[j]=eles[j-1];
    40.         }
    41.         //再把t元素放到i索引处即可
    42.         eles[i]=t;
    43.         this.N++;
    44.     }
    45.  
    46.     //删除指定位置I处的元素并返回该元素
    47.     public T removeFrom(int i){
    48.         i--;
    49.         //记录索引i处的值
    50.         T target=eles[i];
    51.         //索引i后面的元素(不含索引i)依次向前移动一位
    52.         for (int j =i; j< (this.N-1); j++) {
    53.             eles[j]=eles[j+1];
    54.         }
    55.         //元素个数减一
    56.         this.N--;
    57.  
    58.         if(N4){
    59.             resize(eles.length/2);
    60.         }
    61.  
    62.         return target;
    63.     }
    64.  
    65.     //查询t元素第一次出现的位置
    66.     public int indexOf(T t){
    67.         for (int i = 0; i < (this.N-1); i++) {
    68.             if(t.equals(eles[i])){
    69.                 return i+1;
    70.             }
    71.         }
    72.         return -1;
    73.     }
    74.  
    75.     //遍历顺序表
    76.     public void showOrderList(){
    77.         for (int i = 0; i < this.N ; i++) {
    78.             System.out.print(eles[i]+"\t");
    79.         }
    80.     }
    81.  
    82.     //扩容和缩容方法：由newSize重置eles的大小
    83.     public void resize(int newSize){
    84.         //定义一个临时数组，指向原数组
    85.         T[] temp=eles;
    86.         //创建新数组
    87.         eles= (T[]) new Object[newSize];
    88.         //把原数组数据指向新数组
    89.         for (int i = 0; i < N; i++) {
    90.             eles[i]=temp[i];
    91.         }
    92.     }

    3.以java特有方式实现对顺序表的遍历，首先自定义顺序表带有泛型实现Iterable接口，重写接口中的方法

    1.     @Override
    2.     public Iterator iterator() {
    3.         return new SIterator();
    4.     }
    5.  
    6.     private class SIterator implements Iterator{
    7.  
    8.         private int cusor;
    9.  
    10.         public SIterator() {
    11.             this.cusor=0;
    12.         }
    13.  
    14.         @Override
    15.         public boolean hasNext() {
    16.             return cusor
    17.         }
    18.  
    19.         @Override
    20.         public Object next() {
    21.             return eles[cusor++];
    22.         }
    23.     }

            顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。（出自百度百科）

    二、单链表

    1.结构定义：

    1.     //记录头结点
    2.     private Node head;
    3.  
    4.     //记录链表长度
    5.     private int N;
    6.  
    7.     //结点类
    8.     private class Node{
    9.         //存储数据
    10.         T item;
    11.  
    12.         //下一个结点
    13.         Node next;
    14.  
    15.         public Node(T item,Node next){
    16.             this.item=item;
    17.             this.next=next;
    18.         }
    19.     }
    20.  
    21.     public MyLinkedList() {
    22.         //初始化头结点
    23.         this.head=new Node(null,null);
    24.  
    25.         //初始化元素个数
    26.         this.N=0;
    27.     }

    2.对单链表的各种操作

    1.     //清空链表
    2.     public void clear(){
    3.         this.head.next=null;
    4.         this.N=0;
    5.     }
    6.  
    7.     //获取链表长度
    8.     public int length(){
    9.         return this.N;
    10.     }
    11.  
    12.     //判断链表是否为空
    13.     public boolean isEmpty(){
    14.         return this.N==0;
    15.     }
    16.  
    17.     //获取指定位置i处的元素
    18.     public T get(int i){
    19.         //通过循环从头结点开始向后找i此即可得到目标
    20.         Node n=this.head.next;
    21.         for (int index = 0; index < i; index++) {
    22.             n=n.next;
    23.         }
    24.  
    25.         return n.item;
    26.     }
    27.  
    28.     //向链表中添加元素T
    29.     public void insert(T t){
    30.         //找到当前最后一个结点
    31.         Node n=this.head;
    32.         while (n.next!=null){
    33.             n=n.next;
    34.         }
    35.  
    36.         //创建新结点，保存元素T
    37.         Node newNode = new Node(t, null);
    38.  
    39.         //让当前最后一个结点指向新节点
    40.         n.next=newNode;
    41.  
    42.         //元素个数+1
    43.         this.N++;
    44.     }
    45.  
    46.     //向指定位置i处添加元素T
    47.     private void insert(int i,T t){
    48.         //找到i位置的前一个结点
    49.         Node pre=this.head;
    50.         for (int index = 0; index < i; index++) {
    51.             pre=pre.next;
    52.         }
    53.         //找到i位置结点
    54.         Node curr=pre.next;
    55.  
    56.         //创建新结点，并且新结点需要指向原来i位置的结点
    57.         final Node newNode = new Node(t, curr);
    58.         //原来i位置的前一个结点指向新结点
    59.         pre.next=newNode;
    60.  
    61.         //元素个数+1
    62.         this.N++;
    63.     }
    64.  
    65.     //删除指定位置i处的元素，并返回被删除的元素
    66.     public T remove(int i){
    67.         //找到i位置的前一个结点
    68.         Node pre = this.head;
    69.         for (int index = 0; index < i; index++) {
    70.             pre=pre.next;
    71.         }
    72.  
    73.         //找到i位置结点
    74.         Node nowNode = pre.next;
    75.  
    76.         //找到i位置下一个结点
    77.         Node curr = nowNode.next;
    78.  
    79.         //前一个结点指向下一个结点
    80.         pre.next=curr;
    81.  
    82.         //元素个数减一
    83.         this.N--;
    84.  
    85.         return nowNode.item;
    86.     }
    87.  
    88.     //查找元素T在链表中第一次出现的位置
    89.     public int indexOf(T t){
    90.         //从头结点开始遍历，取出每一个item进行比较，若相同则找到了
    91.         Node n=head;
    92.         for (int i = 0; n.next!=null; i++) {
    93.             n=n.next;
    94.             if(n.item.equals(t)){
    95.                 return i;
    96.             }
    97.         }
    98.         return -1;
    99.     }

    3.以java特有方式实现对单链表的遍历，首先自定义单链表带有泛型实现Iterable接口，重写接口中的方法

    1.     @Override
    2.     public Iterator iterator() {
    3.         return new LIterator();
    4.     }
    5.  
    6.     private class LIterator implements Iterator{
    7.         private  Node n;
    8.         public LIterator(){
    9.             this.n=head;
    10.         }
    11.  
    12.         @Override
    13.         public boolean hasNext() {
    14.             return n.next!=null;
    15.         }
    16.  
    17.         @Override
    18.         public Object next() {
    19.             n=n.next;
    20.             return n.item;
    21.         }
    22.     }

             单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。（出自百度百科）

    三、双向链表

    1.结构定义

    1.     //首结点
    2.     private Node head;
    3.     //最后一个结点
    4.     private Node last;
    5.     //链表的长度
    6.     private int N;
    7.  
    8.     //节点类
    9.     private class Node{
    10.         public Node(T item,Node pre,Node next){
    11.             this.item=item;
    12.             this.pre=pre;
    13.             this.next=next;
    14.         }
    15.         //存储数据
    16.         public T item;
    17.         //指向上一个结点
    18.         public Node pre;
    19.         //指向下一个结点
    20.         public Node next;
    21.     }
    22.  
    23.     public TwoWayLinkList() {
    24.         //初始化头结点和尾结点
    25.         this.head=new Node(null,null,null);
    26.         this.last=null;
    27.         // 初始化元素个数
    28.         this.N=0;
    29.  
    30.     }

    2.对双向链表的各种操作

    1.     //清空链表
    2.     public void clear(){
    3.         this.head.next=null;
    4.         this.head.pre=null;
    5.         this.head.item=null;
    6.         this.last=null;
    7.         this.N=0;
    8.     }
    9.  
    10.     //获取链表长度
    11.     public int length(){
    12.         return N;
    13.     }
    14.  
    15.     //判断链表是否为空
    16.     public Boolean  isEmpty(){
    17.         return N==0;
    18.     }
    19.  
    20.     //获取第一个元素
    21.     public T getFirst(){
    22.         if(isEmpty()){
    23.             return null;
    24.         }else {
    25.             return head.next.item;
    26.         }
    27.     }
    28.  
    29.     //获取最后一个元素
    30.     public T getLast(){
    31.         if(isEmpty()){
    32.             return null;
    33.         }else {
    34.             return last.item;
    35.         }
    36.     }
    37.  
    38.     //插入元素t
    39.     public void insert(T t){
    40.  
    41.         if(isEmpty()){//若链表为空
    42.             //创建新结点
    43.             Node newNode = new Node(t, head, null);
    44.             //让新结点成为尾结点
    45.             last=newNode;
    46.             //头结点指向尾结点
    47.             head.next=last;
    48.         }else {
    49.             //若链表不为空
    50.             Node oldLast=last;
    51.             //创建新结点
    52.             Node newNode = new Node(t, oldLast, null);
    53.             //让当前尾结点指向新结点
    54.             oldLast.next=newNode;
    55.  
    56.             //让新结点成为尾结点
    57.             last=newNode;
    58.         }
    59.         //元素个数+1
    60.         N++;
    61.  
    62.     }
    63.  
    64.     //向指定位置i处插入元素t
    65.     public void insert(int i,T t){
    66.         //找到i位置的前一个结点
    67.         Node pre=head;
    68.         //找到i位置的结点
    69.         for (int index = 0; index < i; index++) {
    70.             pre=pre.next;
    71.         }
    72.         Node curr = pre.next;
    73.  
    74.         //创建新结点
    75.         Node newNode = new Node(t, pre, curr);
    76.         //让i位置的前一个结点的下一个结点变为新结点
    77.         pre.next=newNode;
    78.  
    79.         //让i位置的前一个结点变为新结点
    80.         curr.pre=newNode;
    81.  
    82.         //元素个数加一
    83.         N++;
    84.     }
    85.  
    86.     //获取指定位置i处的元素
    87.     public T get(int i){
    88.         Node n=head.next;
    89.         for (int index = 0; index < i; index++) {
    90.             n=n.next;
    91.         }
    92.         return n.item;
    93.     }
    94.  
    95.     //找到元素t在链表中第一次出现的位置
    96.     public int indexOf(T t){
    97.         Node n=head;
    98.         for(int i=0;n.next!=null;i++){
    99.             n=n.next;
    100.             if(n.next.equals(t)){
    101.                 return i;
    102.             }
    103.         }
    104.         return -1;
    105.     }
    106.  
    107.     //删除i位置的元素，并返回该元素
    108.     public T remove(int i){
    109.         //找到i位置的前一个结点
    110.         Node pre=head;
    111.  
    112.         //找到i位置的前结点
    113.         for (int index = 0; index < i; index++) {
    114.             pre=pre.next;
    115.         }
    116.         //找到i位置的结点
    117.         Node curr = pre.next;
    118.  
    119.         if((i+1)==N){
    120.  
    121.             pre.next=null;
    122.             last=pre;
    123.  
    124.         }else {
    125.  
    126.             //找到i位置的下一个结点
    127.             Node nextNode = curr.next;
    128.  
    129.             //让i位置的前一个结点的下一个结点变为i位置的下一个结点
    130.             pre.next=nextNode;
    131.  
    132.             //让i位置的下一个结点的上一个结点变为i位置的前一个结点
    133.             nextNode.pre=pre;
    134.  
    135.  
    136.         }
    137.         //元素个数-1
    138.         N--;
    139.         return curr.item;
    140.     }

    3.以java特有方式实现对双链表的遍历，首先自定义双链表带有泛型实现Iterable接口，重写接口中的方法

    1.     @Override
    2.     public Iterator iterator() {
    3.         return new TIterator();
    4.     }
    5.  
    6.     private class TIterator implements Iterator{
    7.         private Node n;
    8.  
    9.         public TIterator() {
    10.             this.n=head;
    11.         }
    12.  
    13.         @Override
    14.         public boolean hasNext() {
    15.             return n.next!=null;
    16.         }
    17.  
    18.         @Override
    19.         public Object next() {
    20.             n=n.next;
    21.             return n.item;
    22.         }
    23.     }

            双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表（出自百度百科）

    四、栈

    1.结构定义

    1.     //记录首结点
    2.     private  Node head;
    3.     //栈中元素个数
    4.     private int N;
    5.     private class Node{
    6.         private T item;
    7.         private Node next;
    8.  
    9.         public Node(T item, Node next) {
    10.             this.item = item;
    11.             this.next = next;
    12.         }
    13.     }
    14.  
    15.     public MyStack() {
    16.         this.head=new Node(null,null);
    17.         this.N=0;
    18.     }

    2.对栈的各种操作

    1. //判断当前栈中元素个数是否为0
    2.     public boolean isEmpty(){return N==0;}
    3.  
    4.     //获取栈中元素个数
    5.     public int size(){
    6.         return N;
    7.     }
    8.  
    9.     //把t元素压入栈
    10.     public void push(T t){
    11.         //找到首结点指向的第一个结点
    12.         Node oldFirst = head.next;
    13.  
    14.         //创建新结点
    15.         Node newNode = new Node(t, null);
    16.  
    17.         //让首结点指向新结点
    18.         head.next=newNode;
    19.  
    20.         //让新结点指向原来的第一个结点
    21.         newNode.next=oldFirst;
    22.  
    23.         //元素个数+1
    24.         N++;
    25.     }
    26.  
    27.     //弹出栈顶元素
    28.     public T pop(){
    29.         //找到首结点指向的第一个结点
    30.         Node oldFirst = head.next;
    31.  
    32.         //让首结点指向原来第一个结点的下一个结点
    33.         if(oldFirst==null){
    34.             return null;
    35.         }
    36.         head.next=oldFirst.next;
    37.  
    38.         //元素个数-1
    39.         N--;
    40.  
    41.         return oldFirst.item;
    42.     }

    3.以java特有方式实现对栈的遍历，首先自定义栈带有泛型实现Iterable接口，重写接口中的方法

    1.     @Override
    2.     public Iterator iterator() {
    3.         return new SIterator();
    4.     }
    5.  
    6.     private class SIterator implements Iterator{
    7.         private Node n;
    8.  
    9.         public SIterator() {
    10.             this.n=head;
    11.         }
    12.  
    13.         @Override
    14.         public boolean hasNext() {
    15.             return n.next!=null;
    16.         }
    17.  
    18.         @Override
    19.         public Object next() {
    20.             n=n.next;
    21.             return n.item;
    22.         }
    23.     }

            栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。（出自百度百科）

    五、队列

    队列的结构定义

    1.     //队列的结构
    2.     private class Node{
    3.         public T item;
    4.         public Node next;
    5.  
    6.         public Node(T item, Node next) {
    7.             this.item = item;
    8.             this.next = next;
    9.         }
    10.     }
    11.     //记录首结点
    12.     private Node head;
    13.     //记录最后一个结点
    14.     private Node last;
    15.     //记录队列中元素个数
    16.     private int N;
    17.  
    18.     public MyQueue() {
    19.         this.head =new Node(null,null);
    20.         this.last=null;
    21.         this.N=0;
    22.     }

    队列的各种操作

    1.     //判断队列是否为空
    2.     public boolean isEmpty(){
    3.         return N==0;
    4.     }
    5.  
    6.     //返回队列中的元素个数
    7.     public int size(){
    8.         return N;
    9.     }
    10.  
    11.     //向队列中插入元素t
    12.     public void  enqueue(T t){
    13.         if(last==null){//当前尾结点last为null
    14.             last=new Node(t,null);
    15.             head.next=last;
    16.         }else {//当前尾结点last不为null
    17.             Node oldLast=last;
    18.             last=new Node(t,null);
    19.             oldLast.next=last;
    20.         }
    21.         //元素个数+1
    22.         this.N++;
    23.     }
    24.  
    25.     //从队列中拿出一个元素
    26.     public T dequeue(){
    27.         if(isEmpty()){
    28.             return null;
    29.         }
    30.         Node oldFrist=head.next;
    31.         head.next=oldFrist.next;
    32.         N--;
    33.  
    34.         //因为出队列是在删除元素，故若队列中的元素被删除完了需要重置last=null
    35.         if(isEmpty()){
    36.             last=null;
    37.         }
    38.         return oldFrist.item;
    39.     }

    队列的遍历，在队列类实现Iterable接口的条件下

    1.     @Override
    2.     public Iterator iterator() {
    3.         return new QIterator();
    4.     }
    5.  
    6.     private class QIterator implements Iterator{
    7.  
    8.         private Node n;
    9.  
    10.         public QIterator() {
    11.             this.n = head;
    12.         }
    13.  
    14.         @Override
    15.         public boolean hasNext() {
    16.             return n.next!=null;
    17.         }
    18.  
    19.         @Override
    20.         public Object next() {
    21.             n=n.next;
    22.             return n.item;
    23.         }
    24.     }

            队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。（出自百度百科）

    六、符号表（键值对）

    结构定义

    1.     //定义内部类
    2.     private class Node{
    3.         //键
    4.         public Key key;
    5.         //值
    6.         public Value value;
    7.         //下一个结点
    8.         public Node next;
    9.  
    10.         public Node(Key key, Value value, Node next) {
    11.             this.key = key;
    12.             this.value = value;
    13.             this.next = next;
    14.         }
    15.     }
    16.     //记录首结点
    17.     private Node head;
    18.     //记录符号中的元素个数
    19.     private int N;
    20.  
    21.     public SymbolTable() {
    22.         this.head=new Node(null,null,null);
    23.         this.N=0;
    24.     }

    对符号表的各种操作

    1.     //获取符号表中键值对的个数
    2.     public int size(){
    3.         return N;
    4.     }
    5.  
    6.     //向符号表中插入键值对
    7.     public void put(Key key,Value value){
    8.         //符号表中已经存在键为key的键值对，则只需要将key的值进行覆盖
    9.         Node n=head;
    10.         while (n.next!=null){
    11.             //变换n
    12.             n=n.next;
    13.             //判断n结点存储的键你是否为n，如果是则覆盖其值
    14.             if(n.key.equals(key)){
    15.                 n.value=value;
    16.                 return;
    17.             }
    18.         }
    19.         //符号表中不存在key的键值对，直接存入即可
    20.         Node newNode = new Node(key, value, null);
    21.         Node oldFist = head.next;
    22.         newNode.next=oldFist;
    23.         head.next=newNode;
    24.         N++;
    25.     }
    26.  
    27.     //删除符号表中键为key的键值对
    28.     public void delete(Key key){
    29.         //找到键为key的结点，把该结点删除
    30.         Node n = this.head;
    31.         while (n.next!=null){
    32.             //判断n结点的下一个结点是否为key
    33.             if(n.next.key.equals(key)){
    34.                 n.next=n.next.next;
    35.                 N--;
    36.                 return;
    37.             }
    38.             n=n.next;
    39.         }
    40.     }
    41.  
    42.     //从符号表中获取key对应的值
    43.     public Value get(Key key){
    44.         //找到键为key的结点
    45.         Node n = this.head;
    46.         while (n.next!=null){
    47.             n=n.next;
    48.             if(n.key.equals(key)){
    49.                 return n.value;
    50.             }
    51.  
    52.         }
    53.         return null;
    54.     }

    有序符号表，有序符号表的实现不过是在无序符号表的基础上，在进行数据添加时将添加数据的键和已有的键进行大小比较，进而实现数据的有序。在原有的符号表的key实现了Comparable的基础上，对数据增加方法进行以下修改

    1.     //向符号表中插入键值对
    2.     public void put(Key key,Value value){
    3.         //定义两个结点分别记录当前结点和低昂前结点的上一个结点
    4.         Node curr = head.next;
    5.         Node pre = this.head;
    6.  
    7.         while (curr!=null&&key.compareTo(curr.key)>0){
    8.             //变换当前结点和当前结点的上一个结点
    9.             pre=curr;
    10.             curr=curr.next;
    11.         }
    12.         //若要插入的键和当前的key值相同，则覆盖
    13.         if(curr!=null&& key.compareTo(curr.key)==0){
    14.             curr.value=value;
    15.             return;
    16.         }
    17.         //当前要插入的键和当前的key不同则插入
    18.         Node newNode = new Node(key, value, null);
    19.         newNode.next=curr;
    20.         pre.next=newNode;
    21.         N++;
    22.     }

            符号表最主要的目的就是将一个键和一个值联系起来，符号表能够将存储的数据元素是一个键和一个值共同组成的。键值对数据，我们可以根据键来查找对应的值。

    算法与数据结构排序与线性表篇小节：

    快慢指针：
        开门指针指移动速度有差别的两个指针，通过这个差别可以得到一个差值，长使用这个差值解决中值问题，单向链表是否成环问题，有环链表入口问题

    题目分析：
        1.在没有思路的时候，先找小数据做暴力穷举，然后看看能不能得出题目答案。
        2.先用小数据看看是个什么数学公式。然后再翻译成代码

    递归类计算：
        容易出现的问题，递归要不断进栈。当存在大量数据时，只用递归使得栈内存溢出，同时也会消耗大量运算时间
        解决方法，可以外置一个HashMap，通过HashMap保存每一次计算结果，这样可以减少栈内存溢出情况，同时也会节约大量运算时间

    逆波兰表达式{
        中缀表达式：a+b
        后缀表达式：
            a+b=ab+;a+(b-c)*d=abc-d*+
            a*(b-c)+d=abc-*d+

    }

  • 相关阅读:
    C语言——动态数组的创建和使用
    tcpdump(一)基础理论知识
    H5页面在ios上文本框不能输入
    【Jenkins打包服务，Dockerfile报错：manifest for java : 8 not fourd】
    RestTemplate使用方法
    【单片机基础】ADC0832详解
    Datawhale-新能源时间序列赛事学习笔记(1)
    YOLOv5训练自己的数据集(超详细)
    水果店圈子：做水果店有多赚钱，开个小型水果店一年收入能赚多少钱
    Linux查看僵尸进程
  • 原文地址：https://blog.csdn.net/qq_55865959/article/details/126445663