从头开始，一位，两位……这样找，一遇到素数，就把剩下的部分提取出来，递归，对剩下的部分照样如此操作

对了，忘了说，判断字符转化为int用strtol函数，实现中，素数表已经建立~以下是建立素数表的代码，可供参考~

void primenumber()//建立素数表
{
    int i=0,j=0;

    judge[0]=judge[1]=1;

    for (i=2;i<100000;i++)
    {
        int flag=0;

        if (judge[i])
            continue;

        for (j=i;j<1000000;j+=i)
        {
            if (judge[j]==0&&flag)
                judge[j]=1;

            flag=1;
        }
    }
}

[此贴子已经被作者于2016-12-17 12:17编辑过]

对了，突然感觉比用strtol函数更好的方法，用逆向思维，建立素数字符串表~

回错了，好像建立素数字符串表字符串不能用sunday算法搜索，还是保留原来意见，用strtol函数~
又说错了，昨晚看完xzlxzlxzl版主提供的网站才知道这个不是sunday算法的核心汗

看了下楼才发现原来atoi函数也有这个功能~诶，那个我曾经用过的，就是没好好复习好库函数

[此贴子已经被作者于2016-12-17 10:31编辑过]

怎么递归？求详解

表我会打，我只是不会怎么去划分，求划分的方法？

#include<iostream>
using namespace std;
int heads[30]={30,30,30,30,30,30,
               30,30,30,30,30,30,
               30,30,30,30,30,30,
               30,30,30,30,30,30,
               30,30,30,30,30,30};
bool IsPrime(int n)
{
    if(n==0||n==1) return false;
    if(n==2) return true;
    int abso=n>0?n:-n;
    for(int i=2;i<abso;i++)
    {
        if(n%i==0) return false;
    }
    return true;
}
void PrintNum(char*str,int last,int num)
{
    int i,idx=1;
    for(i=0;i<=last;i++)
    {
        cout<<str[i];
        if(i+1==heads[idx]&&heads[idx]!=30&&idx<=num) cout<<",";
    }
    cout<<endl;
}
bool Divide(char*str,int from,int to,int depth)            //这个函数是核心，看它就是了。C++的
{
    int i;char s[30];int idx;
    if(from==to)                                       //最末一个字符是素数
    {
        heads[depth]=from;
        if(IsPrime(str[from]-48))
        {
            PrintNum(str,to,depth);return true;        //打印得出的素数集
        };//字符ascii值减48正好等于字符所显示的数字的值
    }
    for(i=from;i<=to&&i-from<6;i++)
    {
        strcpy(s,str+from);
        s[i-from+1]='\0';
        if(IsPrime(atoi(s)))
        {
            heads[depth]=from;
            if(i==to)                                 //最末一个字符串是素数
            {
                PrintNum(str,to,depth);return true;   //打印结果
            }
            else
                if(Divide(str,i+1,to,depth+1))
                    return true;
        }
        else continue;
    }
    return false;
}
int main()
{
    char str[30];
    cout<<"请输入一个不超过30位的数："<<endl;cin>>str;
    int length=strlen(str)-1;
    if(Divide(str,0,length,0)) cout<<"可作素数拆分\n";
    else cout<<"不可作素数拆分";
    return 0;
}

感谢，等我学了c++一定会回头看这个程序的

我用的是标准的纯C，没有使用任何C标准之外的东西。

帮忙看一下我的栈结构，第一次用栈，帮忙测试一下~看看有没有问题：

为什么经历退栈后的都是无法实现的？此句已过期
实现的都没有经历退栈，难道其中有规律还是我的代码有问题？？？

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct LNode
{
    int num;//  num:素数
    int num_L;//素数当前的长度
    char *num_point; //素数的位置

}LNode;
LNode count[30]={0};
LNode *head=count;//这个是判断栈空的头指针，由于已确定进栈元素不超过30个，因此省略考虑判断栈满的情况
LNode *pL=count;//这个是栈指针
int judge[1000000]={0};

void primenumber()//建立素数表
{
    int i=0;

    judge[0]=judge[1]=1;

    for (i=2;i<1000000;i++)
    {
        int flag=0;
        int j=0;

        if (judge[i])
            continue;

        for (j=i;j<1000000;j+=i)
        {
            if (judge[j]==0&&flag)
                judge[j]=1;

            flag=1;
        }
    }
}
int judge_primenumber(int num)//判断质数和合数
{
    return (judge[num]?0:1);
}
char *save_number(char *p,char *str,int len)//初始化数据
{
    int l=pL->num_L;

    char *stop=NULL;//这个为临时指针strtol有用

    char buf[10]="\0";

    if (pL->num_L==0)
        l=1;
    else
        l++;   //如果当前栈状态已初始化，则让素数长度+1

    for (;l<7;++l)
    {
        int kk=0;

        if ((p+l)-str>len)
            return NULL;

        strncpy(buf,p,l);
        kk=strtol(buf,&stop,10);

        if ((p+l)-str==len&&judge_primenumber(kk)==0)  //如果走到表尾也没有找到质数，则返回空~
          return NULL;

        if (judge_primenumber(kk)==1)
        {
            printf("    入栈数据%d\n",kk);//这个是个测试说明
            printf("当前剩余数据%s\n",p);
            printf("当前录入数据%.*s\n\n",p-str,str);

            pL->num=kk;    //入栈~
            pL->num_point=p;
            pL->num_L=l;
            pL++;
            p=p+l;  //入栈后要移动p
            break;
        }
    }

    if (l==7)
        return NULL;

    return p;
}
int judge_str(char *p)
{
    return (pL==head&&p==NULL?0:1);
}

int judge2_str(char *p)
{
    return (pL==head?0:1);
}
int main()
{
    char str[100]="\0";

    char *p=str;

    primenumber();

    gets(str);

    if (strlen(str)>30)
    {
        printf("读取数据超出范围\n");
        exit(0);
    }

    p=save_number(p,str,strlen(str));

    while (judge_str(p)&&*p)
    {      
        p=save_number(p,str,strlen(str));//入栈判断

        if (p==NULL&&judge2_str(p))
        {
            printf("    出栈数据%d\n",(pL-1)->num);//这个是测试说明
            printf("当前剩余数据%s\n",(pL-1)->num_point);
            printf("当前录入数据%.*s\n\n",(pL-1)->num_point-str,str);

            pL->num=0;//重置栈
            pL->num_L=0;
            --pL;    //出栈   

            p=pL->num_point;  //读取栈

        }
        else if (judge_str(p)==0)
        {
            pL->num=0;
            break;
        }

    }

    if (head->num==0)
        printf("不能实现\n");

    pL=head;

    while (pL->num&&head->num)
    {
        printf("%d\n",pL->num);
        pL++;
    }

    return 0;
}

//看下楼，没事了，求大神们帮忙测试下程序~

[此贴子已经被作者于2016-12-17 12:15编辑过]

没事了，终于找到例子证明出栈的还是有可能实现的，不过这种可能性比较小!~

2是质数,经历出栈后变成较大的质数2423~



43是质数~经历出栈后变成较大的质数4363~这证明了出栈是有成效的~



还有能用一个经历两次以上出栈也能实现的数据来吗~我找不到数据，不知道还有没有问题

[此贴子已经被作者于2016-12-17 00:36编辑过]