PLSQL计算质数

看到有人实现了一个计算质数的函数，就是效率有点差，贴一个以前写的计算质数的算法。

目标很简单，列出100以内的质数。
其实算法很简单，两个循环就搞定了。但是发现使用不同的算法，执行效率差别之大相当惊人，特别是数据量级很大的时候。

下面就是最常见的一种写法：（也是最差的一种）

[PHP]

SQL> SET SERVEROUT ON
SQL> DECLARE
  2   V_FLAG BOOLEAN;
  3  BEGIN
  4   FOR I IN 2 .. 100 LOOP
  5    V_FLAG := TRUE;
  6    FOR J IN 2 .. I - 1 LOOP
  7     IF  MOD(I,J) = 0 THEN
  8      V_FLAG := FALSE;
  9     END IF;
10    END LOOP;
11  
12    IF V_FLAG = TRUE THEN
13     DBMS_OUTPUT.PUT_LINE(I);
14    END IF;
15   END LOOP;
16  END;
17  /
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97
PL/SQL 过程已成功完成。
已用时间:  00: 00: 00.09

.
[/PHP]

由于屏幕输出操作比较慢，为了避免影响，将屏幕输出关闭。并将数据量增大到100000，以下所有的测试都在这个相同条件下进行。

[PHP]

SQL> DECLARE
  2   V_FLAG BOOLEAN;
  3  BEGIN
  4   FOR I IN 2 .. 100000 LOOP
  5    V_FLAG := TRUE;
  6    FOR J IN 2 .. I - 1 LOOP
  7     IF  MOD(I,J) = 0 THEN
  8      V_FLAG := FALSE;
  9     END IF;
10    END LOOP;
11  
12    IF V_FLAG = TRUE THEN
13     --DBMS_OUTPUT.PUT_LINE(I);
14     NULL;
15    END IF;
16   END LOOP;
17  END;
18  /
PL/SQL 过程已成功完成。
已用时间:  02: 02: 58.73

.
[/PHP]

这种方法在100000数据量的用时居然达到了2个小时。
如果稍微仔细考虑一下，就会发现，系统做了很多没有必要的工作，首先判断是否能整除的时候不需要循环到I – 1，只要执行到I的平方根就可以了，而且，如果I可以被整除就不需要继续循环，可以马上跳出内层循环了。经过简单优化后：

[PHP]

SQL> DECLARE
  2   V_FLAG BOOLEAN;
  3  BEGIN
  4   FOR I IN 2 .. 100000 LOOP
  5    V_FLAG := TRUE;
  6    FOR J IN 2 .. TRUNC(POWER(I, 0.5)) LOOP
  7     IF  MOD(I,J) = 0 THEN
  8      V_FLAG := FALSE;
  9      EXIT;
10     END IF;
11    END LOOP;
12  
13    IF V_FLAG = TRUE THEN
14     --DBMS_OUTPUT.PUT_LINE(I);
15     NULL;
16    END IF;
17   END LOOP;
18  END;
19  /
PL/SQL 过程已成功完成。
已用时间:  00: 00: 16.21

.
[/PHP]

效果十分的明显，从2个多小时，缩减到了16秒。
算法还可以进一步优化，考虑到质数中只有2是偶数，其他都是奇数，可以将2单独处理，然后将循环的步长设置为2，这样外层循环次数就减少了一半。

[PHP]

SQL> DECLARE
  2   I NUMBER DEFAULT 3;
  3   V_FLAG BOOLEAN;
  4  BEGIN
  5   --DBMS_OUTPUT.PUT_LINE(2);
  6   WHILE I < 100000 LOOP
  7    V_FLAG := TRUE;
  8    FOR J IN 2 .. TRUNC(POWER(I, 0.5)) LOOP
  9     IF  MOD(I,J) = 0 THEN
10      V_FLAG := FALSE;
11      EXIT;
12     END IF;
13    END LOOP;
14  
15    IF V_FLAG = TRUE THEN
16     --DBMS_OUTPUT.PUT_LINE(I);
17     NULL;
18    END IF;
19   I := I + 2;
20   END LOOP;
21  END;
22  /
PL/SQL 过程已成功完成。
已用时间:  00: 00: 09.37

