第一次作业

功能流程图
 

 

#include<stdio.h>
#include<math.h>
double kaifang(int a)
{
if(a<0){
printf("负数无法开方");
return 65535.0f;
}
double x=1.0f,y=0.0f,k=0.0f;
y=x*x-a;
while(abs(y)>=0.001f){
k=2*x;
x=x-(y*1.0f)/k;
y=x*x-a;
}
return x;
 } 
 
 
 
 int main(){
  printf("请输入一个非负整数");
  int a=0;
  scanf("%d",&a);
  double c=kaifang(a);
  if(c==65535.0f){
  printf("输入有误"); 
 }
 else{
 printf("a的算数平方根是%f和-%f",c,c);
 }
 return 0;
 }

牛顿迭代法

//牛顿迭代法计算开方
    //牛顿迭代法算开方
    public  double sequareRoot (double n) {
        if(n < 0) {
            return Double.NaN;
        }else {
            double err = 1e-15;
            double root = n;
            while(Math.abs(n - root * root) > err) {
                root = (n/root + root) / 2;
            }
            return root;
        }
    }

#include <stdio.h>

#include <math.h>

// 牛顿迭代法计算平方根

  double sqrt_newton(double x) {

  double guess = x / 2.0; // 初始猜测值为x的一半

  double delta = 0.000001; // 误差范围

 

  while (fabs(guess * guess - x) > delta)

 {

   guess = (guess + x / guess) / 2.0; // 更新猜测值

 }

 

return guess;

}

 

int main() {

int choice;

double num1, num2;

 

  printf("选择操作：\n");

  printf("1. 加法\n");

  printf("2. 减法\n");

  printf("3. 乘法\n");

  printf("4. 除法\n");

printf("5. 算术开方\n");

printf("请选择：");

scanf("%d", &choice);

 

switch (choice) {

case 1:

printf("请输入两个数字：");

scanf("%lf %lf", &num1, &num2);

printf("结果：%lf\n", num1 + num2);

break;

case 2:

printf("请输入两个数字：");

scanf("%lf %lf", &num1, &num2);

printf("结果：%lf\n", num1 - num2);

break;

case 3:

printf("请输入两个数字：");

scanf("%lf %lf", &num1, &num2);

printf("结果：%lf\n", num1 * num2);

break;

case 4:

printf("请输入两个数字：");

scanf("%lf %lf", &num1, &num2);

if (num2 != 0) {

printf("结果：%lf\n", num1 / num2);

} else {

printf("除数不能为0！\n");

}

break;

case 5:

printf("请输入一个数字：");

scanf("%lf", &num1);

if (num1 >= 0) {

printf("结果：%lf\n", sqrt_newton(num1));

} else {

printf("输入的数字不能小于0！\n");

}

    break;

    default:

printf("无效的选择！\n");

}

 

return 0;

}

public String Result(String[] suffix)

    {

         double label=0;

        Stack<String> Result = new Stack<String>();

        for(int i = 0;i < suffix.length; i++) {

                 if ("1234567890.".indexOf(suffix[i].charAt(0))>=0)

                Result.push(suffix[i]);

            else

            {   
double n = 0;

                if (suffix[i].equals("√"))

                {

                    double z = 0;

                    if(Double.parseDouble(Result.peek())>=0)

                    {

                        z = Double.parseDouble(Result.pop());

                        n = sequareRoot(z);

                    }

                    else label = 1;

                }

                else if (suffix[i].equals("-"))

                {　　                    if (i + 1 < suffix.length)

                    {　  　　　　　　　　　　　　　　 
                        if (Result.size()  == 1 || (Result.size() %2 == 0 && ("+-*/".contains(suffix[i + 1]))))

                        {

                            double q = 0;

                            q = Double.parseDouble(Result.pop());

                            n = -q;

                        }//否则 则判断为减号，弹出栈顶两个数相减

                        else

                        {

                            double a = 0, b = 0;

                            a = Double.parseDouble(Result.pop());

                            b = Double.parseDouble(Result.pop());

                            n = b - a;

                        }

                    }//i+1超出数组长度说明当前“-”为最后一个运算符

                    else

                    {

                        if (Result.size() == 1 )

                        {

                            double q = 0;

                            q = Double.parseDouble(Result.pop());

                            n = -q;

                            System.out.println(n);

                        }

                        else {

                            double a = 0, b = 0;

                            a = Double.parseDouble(Result.pop());

                            b = Double.parseDouble(Result.pop());

                            n = b - a;

                        }

                    }

                }//判断为一般运算符 则弹出栈顶两个数字进行双目运算

                else

                {

                    double x, y = 0;

                    x = Double.parseDouble(Result.pop());

                    y = Double.parseDouble(Result.pop());

                    switch (suffix[i]) {

                        case "+":

                            n = x + y;

                            break;

                        case "*":

                            n = x * y;

                            break;

                        case "/":

                            if (x == 0) {                                
label = 1;

                            }

                            n = y / x;

                            break;

                    }

                }

                Result.push(String.valueOf(n));

            }

        }　 

        if(label == 1)

            return "ERROR!";

        return (Result.peek());//返回栈顶的最终结果

    }
 

