我的编程空间,编程开发者的网络收藏夹
学习永远不晚

Android实践(计算器的数据结构实现)

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

Android实践(计算器的数据结构实现)

新的知识,新的开始。

接下来一起探讨使用Android技术解决计算器诸多问题,首先这个方法并不是适合所有人,有数据结构基础的同学可以稍微看看。

一般实现Android计算器都是只能进行例如 x + y = z的操作,但是需要实现类似于a + b * c = d的操作需要使用到逆波兰式。

下面解释一下逆波兰式的功能,人类认识中缀表达式,例如a+b*c,但是计算机只会按部就班的操作(a+b)*c,这样就与我们的目的背道而驰了,所以我们得将中缀表达式转化为后缀表达式,观察如下表格:

中缀表达式 后缀表达式
a+b*c abc*+
a*b+c ad*c+

我们所知 ÷× 的优先级比 + - 高。那我们如何使用后缀表达式呢?看如下图

栈底----->栈顶
a       没有两个数字
ab     有两个数字则需要评判下一位是不是运算符
abc   显然下一位并不是运算符,则再次评判下一位
abc*  这里可以运行b*c = z操作并压入栈中
az     继续评判
az+   运算完成 (b*c)+a   

 下来我们看一下该代码是如何实现的。


static Stack op = new Stack();
    public static Float getv(char op, Float f1, Float f2) {
        if (op == '+') return f2 + f1;
        else if (op == '-') return f2 - f1;
        else if (op == '*') return f2 * f1;
        else if (op == '/') return f2 / f1;
        else return Float.valueOf(-0);
    }
    public static float calrp(LinkedList rp) {
        Stack v = new Stack();
        int len = rp.size();
        for (int i = 0; i < len; i++) {
            InnerOperateChar ch =rp.get(i);
            //如果是数字则压栈
            if (ch.isNum()) v.push(Float.parseFloat(ch.getNumber()));
            //非数字进行操作压栈
            else v.push(getv(ch.getOperater(), v.pop(), v.pop()));
        }
        return v.pop();
    }

那我们再往前推进,如何生成后缀表达式呢?

我们仔细观察一下中缀转化为后缀的过程

a+b*c    ----->   abc*+

 元素位置不变,则说明遇见数字则直接加入结果行列,那遇见运算符呢?

接下来一步一步进行模拟。

result op(栈) 操作讲解
a   a直接加入result
a + +入栈
ab + b直接加入result
ab +* *入栈
ab* + *出栈
ab*c + c直接加入result
ab*c+   +出栈

过程捕捉:在遇见+-运算时候需要将之前的op栈的元素弹出并加入至result中 ,在遇见*/运算符时,与之前的操作一直,不过遇见同等运算等级的弹出元素需要停止。

以下是Java源程序。


public static LinkedList getrp(LinkedList s) {
        int len = s.size();
        LinkedList result = new LinkedList();
        for (int i = 0; i < len; i++) {
            InnerOperateChar ch = s.get(i);
            if (ch.isNum()) {
                result.add(ch);
            } else if (!ch.isNum()) {
                //如果是运算符的话
                char oppo = ch.getOperater();
                if (oppo == '+' || oppo == '-') {
                    while (!op.empty()) {
                        result.add(op.pop());
                    }
                    op.push(ch);
                }
                if (oppo == '*' || oppo == '/') {
                    while (!op.empty() && op.peek().getOperater() == '*') {
                        result.add(op.pop());
                    }
                    op.push(ch);
                }
            }
        }
        while (!op.empty()) {
            InnerOperateChar temp = op.pop();
            result.add(temp);
        }
        return result;
    }

接下来解析工程中的重要数据结构(即运算符与数字集合类)

如下为创建的过程,再次声明,这里的数据结构是为了简化后期程序的难度。


//添加数字
linkedList.add(new InnerOperateChar("1"));
//添加运算符
linkedList.add(new InnerOperateChar('-'));

