for(i=(*n)-1;i>=j;i--) 说明你对for结束时,i是多少没有概念

所以呢？把i改成j，加上分号（分号是我复制程序过来的时候漏了，不好意思），运行结果一样是一堆乱码。。。i和j写错了，只不过新加的数位置不对，又不会影响到为什么是乱码的问题。。。
Entrez un chiffre : 12
Le tableau precedent : 1  6  7  10  14  18  22  29  36  47
Le nouveau tableau : 1  6  7  12  14  18  22  29  36  48  12  9900928  0  4199400  0  0  0  46  0  4225568  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

--------------------------------

算了，以后我注意一下数组不要越界就好了，关于为什么用指针会出现乱码的问题以后有机会再讨论吧。

当然如果有大佬们还能看到这个贴子，愿意帮我解决一下乱码问题，我也很感激。

乱码问题到底还是数组越界嘛,这个好解决,除了要对数组长度进行判断是否越界,也可以用链表,这里简单弄了个,不过单向的实现某些功能不太方便,就算这样了~

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

typedef struct DATA DATA,*P_DATA;
typedef int Element; 

struct DATA
{
    Element num;
    P_DATA next;
};

int comp( const void*,const void* );

void nodeMal( void** ,size_t size );
void nodeFree( void** );

void initHead( P_DATA* );
void initData( P_DATA*,Element );

P_DATA find( const DATA*,const DATA*,int (*) ( const void*,const void* ));

P_DATA insertOrder( P_DATA,P_DATA,int (*) ( const void*,const void* ));
void _insert( P_DATA,P_DATA );

int isSingle( const DATA* );

P_DATA delNode( P_DATA );

P_DATA insert( P_DATA,Element,int (*)( const void*,const void* ) );
void print( const DATA* );

void fun ( void );

int main ( void )
{
    fun();
    
    return 0;
}

int comp( const void* _p,const void* _q)
{
    P_DATA p=( P_DATA )_p;
    P_DATA q=( P_DATA )_q;
    
    if ( p->num>q->num )
        return -1;
    else
        return 1;
}

void nodeMal( void** p,size_t size )
{
    assert(p);
    
    *p=malloc(size);
    
    assert(*p);
    
    memset(*p,0,size);
}

void nodeFree( void** p )
{
    assert(p);
    
    free(*p);
    *p=NULL;
}

void initHead(P_DATA* data )
{
    nodeMal(( void** )data,sizeof (DATA));
    
    (*data)->next=*data;
}

void initData( P_DATA* data,Element num )
{
    nodeMal(( void** )data,sizeof (DATA));
    (*data)->num=num;
}

P_DATA find( const DATA* key,const DATA* head,int (*comp) ( const void*,const void* ))
{
    const DATA* t=head;
    
    while ( t->next!=head&&comp(key,t->next)<0)
        t=t->next;
        
    return ( P_DATA )t;
}

void _insert( P_DATA p,P_DATA q )
{
    p->next=q->next;
    q->next=p;
}

P_DATA insertOrder( P_DATA data,P_DATA head,int (*comp) ( const void*,const void* ))
{
    P_DATA p=find(data,head,comp);
    
    _insert(data,p);
    
    return data;
}

int isSingle( const DATA* head )
{
    return head->next==head;
}

P_DATA delNode( P_DATA p )
{
    P_DATA t=p->next;
    
    p->next=t->next;
    
    return t;
}

P_DATA insert( P_DATA head,Element num,int (*comp)( const void*,const void* ) )
{
    
    P_DATA data=NULL;
    P_DATA p=NULL;
    
    if ( head==NULL)
        return NULL;
    
    initData(&data,num);
    
    p=insertOrder(data,head,comp);
    
    ++head->num;
    
    return p;
}

void print( const DATA* head )
{
    const DATA* p=head;
    
    if (head==NULL)
        return ;
    
    while ((p=p->next)!=head)
        printf("%-4u",p->num);
    
    puts("");
}

void fun ( void )
{
    #define ARR_SIZE( a )    \
        (sizeof (a)/sizeof (*(a)))
        
    Element a[]={7,9,8,6,4,2,3,1,5};
    
   P_DATA head=NULL;
   P_DATA p=NULL;
   
   Element num;
    
    size_t i;
    
    initHead(&head);

    for (i=0;i!=ARR_SIZE(a);++i)
        insert(head,a[i],comp);
    
    puts("初始数据:");
    print(head);
    
    puts("请输入要插入的数据:");
    if (scanf("%d%*c",&num)!=1)
        return ;
        
    insert(head,num,comp);
    
    puts("输出数据如下:");
    print(head);
    
    
    while (!isSingle(head))
    {
        P_DATA t=delNode(head);
        nodeFree(( void** )&t);
    }
    
    nodeFree(( void** )&head);
    
    #undef ARR_SIZE
}

[此贴子已经被作者于2018-4-2 16:16编辑过]