平方根

最新推荐文章于 2024-08-19 09:52:29 发布
最新推荐文章于 2024-08-19 09:52:29 发布
阅读量1.3k 收藏
点赞数
分类专栏： 信息学奥赛


任意数的平方根.

1的平方根是1

2的平方根是1.4


C++：

/*          Code written by Sanchit Karve
                  A.K.A born2c0de
                  Contact Me at born2c0de AT hotmail.com

                  20 August, 2005

*/
From: http://www.dreamincode.net/code/snippet244.htm


#include <iostream>
#include <math.h>

using namespace std;

float sqroot(float m)
{
     float i=0;
     float x1,x2;
     while( (i*i) <= m )
               i+=0.1;
     x1=i;
     for(int j=0;j<10;j++)
     {
          x2=m;
          x2/=x1;
          x2+=x1;
          x2/=2;
          x1=x2;
     }
     return x2;
}

int main()
{
   cout<<"Enter a Number:";
   int no;
   cin>>no;
   cout<<"Square Root using sqroot()= "<<sqroot(no)<<endl
       <<"Square Root using sqrt()  = "<<sqrt(no);

   return 0;
}



Java:

1.古人算法（暴力法）  

原理：从0开始0.00001,000002...一个一个试，直到找到x的平方根，代码如下：

[java]  view plain  copy
  1. public class APIsqrt {  
  2.   
  3.     static double baoliSqrt(double x) {  
  4.   
  5.         final double _JINGDU = 1e-6;  
  6.         double i;  
  7.         for (i = 0; Math.abs(x - i * i) > _JINGDU; i += _JINGDU)  
  8.             ;  
  9.         return i;  
  10.     }  
  11.   
  12.     public static void main(String[] args) {  
  13.         double x = 3;  
  14.         double root = baoliSqrt(x);  
  15.         System.out.println(root);  
  16.     }  
  17. }  

测试结果：

1.7320509999476947

2.牛顿迭代法

计算机科班出身的童鞋可能首先会想到的是《数值分析》中的牛顿迭代法求平方根。原理是：随意选一个数比如说8，要求根号3，我们可以这么算：

(8 + 3/8) = 4.1875

(4.1875 + 3/4.1875) = 2.4519

(2.4519 + 3/2.4519) = 1.837

(1.837 + 3/1.837) = 1.735

做了4步基本算出了近似值了，这种迭代的方式就是传说中的牛顿迭代法了，代码如下：

[java]  view plain  copy
  1. public class APIsqrt {  
  2.   
  3.     static double newtonSqrt(double x) {  
  4.   
  5.         if (x < 0) {  
  6.             System.out.println("负数没事开什么方");  
  7.             return -1;  
  8.         }  
  9.         if (x == 0)  
  10.             return 0;  
  11.   
  12.         double _avg = x;  
  13.         double last_avg = Double.MAX_VALUE;  
  14.         final double _JINGDU = 1e-6;  
  15.   
  16.         while (Math.abs(_avg - last_avg) > _JINGDU) {  
  17.             last_avg = _avg;  
  18.             _avg = (_avg + x / _avg) / 2;  
  19.         }  
  20.         return _avg;  
  21.     }  
  22.   
  23.     public static void main(String[] args) {  
  24.         double x = 3;  
  25.         double root = newtonSqrt(x);  
  26.         System.out.println(root);  
  27.     }  
  28. }  

测试结果：

1.7320508075688772


3.暴力-牛顿综合法

原理：还是以根号3为例，先用暴力法讲根号3逼近到1.7，然后再利用上述的牛顿迭代法。虽然没有用牛顿迭代好，但是也为我们提供一种思路。代码如下：

[java]  view plain  copy
  1. public class APIsqrt {  
  2.   
  3.     static double baoliAndNewTonSqrt(double x) {  
  4.       
  5.         if (x < 0) {  
  6.             System.out.println("负数没事开什么方");  
  7.             return -1;  
  8.         }  
  9.         if (x == 0)  
  10.             return 0;  
  11.   
  12.         double i = 0;  
  13.         double _avg;  
  14.         double last_avg = Double.MAX_VALUE;  
  15.         for (i = 0; i*i < x; i += 0.1);  
  16.         _avg = i;  
  17.   
  18.         final double _JINGDU = 1e-6;  
  19.   
  20.         while (Math.abs(_avg - last_avg) > _JINGDU) {  
  21.             last_avg = _avg;  
  22.             _avg = (_avg + x / _avg) / 2;  
  23.         }  
  24.         return _avg;  
  25.     }  
  26.       
  27.     public static void main(String[] args) {  
  28.         double x = 3;  
  29.         double root = baoliAndNewTonSqrt(x);  
  30.         System.out.println(root);  
  31.     }  
  32. }  