package com.example.thirdlesson;
public class InnerOperateChar {
    private String number;
    private char operater;
    private boolean isNum;
    public InnerOperateChar(String number) {
        this.number = number;
        this.operater = '#';
        this.isNum = true;
    }
    public InnerOperateChar(char operater) {
        this.number ="#";
        this.operater = operater;
        this.isNum = false;
    }
    public boolean isNum() {
        return isNum;
    }
    public void setNum(boolean num) {
        isNum = num;
    }
    public String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number;
    }
    public char getOperater() {
        return operater;
    }
    public void setOperater(char operater) {
        this.operater = operater;
    }
}

那我们开始我们的布局排版吧。

这是我们的预期效果图

完整xml文件在最后面

 接下来我们查看我们TextView中的两个元素


TextView showResult;//即xml中的showResult
TextView showAll;//即xml中的showAll
showAll = this.findViewById(R.id.showAll);
showResult = this.findViewById(R.id.showResult);

同时我们也设定了一个参数,用来将当前输入的数字或者运算符加入进去。


//单一数据
StringBuffer paramOne = new StringBuffer();
接下来是细节部分: 此操作为清零操作 实现现象:

 实现代码:

btnC = this.findViewById(R.id.buttonC);
        btnC.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //清零
                //1.paramOne清零
                //2.showAll清零
                //3.showResult清零
                //4.linkedList清空
                paramOne = new StringBuffer();
                showAll.setText("");
                showResult.setText("");
                linkedList.clear();
            }
        });
  此操作为删除操作 主要重点: 当前所有的参数都为空,则为当前存放字符为空并且当前链表为空 当前paramOne有参数,如果进行当前paramOne删除,并同步 如果paramOne没参数,则提取linkedList的最后一个元素lastOne lastOne如果是运算符,则直接删除即可 lastOne如果是字符串,比如123.1则需要提取至paramOne中进行删除同步 实现现象:

 实现源码:

btnDel = this.findViewById(R.id.buttonDEL);
        btnDel.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //删除最后一个
                //1.如果paramOne还有数据就进行删除
                //1.1 并且showResult需要同步删除
                //2.如果paramOne没数据,提取linkedList最后一个
                //2.1 如果是运算符,直接linkedList移除最后一个
                //2.2 如果是字符串,则将paramOne赋值为linkedList最后一个元素,并同步showResult
                //2.3 同步showAll
                //避免删除闪退
                if(linkedList.size()==0 && paramOne.length()==0){
                    return;
                }
                if(paramOne.length()!=0){
                    paramOne=new StringBuffer(paramOne.subSequence(0,paramOne.length()-1));
                    showResult.setText(paramOne.toString());
                }
                else{
                    //如果是运算符的话,不需要任何操作
                    InnerOperateChar lastElem = linkedList.removeLast();
                    if(lastElem.isNum()){
                        String lastNum = lastElem.getNumber();
                        paramOne = new StringBuffer(lastNum.substring(0,lastNum.length()-1));
                        showResult.setText(paramOne.toString());
                    }else {
                        ;
                    }
                    showAll.setText(AllToString(linkedList));
                }
            }
        });
 此操作为点击数字操作 实现代码:

switch (v.getId()) {
                case R.id.button0:
                    //上端不用改变,只有进行运算的时候入队即可
                    paramOne.append("0");
                    showResult.setText(paramOne.toString());
                    break;
}
 此操作为小数点处理 试验现象:

主要难点:需要判断当前ParamOne的长度是否是0,如果是的话则就是这个操作,如果包含.如果包含则不需要再添加,否则添加。 实现代码: 

case R.id.buttonDOT:
                    //如果出现再没数字的情况下直接按下.则直接变为0. 然后再进行后续操作
                    if(paramOne.length()==0){
                        paramOne.append("0.");
                    }else{
                        //如果出现1.1 然后还想点. 则不生效否则添加
                        if(paramOne.toString().contains(".")){
                            ;
                        }else{
                            paramOne.append(".");
                        }
                    }
                    showResult.setText(paramOne.toString());
                    break;