.
[/PHP]

仔细考虑一下，其实用来被整除的数是质数就足够了，不需要对所有奇数进行判断。在下面的过程中，使用索引表来保存计算得到的所有的质数：

[PHP]

SQL> DECLARE
  2   TYPE T_RECORD IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
  3   V_RESULT T_RECORD;
  4   V_FLAG BOOLEAN;
  5   V_CNT NUMBER;
  6   I NUMBER DEFAULT 3;
  7  BEGIN
  8   V_RESULT(1) := 2;
  9   --DBMS_OUTPUT.PUT_LINE(V_RESULT(1));
10   WHILE(I < 100000) LOOP
11    V_FLAG := TRUE;
12    V_CNT := V_RESULT.COUNT;
13    FOR J IN 1..V_CNT LOOP
14     IF V_RESULT(J) > POWER(I, 0.5) THEN
15      EXIT;
16     END IF;
17     IF MOD(I,V_RESULT(J)) = 0 THEN
18      V_FLAG := FALSE;
19      EXIT;
20     END IF;
21    END LOOP;
22    IF V_FLAG THEN
23    -- DBMS_OUTPUT.PUT_LINE(I);
24     V_RESULT(V_CNT+1) := I;
25    END IF;
26    I := I + 2;
27   END LOOP;
28  END;
29  /
PL/SQL 过程已成功完成。
已用时间:  00: 00: 06.68

.
[/PHP]

已经将速度提高到了6秒左右，还能不能更快呢？注意到在最内层循环中调用了一个函数POWER(I, 0.5)，下面将这个表达式转换一下，避免使用这个函数：

[PHP]

SQL> DECLARE
  2   TYPE T_RECORD IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
  3   V_RESULT T_RECORD;
  4   V_FLAG BOOLEAN;
  5   I NUMBER DEFAULT 3;
  6  BEGIN
  7   --DBMS_OUTPUT.PUT_LINE(2);
  8   V_RESULT(1) := 2;
  9   WHILE(I < 100000) LOOP
10    V_FLAG := TRUE;
11    FOR J IN 1..V_RESULT.COUNT LOOP
12     IF V_RESULT(J) * V_RESULT(J) > I THEN
13      EXIT;
14     END IF;
15     IF MOD(I,V_RESULT(J)) = 0 THEN
16      V_FLAG := FALSE;
17      EXIT;
18     END IF;
19    END LOOP;
20    IF V_FLAG THEN
21    -- DBMS_OUTPUT.PUT_LINE(I);
22     V_RESULT(V_RESULT.COUNT + 1) := I;
23    END IF;
24    I := I + 2;
25   END LOOP;
26  END;
27  /
PL/SQL 过程已成功完成。
已用时间:  00: 00: 01.03

.
[/PHP]

难以置信吧，一个执行两个小时的PL/SQL，通过算法的调整可以优化到了1秒。
其实能优化的地方还有很多，不过这些优化能带来的性能提升已经很小了。比如：

[PHP]

SQL> DECLARE
  2   TYPE T_RECORD IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
  3   V_RESULT T_RECORD;
  4   V_FLAG BOOLEAN;
  5   I NUMBER DEFAULT 3;
  6  BEGIN
  7   --DBMS_OUTPUT.PUT_LINE(2);
  8   V_RESULT(0) := 2;
  9   WHILE(I < 100000) LOOP
10    V_FLAG := TRUE;
11    FOR J IN 1..V_RESULT.COUNT - 1 LOOP
12     IF V_RESULT(J) * V_RESULT(J) > I THEN
13      EXIT;
14     END IF;
15     IF MOD(I,V_RESULT(J)) = 0 THEN
16      V_FLAG := FALSE;
17      EXIT;
18     END IF;
19    END LOOP;
20    IF V_FLAG THEN
21    -- DBMS_OUTPUT.PUT_LINE(I);
22     V_RESULT(V_RESULT.COUNT) := I;
23    END IF;
24    I := I + 2;
25   END LOOP;
26  END;
27  /
PL/SQL 过程已成功完成。
已用时间:  00: 00: 00.96