测试结果：

1.7320508075689423


4.二分开方法

原理：还是以3举例：

(0+3)/2 = 1.5, 1.5^2 = 2.25, 2.25 < 3;

(1.5+3)/2 = 2.25, 2.25^2 = 5.0625, 5.0625 > 3;

(1.5+2.25)/2 = 1.875, 1.875^2 = 3.515625; 3.515625>3;

.

.

.

直到前后两次平均值只差小于自定义精度为止，代码如下：

[java]  view plain  copy
  1. public class APIsqrt {  
  2.   
  3.     static double erfenSqrt(double x) {  
  4.   
  5.         if (x < 0) {  
  6.             System.out.println("负数没事开什么方");  
  7.             return -1;  
  8.         }  
  9.         if (x == 0)  
  10.             return 0;  
  11.   
  12.         final double _JINGDU = 1e-6;  
  13.         double _low = 0;  
  14.         double _high = x;  
  15.         double _mid = Double.MAX_VALUE;  
  16.         double last_mid = Double.MIN_VALUE;  
  17.   
  18.         while (Math.abs(_mid - last_mid) > _JINGDU) {  
  19.   
  20.             last_mid = _mid;  
  21.             _mid = (_low + _high) / 2;  
  22.             if (_mid * _mid > x)  
  23.                 _high = _mid;  
  24.             if (_mid * _mid < x)  
  25.                 _low = _mid;  
  26.   
  27.         }  
  28.         return _mid;  
  29.   
  30.     }  
  31.   
  32.     public static void main(String[] args) {  
  33.         double x = 3;  
  34.         double root = erfenSqrt(x);  
  35.         System.out.println(root);  
  36.     }  
  37. }  

测试结果：

1.732051134109497


5.计算 (int)(sqrt(x))算法

PS:此算法非博主所写
原理：空间换时间，细节请大家自行探究，代码如下：

[java]  view plain  copy
  1. public class APIsqrt2 {  
  2.     final static int[] table = { 0, 16, 22, 27, 32, 35, 39, 42, 45, 48, 50, 53,  
  3.             55, 57, 59, 61, 64, 65, 67, 69, 71, 73, 75, 76, 78, 80, 81, 83, 84,  
  4.             86, 87, 89, 90, 91, 93, 94, 96, 97, 98, 99, 101, 102, 103, 104,  
  5.             106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119,  
  6.             120, 121, 122, 123, 124, 125, 126, 128, 128, 129, 130, 131, 132,  
  7.             133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 144,  
  8.             145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155,  
  9.             156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166,  
  10.             167, 167, 168, 169, 170, 170, 171, 172, 173, 173, 174, 175, 176,  
  11.             176, 177, 178, 178, 179, 180, 181, 181, 182, 183, 183, 184, 185,  
  12.             185, 186, 187, 187, 188, 189, 189, 190, 191, 192, 192, 193, 193,  
  13.             194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201, 202,  
  14.             203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210,  
  15.             211, 211, 212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218,  
  16.             218, 219, 219, 220, 221, 221, 222, 222, 223, 224, 224, 225, 225,  
  17.             226, 226, 227, 227, 228, 229, 229, 230, 230, 231, 231, 232, 232,  
  18.             233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 240,  
  19.             240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246,  
  20.             247, 247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253,  
  21.             253, 254, 254, 255 };  
  22.   
  23.     /** 
  24.      * A faster replacement for (int)(java.lang.Math.sqrt(x)). Completely 
  25.      * accurate for x < 2147483648 (i.e. 2^31)... 
  26.      */  
  27.     static int sqrt(int x) {  
  28.         int xn;  
  29.   
  30.         if (x >= 0x10000) {  
  31.             if (x >= 0x1000000) {  
  32.                 if (x >= 0x10000000) {  
  33.                     if (x >= 0x40000000) {  
  34.                         xn = table[x >> 24] << 8;  
  35.                     } else {  
  36.                         xn = table[x >> 22] << 7;  
  37.                     }  
  38.                 } else {  
  39.                     if (x >= 0x4000000) {  
  40.                         xn = table[x >> 20] << 6;  
  41.                     } else {  
  42.                         xn = table[x >> 18] << 5;  
  43.                     }  
  44.                 }  
  45.   
  46.                 xn = (xn + 1 + (x / xn)) >> 1;  
  47.                 xn = (xn + 1 + (x / xn)) >> 1;  
  48.                 return ((xn * xn) > x) ? --xn : xn;  
  49.             } else {  
  50.                 if (x >= 0x100000) {  
  51.                     if (x >= 0x400000) {  
  52.                         xn = table[x >> 16] << 4;  
  53.                     } else {  
  54.                         xn = table[x >> 14] << 3;  
  55.                     }  
  56.                 } else {  
  57.                     if (x >= 0x40000) {  
  58.                         xn = table[x >> 12] << 2;  
  59.                     } else {  
  60.                         xn = table[x >> 10] << 1;  
  61.                     }  
  62.                 }  
  63.   
  64.                 xn = (xn + 1 + (x / xn)) >> 1;  
  65.   
  66.                 return ((xn * xn) > x) ? --xn : xn;  
  67.             }  
  68.         } else {  
  69.             if (x >= 0x100) {  
  70.                 if (x >= 0x1000) {  
  71.                     if (x >= 0x4000) {  
  72.                         xn = (table[x >> 8]) + 1;  
  73.                     } else {  
  74.                         xn = (table[x >> 6] >> 1) + 1;  
  75.                     }  
  76.                 } else {  
  77.                     if (x >= 0x400) {  
  78.                         xn = (table[x >> 4] >> 2) + 1;  
  79.                     } else {  
  80.                         xn = (table[x >> 2] >> 3) + 1;  
  81.                     }  
  82.                 }  
  83.   
  84.                 return ((xn * xn) > x) ? --xn : xn;  
  85.             } else {  
  86.                 if (x >= 0) {  
  87.                     return table[x] >> 4;  
  88.                 }  
  89.             }  
  90.         }  
  91.   
  92.         return -1;  
  93.     }  
  94.     public static void main(String[] args){  
  95.         System.out.println(sqrt(65));  
  96.           
  97.     }  
  98. }  