此操作为点击运算符操作:

实现大致方法:


需要paramOne入队
paramOne清空
操作符入队
showAll显示
showResult清空
实现代码:

case R.id.buttonPLUS:                                                            
    //进行加运算                                                                      
    //1.需要paramOne入队                                                             
    //2.paramOne清空                                                               
    //3.操作符入队                                                                    
    //4.showAll显示                                                                
    //5.showResult清空                                                             
    //以免造成 12. - 12得现象                                                           
    if(paramOne.charAt(paramOne.length()-1)=='.'){                               
        paramOne = new StringBuffer(paramOne.subSequence(0,paramOne.length()-1));
    }                                                                            
    linkedList.add(new InnerOperateChar(paramOne.toString()));                   
    paramOne = new StringBuffer();                                               
    linkedList.add(new InnerOperateChar('+'));                                   
    showAll.setText(AllToString(linkedList));                                    
    showResult.setText("");                                                      
    break;                                                                       
此操作为负数与减法操作: 实现现象:

实现代码:


case R.id.buttonSUB:                                                                  
    //进行-运算                                                                           
    //如果paramOne 长度不为0的话,那就是要进行 - 减操作                                                 
    if(paramOne.length()!=0){                                                         
        if(paramOne.charAt(paramOne.length()-1)=='.'){                                
            paramOne = new StringBuffer(paramOne.subSequence(0,paramOne.length()-1)); 
        }                                                                             
        linkedList.add(new InnerOperateChar(paramOne.toString()));                    
        paramOne = new StringBuffer();                                                
        linkedList.add(new InnerOperateChar('-'));                                    
        showAll.setText(AllToString(linkedList));                                     
        showResult.setText("");                                                       
    }else {                                                                           
        paramOne.append("-");                                                         
        showResult.setText(paramOne.toString());                                      
    }                                                                                                                                            
 进行结果运算: 主要实现源码:

btnIs = this.findViewById(R.id.buttonIS);                                     
btnIs.setOnClickListener(new View.OnClickListener() {                         
    @Override                                                                 
    public void onClick(View v) {                                             
        linkedList.add(new InnerOperateChar(paramOne.toString()));            
        paramOne = new StringBuffer();                                        
        showAll.setText(AllToString(linkedList));                             
        OperateSu1 operateChar = new OperateSu1();                            
        LinkedList suffer = operateChar.getrp(linkedList);  
        float result = operateChar.calrp(suffer);                             
        showResult.setText(result+"");                                        
    }                                                                         
});                                                                           

最后就是完整代码了:


