我先来，解决等边三角形的。
1，对初始数据构造网状链表，每个节点六条链，左上，右上，左，右，左下，右下。
2，对给的三个数，先找出最小的数，等边三角形的最小点到第二大的数的点，必须是沿着左下链找到，如果找不到，就不是，如果找到，记录长度，也就是他们之间的节点数。
3，对第二大的数沿着右链找，找第二部获得的长度，如果刚好是那个数，就是等边三角形，如果不是。不是指定形状。

同理，四边形的也能解决：
4个数
1，先找到两个最小的数，先根据公式确认第二小的数是在第一小的数的右边链还是左下链。
2，在根据第三小的数和第一小的数，确定第三小的数是在第一小的数的左下还是右下。
3，判断出方向之后，判断长度，也就是链的节点数，即可。

六边形类似的逻辑也行。

每层的个数，层数为i,i取值为0到32767.
每层节点个数：node_num = i + 1;

给定一个数n，首先要找到它在哪个层：
sum = 0;
for(i = 0; i < 32767; i++){
sum += (i + 1);
if(n < sum)
{
return i;//i 是层数
}

}

n左上 = n - (i + 1);
n右上 = n - i;
n = n - 1
n右 = n + 1
n左下 = n + i + 1;
n右下 = n + i + 2;

牛B

其实找出公式了，不需要建链表，内存和时间应该都足够。

@stephendanteng 谢谢，能够提供可测试程序？

@witlili 没时间 写啊，老哥，我是C程序员 ，写了也测不了啊。

业务驱动型程序员表示看到这样的就头疼

这个代码写起来还是挺麻烦 的，我写了个三角形的判断的。。。。贴出来参考下。剩下的实在没时间写了，要搞正事了。。

include <stdio.h>

int get_level(int n)
{
int sum = 0;
int i = 0;

for(i = 0; i < 32767; i++)
{
    sum += (i + 1);
    if(n <= sum)
    {
        return i;
    }

}

}

int get_left_on(int n, int i)
{
int res = (n - i - 1);
return (res > 0 ? res:0);
}

int get_right_on(int n, int i)
{
int res = (n - i);
return (res > 0? res:0);
}

int get_left(int n)
{
int res = n - 1;
return (res > 0? res:0);
}

int get_right(int n)
{
return n + 1;
}

int get_left_down(int n, int i)
{
return n + i + 1;
}

int get_right_down(int n, int i)
{
return n + i + 2;
}

int get_min_from_three(int a, int b, int c)
{
int min = a;
if(b < min)
{
min = b;
}
if(c < min)
{
min = c;
}
return min;
}

int get_max_from_three(int a, int b, int c)
{
int max = a;
if(b > max)
{
max = b;
}
if(c > max)
{
max = c;
}
return max;
}

int get_second_min_from_three(int a, int b, int c)
{
if(a > b)

{
if(b > c)
{
return b;
}
else if(a < c)
{
return a;
}
else
{
return c;
}
}
else
{
if(a > c)
{
return a; //b > a > c
}
else if(b < c)
{
return b;//c > b > a
}
else
{
return c; // b > c > a
}

}

}

int judge_three(int a, int b, int c)
{
int min = get_min_from_three(a, b, c);
int max = get_max_from_three(a, b, c);

int second_min = get_second_min_from_three(a,b,c);

int i = 0;  
int j = 0;
int left_down = 0;
int right = 0;
int level = get_level(min);
left_down = get_left_down(min, level);
for(i = 0; i < 32767; i++)
{
    if(second_min < left_down)
    {
        return -1;
    }
    if(second_min == left_down)
    {
        break;//found
    }

    level++;
    left_down = get_left_down(left_down, level);
}

if(i == 32767)
{
    return -1;
}


right = get_right(second_min);

for(j = 0; j < 32767; j++)  
{
    if(max < right)
    {
        return -1;
    }
    if(max == right)
    {
        break;//found
    }

    right = get_right(right);

}

if(i == j)
{
    return 0;//found
}

return -1;

}

int main(int argc, char **argv)
{

printf("hello world !\n");

int res = 0;
res = judge_three(1,4,6);
if(res == 0)
{
    printf("three found!\n");
}
else
{
    printf("not three!\n");
}
res = judge_three(2,4,6);
if(res == 0)
{
    printf("three found!\n");
}
else
{
    printf("not three!\n");
}

return 0;

}

@stephendanteng 谢谢，辛苦了