测试结果：8


6.最快的sqrt算法

PS:此算法非博主所写

这个算法很有名，大家可能也见过，作者是开发游戏的，图形算法中经常用到sqrt，作者才写了一个神级算法，和他那神秘的0x5f3759df，代码如下

[cpp]  view plain  copy
  1. #include <math.h>  
  2. float InvSqrt(float x)  
  3. {  
  4.  float xhalf = 0.5f*x;  
  5.  int i = *(int*)&x; // get bits for floating VALUE  
  6.  i = 0x5f375a86- (i>>1); // gives initial guess y0  
  7.  x = *(float*)&i; // convert bits BACK to float  
  8.  x = x*(1.5f-xhalf*x*x); // Newton step, repeating increases accuracy  
  9.  return x;  
  10. }  
  11.   
  12. int main()  
  13. {  
  14.   printf("%lf",1/InvSqrt(3));  
  15.   
  16.    return 0;  
  17. }  
测试结果：


感兴趣的朋友可以参考http://wenku.baidu.com/view/a0174fa20029bd64783e2cc0.html  是作者解释这个算法的14页论文《Fast Inverse Square Root》


7.一个与算法6相似的算法

PS:此算法非博主所写

代码如下：

[cpp]  view plain  copy
  1. #include <math.h>  
  2. float SquareRootFloat(float number) {  
  3.     long i;  
  4.     float x, y;  
  5.     const float f = 1.5F;  
  6.   
  7.     x = number * 0.5F;  
  8.     y  = number;  
  9.     i  = * ( long * ) &y;  
  10.     i  = 0x5f3759df - ( i >> 1 );  
  11.     y  = * ( float * ) &i;  
  12.     y  = y * ( f - ( x * y * y ) );  
  13.     y  = y * ( f - ( x * y * y ) );  
  14.     return number * y;  
  15. }  
  16.   
  17. int main()  
  18. {  
  19.   printf("%f",SquareRootFloat(3));  
  20.   
  21.    return 0;  
  22. }  
测试结果：