package com.example.thirdlesson;
import androidx.appcompat.app.AppCompatActivity;
import android.graphics.Path;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import java.util.LinkedList;
public class MainActivity extends AppCompatActivity {
    //清零,删除上一字符,等于
    Button btnC, btnDel, btnIs;
    //单一数据
    StringBuffer paramOne = new StringBuffer();
    Button[] buttons_num = new Button[11];
    int[] btnId_num = {R.id.button0, R.id.button1, R.id.button2, R.id.button3, R.id.button4, R.id.button5, R.id.button6, R.id.button7, R.id.button8, R.id.button9, R.id.buttonDOT};
    //放 + - * /的按钮
    Button[] buttons_operate = new Button[4];
    //+ - * /
    int[] btnId_operate = {R.id.buttonPLUS, R.id.buttonSUB, R.id.buttonMUL, R.id.buttonDEV};
    TextView showResult;
    TextView showAll;
    LinkedList linkedList;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //设置内容视图
        setContentView(R.layout.main_layout);
        linkedList = new LinkedList();
        //实例化对象
        initView();
        //绑定监听事件
        //也可以在xml中这样写
        //android:onClick="myClick"
        myClick myClickClass = new myClick();
        for (int i = 0; i < buttons_num.length; i++) {
            buttons_num[i].setOnClickListener(myClickClass);
        }
        for (int i = 0; i < buttons_operate.length; i++) {
            buttons_operate[i].setOnClickListener(myClickClass);
        }
        btnIs = this.findViewById(R.id.buttonIS);
        btnIs.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                linkedList.add(new InnerOperateChar(paramOne.toString()));
                paramOne = new StringBuffer();
                showAll.setText(AllToString(linkedList));
                OperateSu1 operateChar = new OperateSu1();
                LinkedList suffer = operateChar.getrp(linkedList);
                float result = operateChar.calrp(suffer);
                showResult.setText(result+"");
            }
        });
        btnDel = this.findViewById(R.id.buttonDEL);
        btnDel.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //删除最后一个
                //1.如果paramOne还有数据就进行删除
                //1.1 并且showResult需要同步删除
                //2.如果paramOne没数据,提取linkedList最后一个
                //2.1 如果是运算符,直接linkedList移除最后一个
                //2.2 如果是字符串,则将paramOne赋值为linkedList最后一个元素,并同步showResult
                //2.3 同步showAll
                //避免闪退
                if(linkedList.size()==0 && paramOne.length()==0){
                    return;
                }
                if(paramOne.length()!=0){
                    paramOne=new StringBuffer(paramOne.subSequence(0,paramOne.length()-1));
                    showResult.setText(paramOne.toString());
                }
                else{
                    //如果是运算符的话,不需要任何操作
                    InnerOperateChar lastElem = linkedList.removeLast();
                    if(lastElem.isNum()){
                        String lastNum = lastElem.getNumber();
                        paramOne = new StringBuffer(lastNum.substring(0,lastNum.length()-1));
                        showResult.setText(paramOne.toString());
                    }else {
                        ;
                    }
                    showAll.setText(AllToString(linkedList));
                }
            }
        });
        btnC = this.findViewById(R.id.buttonC);
        btnC.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //清零
                //1.paramOne清零
                //2.showAll清零
                //3.showResult清零
                //4.linkedList清空
                paramOne = new StringBuffer();
                showAll.setText("");
                showResult.setText("");
                linkedList.clear();
            }
        });
    }
    void initView() {
        for (int i = 0; i < btnId_num.length; i++) {
            buttons_num[i] = this.findViewById(btnId_num[i]);
        }
        for (int i = 0; i < btnId_operate.length; i++) {
            buttons_operate[i] = this.findViewById(btnId_operate[i]);
        }
        showAll = this.findViewById(R.id.showAll);
        showResult = this.findViewById(R.id.showResult);
    }
    class myClick implements View.OnClickListener {
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.button0:
                    //上端不用改变,只有进行运算的时候入队即可
                    paramOne.append("0");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.button1:
                    paramOne.append("1");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.button2:
                    paramOne.append("2");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.button3:
                    paramOne.append("3");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.button4:
                    paramOne.append("4");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.button5:
                    paramOne.append("5");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.button6:
                    paramOne.append("6");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.button7:
                    paramOne.append("7");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.button8:
                    paramOne.append("8");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.button9:
                    paramOne.append("9");
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.buttonDOT:
                    //如果出现再没数字的情况下直接按下.则直接变为0. 然后再进行后续操作
                    if(paramOne.length()==0){
                        paramOne.append("0.");
                    }else{
                        //如果出现1.1 然后还想点. 则不生效否则添加
                        if(paramOne.toString().contains(".")){
                            ;
                        }else{
                            paramOne.append(".");
                        }
                    }
                    showResult.setText(paramOne.toString());
                    break;
                case R.id.buttonPLUS:
                    //进行加运算
                    //1.需要paramOne入队
                    //2.paramOne清空
                    //3.操作符入队
                    //4.showAll显示
                    //5.showResult清空
                    //以免造成 12. - 12得现象
                    if(paramOne.charAt(paramOne.length()-1)=='.'){
                        paramOne = new StringBuffer(paramOne.subSequence(0,paramOne.length()-1));
                    }
                    linkedList.add(new InnerOperateChar(paramOne.toString()));
                    paramOne = new StringBuffer();
                    linkedList.add(new InnerOperateChar('+'));
                    showAll.setText(AllToString(linkedList));
                    showResult.setText("");
                    break;
                case R.id.buttonSUB:
                    //进行-运算
                    //如果paramOne 长度不为0的话,那就是要进行 - 减操作
                    if(paramOne.length()!=0){
                        if(paramOne.charAt(paramOne.length()-1)=='.'){
                            paramOne = new StringBuffer(paramOne.subSequence(0,paramOne.length()-1));
                        }
                        linkedList.add(new InnerOperateChar(paramOne.toString()));
                        paramOne = new StringBuffer();
                        linkedList.add(new InnerOperateChar('-'));
                        showAll.setText(AllToString(linkedList));
                        showResult.setText("");
                    }else {
                        paramOne.append("-");
                        showResult.setText(paramOne.toString());
                    }
                    break;
                case R.id.buttonMUL:
                    //进行*运算
                    if(paramOne.charAt(paramOne.length()-1)=='.'){
                        paramOne = new StringBuffer(paramOne.subSequence(0,paramOne.length()-1));
                    }
                    linkedList.add(new InnerOperateChar(paramOne.toString()));
                    paramOne = new StringBuffer();
                    linkedList.add(new InnerOperateChar('*'));
                    showAll.setText(AllToString(linkedList));
                    showResult.setText("");
                    break;
                case R.id.buttonDEV:
                    //进行/运算
                    if(paramOne.charAt(paramOne.length()-1)=='.'){
                        paramOne = new StringBuffer(paramOne.subSequence(0,paramOne.length()-1));
                    }
                    linkedList.add(new InnerOperateChar(paramOne.toString()));
                    paramOne = new StringBuffer();
                    linkedList.add(new InnerOperateChar('/'));
                    showAll.setText(AllToString(linkedList));
                    showResult.setText("");
                    break;
            }
        }
    }
    public String AllToString(LinkedList s) {
        String result = "";
        for(InnerOperateChar innerOperateChar:s){
            if(innerOperateChar.isNum()){
                result += innerOperateChar.getNumber();
            }else{
                result += " " +innerOperateChar.getOperater()+" ";
            }
        }
        return result;
    }
}

 xml文件


        

