zsui2354 / zsui2354.blogforums Goto Github PK

View Code? Open in Web Editor NEW

0.0 0.0 0.0 714 KB

zsui2354.blogforums's Introduction

👋 Hi, I’m 王果冻
👀 This is my sharing artifact ...
🌱 Open source is my secret weapon ...
💞️ Open source for 5 minutes, brain-burning for two hours ...
📫 Don't tell anyone~ ...

About me：Link

My blog : https://zsui2354.github.io/

Contact email : [email protected]

X | Twitter : @aidegongjue1

✈️ Telegram : @Ajue5555

   .-') _  .-')                                                         
  (  OO) )( OO ).                                                       
,(_)----.(_)---\_),--. ,--.   ,-.-') .-----. .-----..------.    .---.   
|       |/    _ | |  | |  |   |  |OO/ ,-.   /  -.   |   ___|   / .  |   
'--.   / \  :` `. |  | | .-') |  |  '-'  |  '-' _'  |  '--.   / /|  |   
(_/   /   '..`''.)|  |_|( OO )|  |(_/  .'  /   |_  <`---.  './ / |  |_  
 /   /___.-._)   \|  | | `-' ,|  |_.'.'  /__.-.  |  .-   |  /  '-'    | 
|        \       ('  '-'(_.-(_|  |  |       \ `-'   | `-'   `----|  |-' 
`--------'`-----'  `-----'    `--'  `-------'`----'' `----''     `--'

zsui2354.blogforums's People

Watchers

zsui2354.blogforums's Issues

自律公约

每日任务：

每日一题：每天至少完成一道数据结构或算法题。可以从LeetCode、HackerRank、CodeSignal等平台选择题目。

学习笔记：完成题目后，写一篇简短的学习笔记，记录解题思路、遇到的困难及解决方法。

长期任务：

每月总结：每月末总结本月完成的题目，分析进步和需要改进的地方。

专项突破：每月选择一个数据结构或算法专题（如排序算法、图算法、动态规划等）进行深入学习，并至少完成相关的10道题目。

惩罚机制

每日惩罚：若未完成每日任务，逐次减少1小时娱乐时间，如达到2次以上失去所有娱乐时间，将任务完成即恢复。

每周惩罚：若未完成一周目标，周末取消一次休闲活动

Habitica

需要搭配 Habitica使用，设定自定义的任务

工具	地址
Habitica	https://habitica.com/

创建博客论坛

我自从不断的尝试去尝试各种的论坛服务，尝试了youdeyiwu 去构建，但还是没有github Issues 方便的多，自此以后就用这个了

我会在这里记录：

我的成长心路历程

修习心得

科学技术与编程

数据结构与算法

音频系统构建与处理

资源分享

定期更新，分享新的见解和发现.

Leetcode 罗马数字转整数

13.罗马数字转整数

解题思路：

1.首先既然是罗马转阿拉伯数字那就是接受参数无外乎是字符串的 'I','V','X','L','C','D','M'

2.然后将接受的字符串转换成字符数组

3.接下来很自然的用到 switch() ,将罗马数字按照依次判断，然后将对应的阿拉伯数组放在对应整形数组中

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。

4.IV是表示4 ，相当于 V 减去前面的 I，这样就可以转换阿拉伯数字后，按照这样运算就能求出正确结果，只需要判断 if(num[n] < num[n+1]) 如果成立，则需要减去 num[n] 的数，如果不成立则需要把 num[n] 加进sum

5.最后再累加整形数组中的最后一位元素,返回sum

class Solution {
    public int romanToInt(String s) {
        char[] chararray = new char[s.length()];
        int[] intarray = new int[s.length()];
        chararray = s.toCharArray();
        for (int i =0; i<s.length(); i++){
            switch (chararray[i]){
                case 'I': intarray[i] = 1;
                    break;
                case 'V': intarray[i] = 5;
                    break;
                case 'X': intarray[i] = 10;
                    break;
                case 'L': intarray[i] = 50;
                    break;
                case 'C': intarray[i] = 100;
                    break;
                case 'D': intarray[i] = 500;
                    break;
                case 'M': intarray[i] = 1000;
                    break;
            }
        }
        int sum = 0;
        for (int j=0; j<s.length()-1; j++){
            if (intarray[j]<intarray[j+1]){
                sum -= intarray[j];
            }else{
                sum += intarray[j];
            }
        }
        sum += intarray[s.length()-1];
        return sum;
    }
}

时间复杂度	空间复杂度
$O(n)$	$O(n)$

C++链表的操作实现

//
// Commit by zsui2354 on 2024/6/24.
//

#ifndef ALGO_CPP_LINKEDLIST_H
#define ALGO_CPP_LINKEDLIST_H

#include <iostream>

template<typename T>
struct ListNode {
    T value;
    ListNode* next;
    ListNode(T val): value(val), next(nullptr) {}
};

template<typename T>
class LinkedList {
private:
    ListNode<T>* head;
public:
    LinkedList(): head(nullptr) {}

    void        insert(T val, int position);

    void        move_node(int Index,int position);

    void        remove_Index_node(int position);

    void        remove_value_Allnode(T val);

    void        print_LinkedList() const;

    void        push_back(T val);

    void        push_front(T val);

    void        pop_back();

    void        pop_front();

    void        ChangeNode_value(T val,int position);

    void        reverse();

    bool        find_Generics(T val);

    int         Size();

    int         find_Index(T val);

    int         Rotate_linkedlists(int Index);

    int         Get_Intermediate_NodeIndex();

    T           Get_Intermediate_NodeValue();
    
                ~LinkedList();

};




template<typename T>
void LinkedList<T>::insert(T val, int position) {
    ListNode<T>* newNode = new ListNode<T>(val);
    if (position == 0) {
        newNode->next = head;
        head = newNode;
        return;
    }
    ListNode<T>* current = head;
    for (int i = 0; i < position - 1 && current != nullptr; ++i) {
        current = current->next;
    }
    if (current != nullptr) {
        newNode->next = current->next;
        current->next = newNode;
    }
}


template<typename T>
void LinkedList<T>::move_node(int Index, int position) {
    int counterIndex = Index;
    int counterPosition = position;
    ListNode<T>* currentIndex= head;
    ListNode<T>* currentPosition = head;
    ListNode<T>* prev_Index = nullptr;
    ListNode<T>* prev_Position = nullptr;
    if (Index == 0)
        head = head->next;
    for (int i = 0; i < counterIndex; ++i) {
        prev_Index = currentIndex;
        currentIndex = currentIndex ->next;

    }
    for (int i = 0; i < counterPosition; ++i) {
        prev_Position = currentPosition;
        currentPosition = currentPosition ->next;
    }
    prev_Index->next = currentIndex->next;
    currentIndex->next = currentPosition;
    prev_Position->next = currentIndex;
}


template<typename T>
void LinkedList<T>::remove_Index_node(int position) {
    if (head == nullptr) {
        return;
    }
    if (position == 0) {
        ListNode<T>* temp = head;
        head = head->next;
        delete temp;
    } else {
        ListNode<T>* prev = head;
        for (int i = 0; i < position - 1 && head->next != nullptr; ++i) {
            prev = prev->next;
        }
        if (prev->next != nullptr) {
            ListNode<T>* temp = prev->next;
            prev->next = temp->next;
            delete temp;
        }
    }
}


template<typename T>
void LinkedList<T>::remove_value_Allnode(T val) {
    while(head != nullptr && head->value == val){
        ListNode<T>* temp = head;
        head = head->next;
        delete temp;
    }
    ListNode<T>* current =head;
    while(current != nullptr && current->next != nullptr){
        if (current->next->value == val){
            ListNode<T>* temp = current->next;
            current->next = current->next->next;
            delete temp;
        }else{
            current = current->next;
        }
    }
}


template<typename T>
void LinkedList<T>::print_LinkedList() const {
    ListNode<T>* current = head;
    while (current != nullptr) {
        std::cout << current->value << ", ";
        current = current->next;
    }
    std::cout << std::endl;
}


template<typename T>
void LinkedList<T>::push_back(T val) {
    ListNode<T>* newNode = new ListNode<T>(val);
    if (head == nullptr) {
        head = newNode;
        return;
    }
    ListNode<T>* current = head;
    while (current->next != nullptr) {
        current = current->next;
    }
    current->next = newNode;
}

template<typename T>
void LinkedList<T>::push_front(T val) {
    ListNode<T>* newNode = new ListNode<T>(val);
    if (head == nullptr) {
        head = newNode;
        return;
    }
    newNode->next = head;
    head = newNode;
}

template<typename T>
void LinkedList<T>::pop_back() {
    if (head == nullptr) {
        return;
    } else if (head->next == nullptr) {
        delete head;
        head = nullptr;
        return;
    }
    if (head->next != nullptr) {
        ListNode<T>* current = head;
        while (current->next->next != nullptr) {
            current = current->next;
        }
        delete current->next;
        current->next = nullptr;
    }
}

template<typename T>
void LinkedList<T>::pop_front() {
    if (head == nullptr) {
        return;
    } else if (head->next == nullptr) {
        delete head;
        head = nullptr;
        return;
    }
    ListNode<T>* current = head->next;
    delete head;
    head = current;
}


template<typename T>
int LinkedList<T>::Size(){
    if (head == nullptr){
        return 0;
    }
    int counter=1;
    ListNode<T>* current = head;
    while(current->next != nullptr){
        current = current->next;
        counter++;
    }
    return counter;
}

template<typename T>
bool LinkedList<T>::find_Generics(T val) {
    ListNode<T>* current = head;
    while (current != nullptr) {
        if (current->value == val) {
            return true;
        }
        current = current->next;
    }
    return false;
}


template<typename T>
int LinkedList<T>::find_Index(T val) {
    int counter = 0;
    ListNode<T>* current = head;
    while(current->next != nullptr){
        if (current->value == val){
            return counter;
        }
        current = current->next;
        counter++;
    }
    return -1;
}


template<typename T>
void LinkedList<T>::ChangeNode_value(T val,int position) {
    ListNode<T>* current = head;
    int counter=0;
    while (counter < position){
        current = current->next;
        counter++;
    }
    current->value = val;
}


template<typename T>
int LinkedList<T>::Rotate_linkedlists(int Index) {
    int Counter;
    ListNode<T>* temp = head;
    ListNode<T>* current = head;
    ListNode<T>* back = head;
    while (back->next != nullptr){
        back = back->next;
    }
    while(current->next != nullptr){
        Counter++;
        current = current->next;
        if (Counter == Index){
            head = current->next;
            current->next = nullptr;
            back->next = temp;
        }
    }
    current ->next = nullptr;
    return -1;
}


template<typename T>
int LinkedList<T>::Get_Intermediate_NodeIndex() {
    int value = (int)Size()/2;
    return value;
}


template<typename T>
T LinkedList<T>::Get_Intermediate_NodeValue() {
    int value = (int)Size()/2;
    ListNode<T>* current = head;
    for (int i = 0; i < value; ++i) {
        current = current->next;
    }
    return current->value;
}



template<typename T>
void LinkedList<T>::reverse() {
    ListNode<T>* prev = nullptr;
    ListNode<T>* current = head;
    ListNode<T>* next = nullptr;
    while (current != nullptr) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    head = prev;
}


template<typename T>
LinkedList<T>::~LinkedList() {
    ListNode<T>* current = head;
    while (current) {
        ListNode<T>* temp = current;
        current = current->next;
        delete temp;
    }
    head = nullptr;
}


#endif //ALGO_CPP_LINKEDLIST_H

函数	传参	功能
insert	(T val, int position)	在索引Node前插入Node
remove_Index_node	(int position)	删除索引处Node
remove_value_Allnode	T val	根据给定的值删除Node
print_LinkedList		显示遍历Linked List所有Node
push_back	(T val)	在Linked List 尾部添加Node
push_front	(T val)	在Linked List 头部添加Node
pop_back		在Linked List 尾部删除Node
pop_front		在Linked List 头部删除Node
Size		返回LinkedList的长度
find_Generics	(T val)	查找val 是否存在于Linked List中
find_Index	(T val)	查找并返回Linked List中 val的索引下标
ChangeNode_value	(T val,int position)	改变Linked List中索引处的节点的value
move_node	(int Index,int position)	移动Linked List中Index节点到position位置
reverse		反转LinkedList
Get_Intermediate_NodeIndex		获取LinkedList的中间节点Index
Get_Intermediate_NodeValue		获取LinkedList的中间节点的Value
Rotate_linkedlists	(int Index)	将参数索引前N个节点移到LinkedList 末尾

今后会尝试玩更多的数据结构与算法的实现记录我的学习：仓库地址

Leetcode 搜索插入位置

35. 搜索插入位置

解题思路：

1.函数传入 2个参数，一个是vector容器以引用传递，一个是target目标值

2.用for循环遍历容器去判断当前循环的nums[i] 是否 == target ,成立则返回其索引，反之则判断 target < nums[i] 如成立则插入到 nums.begin{} + i 处的索引，并返回索引数值

3.循环外是末尾添加的情况，在nums数组末尾添加target，并返回最后数组的下标

class Solution {
public:
    int searchInsert(vector<int> &nums, int target) {
        for (int i = 0
                ; i < nums.size()
                ; ++i) {
            if (nums[i] == target) {
                return i;
            } else if (target < nums[i]) {
                nums.insert(nums.begin() + i, target);
                return i;
            }
        }
        nums.push_back(target);
        return nums.size() - 1;
    }
    
};

时间复杂度	空间复杂度
$O(n)$	$O(1)$

计算器小案例

之前做JAVA图形界面的一个小案例

/***
 *  author: zsui2354
 *  date  : 2024.5.9
*/
package Calculator;

import org.w3c.dom.Text;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;

public class Calculator extends JFrame {




     /*标签*/   JLabel Display1;
    /**
     * 设计按钮
     */
     /*按钮*/   JButton number1,number2,number3,number4,number5,number6,number7,number8,number9,number0
            , Add               //加
            , Subtract          //减
            , Multiplication    //乘
            , Division          //除
            , Delete            //删除
            , Clear             //清除
            , Submit            //提交
            ;

     /*文框*/    JTextField
                real_timeText = new JTextField(5),
                output = new JTextField(0);

     /*容器*/     JPanel
                 Fixed_layout = new JPanel(),           //窗口内底层容器
                 Text_container = new JPanel(),         //北部 文本框容器
                 Text_container2 = new JPanel(),        //南部 文本框容器
                 Button_container = new JPanel(),       //按钮容器
                 ButtonLine1_container = new JPanel(),   //按钮行列1
                 ButtonLine2_container = new JPanel(),   //按钮行列2
                 ButtonLine3_container = new JPanel(),   //按钮行列3
                 ButtonLine4_container = new JPanel();   //按钮行列3


              //   ScriptEngine engine; //脚本引擎


                 String[] Ssuanshi_save = new String[100];

    FlowLayout fl = new FlowLayout();       //流式布局
    BorderLayout Bl = new BorderLayout();   //四周布局

    Calculator(){


//        ScriptEngineManager manager = new ScriptEngineManager();
//        engine = manager.getEngineByName("JavaScript");


        Display1 = new JLabel("计算后的结果：");

        number1= new JButton("1")
        ; number2= new JButton("2")
        ; number3= new JButton("3")
        ; number4= new JButton("4")
        ; number5= new JButton("5")
        ; number6= new JButton("6")
        ; number7= new JButton("7")
        ; number8= new JButton("8")
        ; number9= new JButton("9")
        ; number0= new JButton("0")
        ; Add = new JButton("+")
        ; Subtract = new JButton("-")
        ; Multiplication = new JButton("*")
        ; Division = new JButton("/")
        ; Delete = new JButton("<-")
        ; Clear = new JButton("C")
        ; Submit = new JButton("计算")
        ;


        Font buttonFont = new Font("宋体", Font.PLAIN, 21);   //批量设置按钮字体和大小
        number1.setFont(buttonFont);
        number2.setFont(buttonFont);
        number3.setFont(buttonFont);
        number4.setFont(buttonFont);
        number5.setFont(buttonFont);
        number6.setFont(buttonFont);
        number7.setFont(buttonFont);
        number8.setFont(buttonFont);
        number9.setFont(buttonFont);
        number0.setFont(buttonFont);
        Add.setFont(buttonFont);
        Subtract.setFont(buttonFont);
        Multiplication.setFont(buttonFont);
        Division.setFont(buttonFont);
        Delete.setFont(buttonFont);
        Clear.setFont(buttonFont);
        Submit.setFont(buttonFont);

        Font textFont = new Font("宋体", Font.PLAIN, 27);
        real_timeText.setFont(textFont);
        output.setFont(textFont);

        number1.setPreferredSize(new Dimension(50, 50));    //批量设置按钮 尺寸
        number2.setPreferredSize(new Dimension(50, 50));
        number3.setPreferredSize(new Dimension(50, 50));
        number4.setPreferredSize(new Dimension(50, 50));
        number5.setPreferredSize(new Dimension(50, 50));
        number6.setPreferredSize(new Dimension(50, 50));
        number7.setPreferredSize(new Dimension(50, 50));
        number8.setPreferredSize(new Dimension(50, 50));
        number9.setPreferredSize(new Dimension(50, 50));
        number0.setPreferredSize(new Dimension(50, 50));
        Add.setPreferredSize(new Dimension(50, 50));
        Subtract.setPreferredSize(new Dimension(50, 50));
        Multiplication.setPreferredSize(new Dimension(50, 50));
        Division.setPreferredSize(new Dimension(50, 50));
        Delete.setPreferredSize(new Dimension(50, 50));
        Clear.setPreferredSize(new Dimension(50, 50));


        ButtonListener listener = new ButtonListener();// 批量监听按钮
        number1.addActionListener(listener);
        number2.addActionListener(listener);
        number3.addActionListener(listener);
        number4.addActionListener(listener);
        number5.addActionListener(listener);
        number6.addActionListener(listener);
        number7.addActionListener(listener);
        number8.addActionListener(listener);
        number9.addActionListener(listener);
        number0.addActionListener(listener);
        Add.addActionListener(listener);
        Subtract.addActionListener(listener);
        Multiplication.addActionListener(listener);
        Division.addActionListener(listener);
        Delete.addActionListener(listener);
        Clear.addActionListener(listener);
        Submit.addActionListener(listener);



        super.setLayout(Bl);
        super.add(Fixed_layout); //底层四周布局
        Fixed_layout.add(Text_container, BorderLayout.NORTH);

        Text_container.setLayout(new BorderLayout());               //将Text_container 定为 四周布局
        Text_container.add(real_timeText, BorderLayout.CENTER);     //将real_timeText 添加进Text_container 中心
        super.add(Text_container, BorderLayout.NORTH);              // 添加到窗口的上半部分
        real_timeText.setPreferredSize(new Dimension(0, 50));   //设置文本框的宽高

        /**
         * 由于 现代计算器的UI排版我想尽可能的贴近 ，我想用四周型布局，其实是不熟悉网格布局，先用这个凑合凑合得了  :)
         */ Button_container.setLayout(new BorderLayout());            //Button_container 定为 四周布局
            super.add(Button_container, BorderLayout.CENTER);          //将Button_container 放置 中心
            ButtonLine1_container.setLayout(new FlowLayout());         //将按钮行列 设置 流式布局
            ButtonLine2_container.setLayout(new FlowLayout());
            ButtonLine3_container.setLayout(new FlowLayout());


        ButtonLine1_container.add(number1);
        ButtonLine1_container.add(number2);
        ButtonLine1_container.add(number3);
        ButtonLine1_container.add(number4);
        ButtonLine1_container.add(number5);
            Button_container.add(ButtonLine1_container, BorderLayout.NORTH); //将 ButtonLine1_container 放置 Button_container 北
        ButtonLine2_container.add(number6);
        ButtonLine2_container.add(number7);
        ButtonLine2_container.add(number8);
        ButtonLine2_container.add(number9);
        ButtonLine2_container.add(number0);
            Button_container.add(ButtonLine2_container, BorderLayout.CENTER); //将 ButtonLine2_container 放置 Button_container 中心
        ButtonLine3_container.add(Clear);
        ButtonLine3_container.add(Division);
        ButtonLine3_container.add(Multiplication);
        ButtonLine3_container.add(Subtract);
        ButtonLine3_container.add(Add);
            Button_container.add(ButtonLine3_container, BorderLayout.SOUTH); //将 ButtonLine3_container 放置 Button_container 南

        Text_container2.setLayout(new BorderLayout());              //将Text_container2 定为 四周布局
        Text_container2.add(output, BorderLayout.CENTER);           //将output 添加进Text_container2 中心
        //Text_container2.add(Display1, BorderLayout.NORTH);        //将 Display1 添加进Text_container 北
        Text_container2.add(Submit, BorderLayout.NORTH);            //将计算 按钮添加至 Text_container 北，它其实将 Display1 覆盖住了
        super.add(Text_container2, BorderLayout.SOUTH);             // 添加到窗口的下半部分
        output.setPreferredSize(new Dimension(0, 50));   //设置 计算结果 文本框的宽高

        //real_timeText.setEditable(false); 我觉得这里其实可以让 用户编辑 用户也可以用键盘控制计算，而不局限于按键


        output.setEditable(false);  //禁止编辑计算结果
        super.setTitle("王果冻的小计算器");
        super.setBounds(100,100,350,353);
        super.setVisible(true);
        super.setResizable(false);  //禁用窗口大小的随意调整


    }
    class ButtonListener implements ActionListener { //监听
        public void actionPerformed(ActionEvent e) {
            String command = e.getActionCommand();


            switch (command) {
                case "1":
                    String Text = real_timeText.getText();
                    String newText = Text + "1";
                    real_timeText.setText(newText);
                    break;
                case "2":
                    String Text1 = real_timeText.getText();
                    String newText1 = Text1 + "2";
                    real_timeText.setText(newText1);
                    break;
                case "3":
                    String Text3 = real_timeText.getText();
                    String newText3 = Text3 + "3";
                    real_timeText.setText(newText3);
                    break;
                case "4":
                    String Text4 = real_timeText.getText();
                    String newText4 = Text4 + "4";
                    real_timeText.setText(newText4);
                    break;
                case "5":
                    String Text5 = real_timeText.getText();
                    String newText5 = Text5 + "5";
                    real_timeText.setText(newText5);
                    break;
                case "6":
                    String Text6 = real_timeText.getText();
                    String newText6 = Text6 + "6";
                    real_timeText.setText(newText6);
                    break;
                case "7":
                    String Text7 = real_timeText.getText();
                    String newText7 = Text7 + "7";
                    real_timeText.setText(newText7);
                    break;
                case "8":
                    String Text8 = real_timeText.getText();
                    String newText8 = Text8 + "8";
                    real_timeText.setText(newText8);
                    break;
                case "9":
                    String Text9 = real_timeText.getText();
                    String newText9 = Text9 + "9";
                    real_timeText.setText(newText9);
                    break;
                case "0":
                    String Text0 = real_timeText.getText();
                    String newText0 = Text0 + "0";
                    real_timeText.setText(newText0);
                    break;
                case "+":
                    String Text10 = real_timeText.getText();
                    String newText10 = Text10 + "+";
                    real_timeText.setText(newText10);
                    break;
                case "-":
                    String Text11 = real_timeText.getText();
                    String newText11 = Text11 + "-";
                    real_timeText.setText(newText11);
                    break;
                case "/":
                    String Text12 = real_timeText.getText();
                    String newText12 = Text12 + "/";
                    real_timeText.setText(newText12);
                    break;
                case "*":
                    String Text13 = real_timeText.getText();
                    String newText13 = Text13 + "*";
                    real_timeText.setText(newText13);
                    break;
                case "计算":
                    String Text14 = real_timeText.getText();
                    Ssuanshi_save = (new String[Text14.length()]);
                    for (int i=0; i<Ssuanshi_save.length; i++){
                        Ssuanshi_save[i] = String.valueOf(Text14.charAt(i));
                    }
                    for (int i=0; i<Ssuanshi_save.length; i++){

                        /***
                         * 试验性废弃代码
                         */
//                        if (Ssuanshi_save[i].equals("*")){
//                            String str1 = "";
//                            for (int BL_1 = i; BL_1 > 0; BL_1--) {
//                                str1 = String.valueOf(Ssuanshi_save[BL_1 - 1]) + str1; // 使用 + 运算符进行字符串拼接
//                            }
//                            String str2 = "";
//                            for (int BL_2 = i; BL_2 > 0; BL_2--) {
//                                str2 = String.valueOf(Ssuanshi_save[BL_2 - 1]) + str2; // 使用 + 运算符进行字符串拼接
//                            }


                        if (Ssuanshi_save[i].equals("*")) {
                            // 从当前位置向左获取第一个数
                            StringBuilder str1Builder = new StringBuilder();
                            for (int BL_1 = i - 1; BL_1 >= 0; BL_1--) {
                                if (Ssuanshi_save[BL_1].matches("[0-9.]")) {
                                    str1Builder.insert(0, Ssuanshi_save[BL_1]); // 使用 insert 方法在前面插入字符
                                } else {
                                    break; // 遇到非数字字符，结束循环
                                }
                            }
                            String str1 = str1Builder.toString();

                            // 从当前位置向右获取第二个数字
                            StringBuilder str2Builder = new StringBuilder();
                            for (int BL_2 = i + 1; BL_2 < Ssuanshi_save.length; BL_2++) {
                                if (Ssuanshi_save[BL_2].matches("[0-9.]")) {
                                    str2Builder.append(Ssuanshi_save[BL_2]); // 使用 append 方法在后面追加字符
                                } else {
                                    break; // 遇到非数字字符，结束循环
                                }
                            }
                            String str2 = str2Builder.toString();
                            double operand1 = Double.parseDouble(str1);
                            double operand2 = Double.parseDouble(str2);
                            String out = String.valueOf(operand1 * operand2);//计算
                           output.setText(out);
                        }else if(Ssuanshi_save[i].equals("/")){
                            // 从当前位置向左获取第一个数
                            StringBuilder str1Builder = new StringBuilder();
                            for (int BL_1 = i - 1; BL_1 >= 0; BL_1--) {
                                if (Ssuanshi_save[BL_1].matches("[0-9.]")) {
                                    str1Builder.insert(0, Ssuanshi_save[BL_1]); // 使用 insert 方法在前面插入字符
                                } else {
                                    break; // 遇到非数字字符，结束循环
                                }
                            }
                            String str1 = str1Builder.toString();

                            // 从当前位置向右获取第二个数字
                            StringBuilder str2Builder = new StringBuilder();
                            for (int BL_2 = i + 1; BL_2 < Ssuanshi_save.length; BL_2++) {
                                if (Ssuanshi_save[BL_2].matches("[0-9.]")) {
                                    str2Builder.append(Ssuanshi_save[BL_2]); // 使用 append 方法在后面追加字符
                                } else {
                                    break; // 遇到非数字字符，结束循环
                                }
                            }
                            String str2 = str2Builder.toString();
                            double operand1 = Double.parseDouble(str1);
                            double operand2 = Double.parseDouble(str2);
                            String out = String.valueOf(operand1 / operand2);//计算
                            output.setText(out);
                        }else if(Ssuanshi_save[i].equals("+")){
                            // 从当前位置向左获取第一个数
                            StringBuilder str1Builder = new StringBuilder();
                            for (int BL_1 = i - 1; BL_1 >= 0; BL_1--) {
                                if (Ssuanshi_save[BL_1].matches("[0-9.]")) {
                                    str1Builder.insert(0, Ssuanshi_save[BL_1]); // 使用 insert 方法在前面插入字符
                                } else {
                                    break; // 遇到非数字字符，结束循环
                                }
                            }
                            String str1 = str1Builder.toString();

                            // 从当前位置向右获取第二个数字
                            StringBuilder str2Builder = new StringBuilder();
                            for (int BL_2 = i + 1; BL_2 < Ssuanshi_save.length; BL_2++) {
                                if (Ssuanshi_save[BL_2].matches("[0-9.]")) {
                                    str2Builder.append(Ssuanshi_save[BL_2]); // 使用 append 方法在后面追加字符
                                } else {
                                    break; // 遇到非数字字符，结束循环
                                }
                            }
                            String str2 = str2Builder.toString();
                            double operand1 = Double.parseDouble(str1);
                            double operand2 = Double.parseDouble(str2);
                            String out = String.valueOf(operand1 + operand2);//计算
                            output.setText(out);
                        }else if(Ssuanshi_save[i].equals("-")){
                            // 从当前位置向左获取第一个数
                            StringBuilder str1Builder = new StringBuilder();
                            for (int BL_1 = i - 1; BL_1 >= 0; BL_1--) {
                                if (Ssuanshi_save[BL_1].matches("[0-9.]")) {
                                    str1Builder.insert(0, Ssuanshi_save[BL_1]); // 使用 insert 方法在前面插入字符
                                } else {
                                    break; // 遇到非数字字符，结束循环
                                }
                            }
                            String str1 = str1Builder.toString();

                            // 从当前位置向右获取第二个数字
                            StringBuilder str2Builder = new StringBuilder();
                            for (int BL_2 = i + 1; BL_2 < Ssuanshi_save.length; BL_2++) {
                                if (Ssuanshi_save[BL_2].matches("[0-9.]")) {
                                    str2Builder.append(Ssuanshi_save[BL_2]); // 使用 append 方法在后面追加字符
                                } else {
                                    break; // 遇到非数字字符，结束循环
                                }
                            }
                            String str2 = str2Builder.toString();
                            double operand1 = Double.parseDouble(str1);
                            double operand2 = Double.parseDouble(str2);
                            String out = String.valueOf(operand1 - operand2);//计算
                            output.setText(out);
                        }

                    }
                    break;
                case "C":   //这里的C代表清除  是Clear的首字母
                    real_timeText.setText("");
                    output.setText("");
                    break;


            }
        }
    }

    /***
     * 本来想用下面 Script engine 这个 calculateExpression 处理计算 ，发现用时空指针， 可能是初始化 或 环境不完整 ，而引起的 空指针异常
     * 感到有点 烦躁 ，我弃用了它，将其注释
     * author：王果冻
     */
//    public double calculateExpression(String expression) throws ScriptException {
//        return (double) engine.eval(expression);
//    }

    public static void main(String[] args) {
        Calculator OBJ = new Calculator();
    }

}

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.

zsui2354 / zsui2354.blogforums Goto Github PK

zsui2354.blogforums's Introduction

About me：Link

My blog : https://zsui2354.github.io/

Contact email : [email protected]

X | Twitter : @aidegongjue1

✈️ Telegram : @Ajue5555

zsui2354.blogforums's People

Watchers

zsui2354.blogforums's Issues

自律公约

每日任务：

长期任务：

惩罚机制

Habitica

创建博客论坛

我自从不断的尝试去尝试各种的论坛服务，尝试了youdeyiwu 去构建，但还是没有github Issues 方便的多，自此以后就用这个了

13.罗马数字转整数

解题思路：

C++链表的操作实现

今后会尝试玩更多的数据结构与算法的实现记录我的学习： 仓库地址

35. 搜索插入位置

解题思路：

计算器小案例

之前做JAVA图形界面的一个小案例

Recommend Projects

Recommend Topics

Recommend Org

今后会尝试玩更多的数据结构与算法的实现记录我的学习：仓库地址