greatau
关注
专栏目录
一段求平方根的代码
transistor0的专栏
11-22 1438
有人在Quake III的源代码里面发现这么一段用来求平方根的代码: /*================SquareRootFloat================*/float SquareRootFloat(float number) { long i; float x, y; const float f = 1.5F; x = number * 0.5F;
【题解】平方根
C@bMv7GRVt)Q
10-29 479
题目 给出一个正整数n（1&lt;n&lt;=231-1），求当x，y都为正整数，方程sqrt{n}=sqrt{x}-sqrt{y}的解中，x的最大值是多少？ 输入文件 （sqrt.in）一行，一个正整数n。 输出文件 （sqrt.out）一行，一个满足条件的最大的x的解。 样例： input 4 output 9 思路 将等式变形，可以得...
3180：【例30.1】 平方根（C、C++、python）
最新发布
青少年趣味编程
08-19 561
3180：【例30.1】 平方根（C、C++、python）
matlab平方根法和改进平方根法求解线性方程组例题与程序文件.docx
06-24
《MATLAB中的平方根法与改进平方根法求解线性方程组》 线性方程组的求解在科学计算中占有重要的地位，MATLAB作为一种强大的数值计算工具，提供了多种方法来解决这类问题。本文主要探讨的是利用MATLAB实现的平方根法...
matlab平方根法和改进平方根法求解线性方程组例题与程序文件.pdf
05-25
《MATLAB中的平方根法与改进平方根法求解线性方程组》 线性方程组的求解在科学计算中占有重要地位，MATLAB作为一种强大的数值计算工具，提供了多种方法来解决这类问题。本文主要探讨的是利用MATLAB实现的平方根法和...
MATLAB-平方根法和改进平方根法求解线性方程组例题与程序.pdf
05-31
《MATLAB中的平方根法与改进平方根法求解线性方程组》 线性方程组的求解在科学计算中占有重要地位，MATLAB作为一种强大的数值计算工具，提供了多种方法来解决这类问题。本文主要探讨的是利用MATLAB实现的平方根法和...
MATLAB-平方根法和改进平方根法求解线性方程组例题与程序演示教学.pdf
04-04
平方根法和改进平方根法是两种用于求解线性方程组的高效算法，尤其适用于处理对称正定矩阵的线性系统。这两种方法基于矩阵的分解，减少了计算复杂度，提高了求解效率。 首先，平方根法，也称为Cholesky分解，是一种...
matlab通信仿真：3 平方根升余弦滤波器.zip
05-26
本篇将深入探讨"matlab通信仿真：3 平方根升余弦滤波器"这一主题，通过MATLAB这个强大的数值计算与仿真工具，我们将理解平方根升余弦滤波器的基本概念、设计方法以及其实现过程。 首先，平方根升余弦滤波器（Root ...
matlab平方根法代码
11-21
matlab的平方根算法代码简单实用正确的~
求平方根
salmonwilliam的博客
03-21 1276
题目描述 实现函数int sqrt(int x). 计算并返回x的平方根（向下取整） 示例1 输入 2 返回值 1 题目链接：https://www.nowcoder.com/practice/09fbfb16140b40499951f55113f2166c?tpId=117&tqId=37734&rp=1&ru=%2Fta%2Fjob-code-high&qru=%2Fta%2Fjob-code-high%2Fquestion-ranking&.
x 的平方根
sunyadong_的博客
01-18 615
实现 int sqrt(int x) 函数。 计算并返回 x 的平方根，其中 x 是非负整数。 由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。 示例 1: 输入: 4 输出: 2 示例 2: 输入: 8 输出: 2 说明: 8 的平方根是 2.82842...,   由于返回类型是整数，小数部分将被舍去。 不知道是不是还没发现这道题的真正用意，感觉水题一...
X的平方根
BeanBangbang的博客
09-03 387
设计函数int sqrt(int x)，计算 xxx 的平方根。 输入格式 输入一个 整数 xxx，输出它的平方根。直到碰到文件结束符（EOF）为止。 输出格式 对于每组输入，输出一行一个整数，表示输入整数的平方根。 样例输入 1 2 3 4 5 6 7 8 9 样例输出 1 1 1 2 2 2 2 2 3 #include &lt;iostream&gt; using n...
x的平方根
qq_41569375的博客
02-27 1332
题目三十九：实现 int sqrt(int x) 函数，计算并返回 x 的平方根。您在真实的面试中是否遇到过这个题？Yes样例sqrt(3) = 1sqrt(4) = 2sqrt(5) = 2sqrt(10) = 3挑战O(log(x))代码：class Solution { public: /** * @param x: An integer * @return: T...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值