package com.example.thirdlesson;
import java.util.LinkedList;
import java.util.Stack;
public class OperateSu1 {
    static Stack op = new Stack();
    public static Float getv(char op, Float f1, Float f2) {
        if (op == '+') return f2 + f1;
        else if (op == '-') return f2 - f1;
        else if (op == '*') return f2 * f1;
        else if (op == '/') return f2 / f1;
        else return Float.valueOf(-0);
    }
    public static float calrp(LinkedList rp) {
        Stack v = new Stack();
        int len = rp.size();
        for (int i = 0; i < len; i++) {
            InnerOperateChar ch =rp.get(i);
            //如果是数字则压栈
            if (ch.isNum()) v.push(Float.parseFloat(ch.getNumber()));
            //非数字进行操作压栈
            else v.push(getv(ch.getOperater(), v.pop(), v.pop()));
        }
        return v.pop();
    }
    public static LinkedList getrp(LinkedList s) {
        int len = s.size();
        LinkedList result = new LinkedList();
        for (int i = 0; i < len; i++) {
            InnerOperateChar ch = s.get(i);
            if (ch.isNum()) {
                result.add(ch);
            } else if (!ch.isNum()) {
                //如果是运算符的话
                char oppo = ch.getOperater();
                if (oppo == '+' || oppo == '-') {
                    while (!op.empty()) {
                        result.add(op.pop());
                    }
                    op.push(ch);
                }
                if (oppo == '*' || oppo == '/') {
                    while (!op.empty() && op.peek().getOperater() == '*') {
                        result.add(op.pop());
                    }
                    op.push(ch);
                }
            }
        }
        while (!op.empty()) {
            InnerOperateChar temp = op.pop();
            result.add(temp);
        }
        return result;
    }
    //    public static void main(String[] args) {
//        LinkedList linkedList = new LinkedList();
//        linkedList.add(new InnerOperateChar("1"));
//        linkedList.add(new InnerOperateChar('+'));
//        linkedList.add(new InnerOperateChar("11"));
//        linkedList.add(new InnerOperateChar('*'));
//        linkedList.add(new InnerOperateChar("3"));
//        linkedList.add(new InnerOperateChar('-'));
//        linkedList.add(new InnerOperateChar("8"));
//        LinkedList paramString = getrp(linkedList);
//        //1+22*33-8
////        System.out.println(paramString);
//
//        System.out.println(calrp(paramString));
//    }
}

