已知n行2列的二维数组A[n][2],且已知数组中的第一列的元素为大于0的逐渐增大的正数，第二列中元素为大于等于0的正数，要求数组中第一列的相邻两个元素之间的差值小于0.1，一旦相邻两个元素的差值大于0.1，即取中间值插入其中，相应的第二列元素也取中间值，得到扩充后新数组，再次判断新数组中第一列的相邻两个元素的差值是否小于0.1，不满足继续在其中插入一组中间值，直到最后得到的新数组，第一列所有所有相邻元素之间的差值都小于0.1了，则结束运算，输出得到的新二维数组，求大神指点实现算法
举个例子：1    1         1          1
          1.5  1   变成  1.0625     1
                         1.125      1
                         1.1875     1
                         1.25       1
                         1.3125     1
                         1.375      1
                         1.4375     1
                         1.5        1
                        

你学指针了没有，会不会用结构数组？如果会用链表来存储这些数据，那么后期的“扩充”，就只要对前后两个相邻的链表进行比较扩充。
把这个链表走一遍就完成了。
如果只用数组存储的话，，，我觉得可能要用函数去反复递归处理。但我看到递归就头疼。。(下面这段还没试过，不晓得行不行，)
double fun(double a,double b){
if(b-a<=0.1){printf("%llf",b);
}else{
    a=fun(a,(a+b)/2);
    b=fun((a+b)/2,b);
}
return b;
}

请问您说的第一种，采用链表比较扩充的方法，能给写个具体的算法吗？谢谢

#include <stdio.h>

size_t foo( const double src[][2], size_t src_len, double dst[][2] )
{
    if( src_len == 0 )
        return 0;

    size_t dst_len = 1;
    dst[0][0]=src[0][0], dst[0][1]=src[0][1];
    for( size_t i=1; i!=src_len; ++i )
    {
        const double delta0 = src[i][0] - dst[dst_len-1][0];
        const double delta1 = src[i][1] - dst[dst_len-1][1];
        size_t cnt = 1;
        for( double tmp=delta0; tmp>0.1; tmp/=2, cnt*=2 );

        for( size_t j=0; j!=cnt; ++j )
        {
            dst[dst_len][0] = src[i][0] - ( (cnt-1-j)*1.0/cnt )*delta0;
            dst[dst_len][1] = src[i][1] - ( (cnt-1-j)*1.0/cnt )*delta1;
            ++dst_len;
        }
    }

    return dst_len;
}

int main( void )
{
    double a[][2] = { {1,1}, {1.5,1} };

    double b[100][2];
    size_t b_len = foo( a, sizeof(a)/sizeof(*a), b );

    for( size_t i=0; i!=b_len; ++i )
        printf( "%g\t%g\n", b[i][0], b[i][1] );

    return 0;
}

想了又想，想实现目的不一定要用到递归函数。
#include <stdio.h>
int main()
{
    double a=1,b=2.5,k=b-a;
    while(k>=0.1)   k=k/2;
    while(a<=b)
    {        
        printf("%g\t",a);
        a+=k;
    }
    return 0;
   
}
如果要将数据存入数组中，然后输出，只要简单加上赋值的代码就能实现了。

收到的鲜花

• 书生牛犊 于 2016-08-04 18:11 送鲜花  10朵   附言：我很赞同！这个很厉害，直接计算出两个数之 ...

#include <stdio.h>
#include<stdlib.h>

typedef struct node *Node;
struct node {
    double Num;
//int Num2;第二个元素的处理你自己做吧。
    Node Next;
};

Node Fun(Node,double);
void Fun2(Node,double);

int main() {
    int n;
    scanf("%d",&n);
    Node Head=NULL;
    Node temp=Head;
    while(n--) {
        double num;
        scanf("%lf",&num);
        if(!temp) {
            Head=(Node)malloc(sizeof(struct node));
            Head->Num=num;
            temp=Head;
        } else {
            temp->Next=(Node)malloc(sizeof(struct node));
            temp->Next->Num=num;
            temp=temp->Next;
        }
    }
    temp->Next=NULL;


    Head=Fun(Head,0.1);
    //Fun2(Head,0.1);
//因为链表的头结点不会被改动，所以Fun2也是可行的，没必要返回个什么值。
//后续你就可以用这个返回的链表做各种别的事，比如输出
    temp=Head;
    while(temp) {
        printf("%.4lf ",temp->Num);
        temp=temp->Next;
    }

    return 0;
}