//UI设计

class Calculator1 extends JFrame implements ActionListener {

    private JPanel jp_north = new JPanel();

    //JPanel是java图形用户界面GUI工具包swing中的面板容器类，包含在javax.swing包中，可以进行嵌套，功能是对窗体中具有相同逻辑功能组件进行组合

    private JTextField resultText = new JTextField("0"); //创建一个输入框

    private JPanel jp_center = new JPanel();

    private String input = "";



    public Calculator1()  throws HeadlessException{

        this.init();

        this.addNorthComponent();

        this.addCenterComponent();

    }

    //建立计算器界面布局

    public void init() {

        this.setTitle("计算器");//界面名称

        this.setSize(800,800);//界面大小

        this.setLayout(new BorderLayout());//建立布局

        this.setResizable(false); //计算器界面被拉伸

        this.setDefaultCloseOperation(EXIT_ON_CLOSE);//使用system exit方法退出应用程序

    }



    //向顶层容器添加组件

    public void addNorthComponent()

    {

        this.resultText.setPreferredSize(new Dimension(700,150));

        resultText.setHorizontalAlignment(JTextField.RIGHT);;//文本框内容右对齐

        resultText.setEditable(false);//文本框不允许修改结果

        resultText.setFont(new Font("隶书",Font.PLAIN,36));

        jp_north.add(resultText);

        this.add(jp_north,BorderLayout.NORTH);//把顶层界面添加到整体布局的上层

    }



    //向中间层容器添加组件

    public void addCenterComponent()

