原始数据如下：其中 2017 5 1  你可以看成是一个字符串  也可以看成是一个结构体 总之不可分割
2017    5    1
2016    7    2
2011    1    3
2011    1    4
2000    2    5
2000    2    6
2000    3    7
1990    10    8
1991    11    9
1991    8    10
2011    2    11
2011    2    12
2016    3    13
2016    4    14
2016    3    15
2017    5    16


排序后结果如下：

1990    10    8
1991    8    10
1991    11    9
2000    2    5
2000    2    6
2000    3    7
2011    1    3
2011    1    4
2011    2    11
2011    2    12
2016    3    13
2016    3    15
2016    4    14
2016    7    2
2017    5    1
2017    5    16

想了半天 不知从何下手

你不需要对他们排序啊，建立一个链表，升序插入，然后逐一输入数据就可以了哦。

EXCEL实现起来是很简单的  就是不知道内部机制

3楼的图片 何你说的实现 方法应该不同吧
我链表不熟  没玩过

临时写的，其他部分你要自己完成，我只完成了插入和打印。
你需要自己完成释放内存，当然这个程序只运行一次，释放与否无所谓，另外输入函数自己造个轮子比较好，我用的gets()只是为了测试。
另外还要进行空字符串检查。我没写，但是很简单，一个if就够了。

测试数据没有完全输入，但是这一部分应该够了。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct NODE {
    char *str;
    struct NODE *Next;
}Node;
int
insert( Node **RootP, const char *src );
void
print_list( Node *RootP );

int
main( void )
{
    Node *RootP;
    char src[ 100 ];

    RootP = NULL;

    while( gets( src ) && '\0' != src[ 0 ] )
    {
        insert( &RootP, src );
    }
    print_list( RootP );


    return 0;
}

int
insert( Node **RootP, const char *src )
{
    Node *next;
    Node *new;

    for( next = *RootP; NULL != next;next = *RootP )
    {
        if( strcmp( next->str, src ) > 0 )
            break;
        RootP = &next->Next;
    }

    new = ( Node * )malloc( sizeof( Node ) );
    if( NULL == new )
        return 0;
    new->Next = next;
    new->str = strdup( src );
    *RootP = new;

    return 1;
}


void
print_list( Node *RootP )
{
    Node *next;

    for( next = RootP; NULL != next; next = RootP )
    {
        printf( "%s\n", next->str );
        RootP = next->Next;
    }
}

[此贴子已经被作者于2017-3-13 18:10编辑过]

多谢 收藏  好好研究一下

另外一个办法，就是建立一个很大的数组，当然这个可以动态分配。
然后建立一个指针数组。

将数据录入，复制到数组中，用一个指针指向它们。
完成后，用strcmp（）对比，交换指针就可以了。
但是这会有点慢，而且估计就真的需要排序的算法了。算法我一窍不通，帮不了你。

插入排序最简单，把原链表的元素一个一个拆下来插到新链表中，插入方式为找空当（比该元素小和大的空当中）。拆完了，就排好了。
我曾经想出一个奇葩的算法，现在修正一下:先建立一个head当原链表的新表头,每次找head后链表中最大的，插入到前面，并完成链表的复合工作，head后没有了就排完了,最
后释放head。

我数据给错了
我一楼的数据是中式日期表示方法

实际上基础数据是 月 日  年。但要按中式 就是实际日期进行升降排序

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
struct Store
{
    int first;
    int second;
    int third;

    
};

int compare(void * a, void * b)
{
    Store * cmp1 = (Store*)a;
    Store * cmp2 = (Store*)b;

    return cmp1->first > cmp2->first ? 1 :
        (cmp1->first < cmp2->first ? -1 : 
        (cmp1->second > cmp2->second ? 1 :
        (cmp1->second < cmp2->second ? -1 : 
        (cmp1->third > cmp2->third ? 1 : 
        (cmp1->third < cmp2->third ? -1 : 0)))));
}

int main()
{
    Store s[30];
    int i;
    for (i = 0; i < 5; i++)
        scanf("%d%d%d", &s[i].first, &s[i].second, &s[i].third);
    int j;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4 - i; j++) {
            if (compare(&s[j], &s[j + 1]) > 0) {
                Store tmp = s[j];
                s[j] = s[j + 1];
                s[j + 1] = tmp;
            }
        }
    }

    for (i = 0; i < 5; i++)
        printf("%d %d %d\n", s[i].first, s[i].second, s[i].third);
    system("pause");
}

应该能满足你的要求