Node Fun(Node H,double K) {
    if(H&&H->Next) {
        while(H->Next->Num-H->Num>K) { //不知道等于0.1的情况要不要处理，
            Node temp=(Node)malloc(sizeof(struct node));
            temp->Num=(H->Num+H->Next->Num)/2;
            temp->Next=H->Next;                       //这两步就实现了链表的插入操作
            H->Next=temp;                             //
        }
        H->Next=Fun(H->Next,K);
    }
    return H;
}
void Fun2(Node Head,double K) {
    Node H=Head;        ／／费周章声明一个指针只是为了保留头结点，如果这个函数未来改动了，需要返回头指针了，那么直接ｒｅｔｕｒｎ　Ｈｅａｄ就行
    while(H&&H->Next) {
        while(H->Num-H->Next->Num>K) { //不知道等于0.1的情况要不要处理，
            Node temp=(Node)malloc(sizeof(struct node));
            temp->Num=(H->Num+H->Next->Num)/2;
            temp->Next=H->Next;                       //这两步就实现了链表的插入操作
            H->Next=temp;                          //
        }
        H=H->Next;
    }
}

由于精度的关系，间距０．１的情况时还是被平分了。。。这个代码要用在这道题目上还得稍微改改，加进去一个元素Ｎｕｍ２，修改几处就能用了。再多我不帮忙了。

#include <stdio.h>
#include <stdlib.h>

typedef struct _DATA_
{
    double f1;
    double f2;
    _DATA_ *Next;
} DATA, *PDATA;

PDATA _Add(PDATA p, double f1, double f2)
{
    PDATA pAdd = (PDATA)malloc(sizeof(DATA));
    if (p != NULL)
    {
        pAdd->Next = p->Next;
        p->Next = pAdd;
    }
    else
    {
        pAdd->Next = NULL;
    }
    pAdd->f1 = f1;
    pAdd->f2 = f2;
    return pAdd;
}

main()
{
    PDATA p = _Add(NULL, 1, 1);
    _Add(p, 1.5, 1);

    PDATA pi = p;
    while (pi->Next != NULL)
    {
        if ((pi->Next->f1 - pi->f1) > 0.1)
        {
            _Add(pi, (pi->Next->f1 + pi->f1) / 2, (pi->Next->f2 + pi->f2) / 2);
        }
        else
        {
            pi = pi->Next;
        }
    }
   
    PDATA pt;
    pi = p;
    while (pi != NULL)
    {
        printf("%lf, %lf\n", pi->f1, pi->f2);
        pt = pi;
        pi = pi->Next;
        free(pt);
    }
}

谢谢楼上各位前辈的指教！4楼的算法很好，我已经验证了，能够满足题目的要求，学习了。5楼没看懂。6楼和7楼的算法都好高端，我还得继续学习！

你这题难点就在于类型是浮点数
a/2 + a/2 未必等于 a
避免浮点数的累加误差是关键

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
int main()
{
    double a[][2] = { {1,3}, {1.5,1} };
    //double b[50][2];
    double *b;
    double k1=a[1][0]-a[0][0],k2;
    int j,i=0,m=0;
    while(k1>=0.1)
    {
        k1=k1/2;
        m++;
    }
    j=pow(2,m);
    k2=(a[0][1]-a[1][1])/j;
    b=(double*)malloc((j+1)*sizeof(double)*2);   
    b[i++]=a[0][0];
    b[i++]=a[0][1];
    for(i=2;i<=j*2;)       //for(i=1;i<=j;i++)     
    {
        b[i++]=b[i-2]+k1;  //    b[i++]=b[i-1][0]+k1;
        b[i++]=b[i-2]-k2;    //  b[i++]=b[i-2][1]-k2;
    }
    for(i=0;i<=j*2;)
   {
        printf("%g\t",b[i++]);
        printf("%g\n",b[i++]);
   }
    free(b);
    return 0;  
}
这样应该能看懂吧。

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