    {

        String btn_next = "C()/789*456-123+√0.=";//存储中间按钮的所有字符



        this.jp_center.setLayout(new GridLayout(5,4,3,3));//设置中间按钮的行列（5行4列的网格布局）

        this.add(jp_center,BorderLayout.CENTER);//中层布局添加到整体布局的中层

        this.setVisible(true);

         String regex = "[\\+\\-\\*\\/\\√\\(\\)\\.\\=C]";

        for(int i = 0;i < 20;i++)

        {

            String temp = btn_next.substring(i,i+1);

            JButton btn = new JButton();

            btn.setFont(new Font("宋体",Font.BOLD,30));

            btn.addActionListener(this);//每个按钮都注册事件监听器

            btn.setText(temp);

            btn.setBackground(Color.PINK);

            jp_center.add(btn);

            if(temp.matches(regex)) {

               btn.setFont(new Font("粗体",Font.BOLD,30));

               btn.setForeground(Color.RED);

            }

        }

    }
 void input_expression(char* expression, int size) {
char c;
int index = 0;

gotoxy(12, 7);

while (1) {
c = _getch(); // 逐字符读取输入

if (c == '\r' || c == '\n') { // 回车或换行表示输入结束
expression[index] = '\0';
break;
}
else if (c == '\b' && index > 0) { // 处理退格
index--;
gotoxy(25 + index, 7);
printf(" ");
gotoxy(25 + index, 7);
}
else if (isprint(c) && index < size - 1) { // 只接受可打印字符
expression[index++] = c;
printf("%c", c);
}
}
}

void zhuanhuan(char g[], char e[]) {
int i, j;
for (i = 0, j = 0; g[i] != '\0'; i++) {
if (g[i] == '-' && (i == 0 || g[i - 1] == '(')) {
e[j++] = '0';

e[j++] = g[i];
}
e[j] = '\0';
}
int is_operation(char op) {
if (op == '+' || op == '-' || op == '*' || op == '/') {
return 1;
}
return 0;
}

int priority(char op) {
if (op == '+' || op == '-') {
return 1;
}
else if (op == '*' || op == '/') {
return 2;
}
return 0;
}

void postfix(char e[], char f[]) {
int i, j, k;
char stack[100];
int top = -1;

for (i = 0, j = 0; e[i] != '\0'; i++) {
if (isdigit(e[i]) || e[i] == '.') {
f[j++] = e[i];
if (!isdigit(e[i + 1]) && e[i + 1] != '.') {
f[j++] = ' ';
}
}
else if (e[i] == '(') {
stack[++top] = e[i];
}
else if (is_operation(e[i])) {
while (top >= 0 && priority(stack[top]) >= priority(e[i])) {
f[j++] = stack[top--];
}
stack[++top] = e[i];
}
else if (e[i] == ')') {
while (top >= 0 && stack[top] != '(') {
f[j++] = stack[top--];
}
top--; // Pop the left parenthesis
}
}

while (top >= 0) {
f[j++] = stack[top--];
}
f[j] = '\0';
}
double readnum(char f[], int* i) {
double num = 0.0;
double decimal = 0.1;
int is_decimal = 0;

while (isdigit(f[*i]) || f[*i] == '.') {
if (f[*i] == '.') {
is_decimal = 1;
}
else {
if (is_decimal) {
num += (f[*i] - '0') * decimal;
decimal *= 0.1;
}
else {
num = num * 10 + (f[*i] - '0');
}
}
(*i)++;
}
return num;
}
double evalpost(char f[]) {
double stack[100];
int top = -1;
double num1, num2;

for (int i = 0; f[i] != '\0'; i++) {
if (isdigit(f[i]) || f[i] == '.') {
stack[++top] = readnum(f, &i);
}
else if (f[i] == ' ') {
continue;
}
else if (is_operation(f[i])) {
num2 = stack[top--];
num1 = stack[top--];

switch (f[i]) {
case '+':
stack[++top] = num1 + num2;
break;
case '-':
stack[++top] = num1 - num2;

break;
case '*':
stack[++top] = num1 * num2;
break;
case '/':
stack[++top] = num1 / num2;
break;
}
}
}
return stack[top];
}

int is_valid_expression(const char* expression) {
int parentheses_count = 0;
int last_char_is_operator = 0;

for (int i = 0; expression[i] != '\0'; i++) {
if (isdigit(expression[i]) || expression[i] == '.') {
last_char_is_operator = 0;
}
else if (is_operation(expression[i])) {
if (last_char_is_operator) {
return 0;
}
last_char_is_operator = 1;
}
else if (expression[i] == '(') {
parentheses_count++;
last_char_is_operator = 0;
}
else if (expression[i] == ')') {
parentheses_count--;
if (parentheses_count < 0) {
return 0;
}
last_char_is_operator = 0;
}
else {
return 0;
}
}

if (parentheses_count != 0) {
return 0;
}

return 1;
}

void display_ending() {
system("cls");
printf("##########################\n");
printf("# #\n");
printf("# 谢谢使用 #\n");
printf("# #\n");
printf("##########################\n");
}

int main() {
char input_expr[100]; // 用于存储用户输入的表达式
char processed_expression[100]; // 用于存储处理后的表达式（去除空格等）
char postfix_expression[100]; // 用于存储后缀表达式
double result; // 用于存储计算结果
int continue_calculating = 1; // 标志位，用于判断是否继续计算
int user_choice; // 用户选择：继续计算或退出

display_calculator(); // 显示计算器界面

while (continue_calculating) {
input_expression(input_expr, sizeof(input_expr));

if (!is_valid_expression(input_expr)) {
gotoxy(12, 7);
printf("输入不合法，请按回车重新输入\n");
while (getchar() != '\n'); // 等待用户按回车
display_calculator(); // 显示新的计算器界面
continue; // 跳过本次循环的剩余部分
}

zhuanhuan(input_expr, processed_expression);
postfix(processed_expression, postfix_expression);
result = evalpost(postfix_expression);
gotoxy(12 + strlen(input_expr) + 1, 7);
printf(" = %.2f\n", result);

gotoxy(50, 15);
printf("继续计算/退出:1/0: ");
scanf("%d", &user_choice);
while (getchar() != '\n'); // 清空输入缓冲区，防止干扰下次输入

if (user_choice == 0) {
continue_calculating = 0;
}
else {
// 清除输入表达式行
gotoxy(12, 7);
for (int i = 0; i < strlen(input_expr) + 100; i++) {
printf(" ");
}

gotoxy(12, 7);
}
}

display_ending();
system("pause");
return 0;
}