作者:Bit_We


免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

Android实践(计算器的数据结构实现)

下载Word文档到电脑,方便收藏和打印~

下载Word文档

猜你喜欢

Android实践(计算器的数据结构实现)

新的知识,新的开始。 接下来一起探讨使用Android技术解决计算器诸多问题,首先这个方法并不是适合所有人,有数据结构基础的同学可以稍微看看。 一般实现Android计算器都是只能进行例如 x + y = z的操作,但是需要实现类似于a +
2022-06-06

Java数据结构之栈与综合计算器的实现

这篇文章主要为大家详细介绍了Java数据结构中栈与综合计算器的实现,文中的示例代码讲解详细,具有一定的学习价值,感兴趣的小伙伴可以了解一下
2022-11-13

MongoDB与边缘计算的结合实践与架构设计

随着物联网和云计算的快速发展,边缘计算逐渐成为新的热点领域。边缘计算是指将数据处理和计算能力从传统的云计算中心转移到物理设备的边缘节点上,以提高数据处理的效率和减少延迟。而MongoDB作为一种强大的NoSQL数据库,其在边缘计算领域的应用
MongoDB与边缘计算的结合实践与架构设计
2023-11-02

Java数据结构之KMP算法的实现

这篇文章主要为大家详细介绍了Java数据结构中KMP算法的原理与实现,文中的示例代码讲解详细,对我们学习Java有一定的帮助,需要的可以参考一下
2022-11-21

MongoDB与大数据技术栈的结合实践与架构设计

MongoDB是一款非关系型数据库,具有高可扩展性、高性能和灵活的数据模型等特点,在大数据领域有着广泛的应用。本文将介绍MongoDB与大数据技术栈的结合实践与架构设计。一、MongoDB在大数据技术栈中的地位和作用在大数据技术栈中,Mon
MongoDB与大数据技术栈的结合实践与架构设计
2023-11-02

设计与实现Golang中链表的数据结构

Golang中链表数据结构的设计与实现引言:链表是一种常见的数据结构,用于存储一系列的节点。每个节点包含数据和指向下一个节点的指针。在Golang中,我们可以通过使用结构体和指针来实现链表。链表的设计与结构定义在Golang中,我们可以
设计与实现Golang中链表的数据结构
2024-01-29

Java数据结构之KMP算法怎么实现

这篇文章主要讲解了“Java数据结构之KMP算法怎么实现”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Java数据结构之KMP算法怎么实现”吧!暴力匹配算法(Brute-Force,BF)这
2023-07-04

Python: 实现bitmap数据结构

http://my.oschina.net/goal/blog/200347 bitmap是很常用的数据结构,比如用于Bloom Filter中、用于无重复整数的排序等等。bitmap通常基于数组来实现,数组中每个元素可以看成是一系列二进制
2023-01-31

利用Golang实现高效的数据结构和算法

利用Golang实现高效的数据结构和算法随着信息时代的快速发展,数据结构和算法成为计算机科学领域中至关重要的部分。在实际应用中,高效的数据结构和算法能够极大地提升程序的执行效率和性能。而作为一种快速、高效且功能强大的编程语言,Golang
利用Golang实现高效的数据结构和算法
2024-02-28