.
[/PHP]

由于从3开始步长为2，因此判断随后的质数的时候，没有必要用2去整除，而直接可以从3开始。
过程仍然可以进一步优化，可以省略掉不必要的赋值和判断语句：

[PHP]

SQL> DECLARE
  2   TYPE T_RECORD IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
  3   V_RESULT T_RECORD;
  4   I NUMBER DEFAULT 3;
  5  BEGIN
  6   --DBMS_OUTPUT.PUT_LINE(2);
  7   V_RESULT(1) := 3;
  8   WHILE(I < 100000) LOOP
  9    FOR J IN 1..V_RESULT.COUNT LOOP
10     IF MOD(I,V_RESULT(J)) = 0 THEN
11      EXIT;
12     END IF;
13     IF V_RESULT(J) * V_RESULT(J) > I THEN
14     -- DBMS_OUTPUT.PUT_LINE(I);
15      V_RESULT(V_RESULT.COUNT + 1) := I;
16      EXIT;
17     END IF;
18    END LOOP;
19    I := I + 2;
20   END LOOP;
21   V_RESULT(0) := 2;
22  END;
23  /
PL/SQL 过程已成功完成。
已用时间:  00: 00: 00.96

.
[/PHP]
但是在100000这个数量级已经看不出性能的差别了。正如Tom所说的，系统总是可以提高1%的性能，不过付出的代价会越来越大。
刚才测试发现，将MOD函数转换一下，性能还会有一个相对明显的提升

[PHP]

SQL> DECLARE
  2   TYPE T_RECORD IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
  3   V_RESULT T_RECORD;
  4   I NUMBER DEFAULT 3;
  5  BEGIN
  6   --DBMS_OUTPUT.PUT_LINE(2);
  7   V_RESULT(1) := 3;
  8   WHILE(I < 100000) LOOP
  9    FOR J IN 1..V_RESULT.COUNT LOOP
10     IF V_RESULT(J) * V_RESULT(J) > I THEN
11      --DBMS_OUTPUT.PUT_LINE(I);
12      V_RESULT(V_RESULT.COUNT + 1) := I;
13      EXIT;
14     END IF;
15     IF TRUNC(I/V_RESULT(J)) = I/V_RESULT(J) THEN
16      EXIT;
17     END IF;
18    END LOOP;
19    I := I + 2;
20   END LOOP;
21   V_RESULT(0) := 2;
22  END;
23  /
PL/SQL 过程已成功完成。
已用时间:  00: 00: 00.87

.
[/PHP]

再来一次尝试：

[PHP]

SQL> DECLARE
  2   TYPE T_RECORD IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;
  3   V_RESULT T_RECORD;
  4   I NUMBER DEFAULT 3;
  5   N NUMBER DEFAULT 0;
  6  BEGIN
  7   --DBMS_OUTPUT.PUT_LINE(2);
  8   V_RESULT(1) := 3;
  9   WHILE(I < 100000) LOOP
10    FOR J IN 1..V_RESULT.COUNT LOOP
11     IF V_RESULT(J) * V_RESULT(J) > I THEN
12      --DBMS_OUTPUT.PUT_LINE(I);
13      V_RESULT(V_RESULT.COUNT + 1) := I;
14      EXIT;
15     END IF;
16     IF TRUNC(I/V_RESULT(J)) = I/V_RESULT(J) THEN
17      EXIT;
18     END IF;
19    END LOOP;
20    IF N = 2 THEN
21     I := I + 4;
22     N := 1;
23    ELSE
24     I := I + 2;
25     N := N + 1;
26    END IF;
27   END LOOP;
28   V_RESULT(0) := 2;
29  END;
30  /
PL/SQL 过程已成功完成。
已用时间:  00: 00: 00.84

.
[/PHP]

看来Tom说的确实没有错，优化的方法总是存在的。

原文出自：http://space.itpub.net/4227/viewspace-68767