Python数据结构与算法中的栈怎么实现

这篇文章主要介绍“Python数据结构与算法中的栈怎么实现”,在日常操作中,相信很多人在Python数据结构与算法中的栈怎么实现问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”Python数据结构与算法中的栈怎
2023-06-29

Java数据结构之AC自动机算法的实现

AC自动机算法常被认为是Trie树+KMP算法的结合体,它是一个多模式匹配算法,在模式匹配领域被广泛应用。本文将详细为大家介绍AC自动机的原理与实现方法,感兴趣的可以了解一下
2022-12-08

编程热搜

  • Android:VolumeShaper
    VolumeShaper(支持版本改一下,minsdkversion:26,android8.0(api26)进一步学习对声音的编辑,可以让音频的声音有变化的播放 VolumeShaper.Configuration的三个参数 durati
    Android:VolumeShaper
  • Android崩溃异常捕获方法
    开发中最让人头疼的是应用突然爆炸,然后跳回到桌面。而且我们常常不知道这种状况会何时出现,在应用调试阶段还好,还可以通过调试工具的日志查看错误出现在哪里。但平时使用的时候给你闹崩溃,那你就欲哭无泪了。 那么今天主要讲一下如何去捕捉系统出现的U
    Android崩溃异常捕获方法
  • android开发教程之获取power_profile.xml文件的方法(android运行时能耗值)
    系统的设置–>电池–>使用情况中,统计的能耗的使用情况也是以power_profile.xml的value作为基础参数的1、我的手机中power_profile.xml的内容: HTC t328w代码如下:
    android开发教程之获取power_profile.xml文件的方法(android运行时能耗值)
  • Android SQLite数据库基本操作方法
    程序的最主要的功能在于对数据进行操作,通过对数据进行操作来实现某个功能。而数据库就是很重要的一个方面的,Android中内置了小巧轻便,功能却很强的一个数据库–SQLite数据库。那么就来看一下在Android程序中怎么去操作SQLite数
    Android SQLite数据库基本操作方法
  • ubuntu21.04怎么创建桌面快捷图标?ubuntu软件放到桌面的技巧
    工作的时候为了方便直接打开编辑文件,一些常用的软件或者文件我们会放在桌面,但是在ubuntu20.04下直接直接拖拽文件到桌面根本没有效果,在进入桌面后发现软件列表中的软件只能收藏到面板,无法复制到桌面使用,不知道为什么会这样,似乎并不是很
    ubuntu21.04怎么创建桌面快捷图标?ubuntu软件放到桌面的技巧
  • android获取当前手机号示例程序
    代码如下: public String getLocalNumber() { TelephonyManager tManager =
    android获取当前手机号示例程序
  • Android音视频开发(三)TextureView
    简介 TextureView与SurfaceView类似,可用于显示视频或OpenGL场景。 与SurfaceView的区别 SurfaceView不能使用变换和缩放等操作,不能叠加(Overlay)两个SurfaceView。 Textu
    Android音视频开发(三)TextureView
  • android获取屏幕高度和宽度的实现方法
    本文实例讲述了android获取屏幕高度和宽度的实现方法。分享给大家供大家参考。具体分析如下: 我们需要获取Android手机或Pad的屏幕的物理尺寸,以便于界面的设计或是其他功能的实现。下面就介绍讲一讲如何获取屏幕的物理尺寸 下面的代码即
    android获取屏幕高度和宽度的实现方法
  • Android自定义popupwindow实例代码
    先来看看效果图:一、布局
  • Android第一次实验
    一、实验原理 1.1实验目标 编程实现用户名与密码的存储与调用。 1.2实验要求 设计用户登录界面、登录成功界面、用户注册界面,用户注册时,将其用户名、密码保存到SharedPreference中,登录时输入用户名、密码,读取SharedP
    Android第一次实验

目录