各位老师，我的程序如下，问题出现在当全局变量#define N 100000以上时总是报错，我想算更大，这问题怎么解决呢？报错：Unhandled exception at 0x002816a2 in Percolation.exe: 0xC0000005: Access violation reading location 0xccccccd4.
我用的是VS 2010编译。谢谢！

#include< stdio.h >
#include< math.h >
#include< malloc.h >
#include< stdlib.h >
#include< time.h >
#define LEN_np sizeof( struct np )
#define LEN_node sizeof( struct node )
#define LEN_np_kind sizeof( struct np_kind )
#define LEN_node_set sizeof( struct node_set )
#define alpha 0  //参数 alpha
#define N 100000 //系统规模
#define r 2 * N  //加的变数目

long extern npmax = 1;
//节点信息
struct node{
    long node_index;
    long node_size;//集团规模
    long color;
    struct node *node_next;
};
//集团类数目信息
struct np{
    long np_size;//npi
    long ng_size;//ngi
    struct np *np_next;
};

struct node_set{
    long node_ind;
    struct node_set *node_set_next;
};

//集团信息
struct np_kind
{
    long np_color; //集团编号
    struct node_set *node_set_point; //节点编号集合
    struct np_kind * np_kind_next;
};

void main( )
{
    int startt,finishh;
    struct node *Adj[ N ];
    struct np *NP, *head_NP, *break_NP;
    struct np_kind *Information, *Information_temp, *Information_last, *head_Information;
    struct node_set *node_set_temp;

    int i, k;//i在初始化邻接矩阵时用，j在初始化NP时用, k在添边时使用
    long *Select( long *select_node, struct np *NP, struct node *A[ N ] );//声明选点函数
    struct np_kind *Update_Information( struct np_kind * head_Information, struct node*Adj[],long *edge_point );//声明更新Information函数
    long Update_Adj( struct node *Adj[ ], struct np_kind  *head_Information, long *edge_point ); //更新Adj
    struct np* Update_NP( struct node *Adj[ ], struct np *head_NP, long *edge_point ); //更新NP

    long break_condition;//跳出循环
    long edge[ 2 ];//保存被选择的点

    long *edge_point;
    long node_size_temp; //新生成的集团的规模
    edge[ 0 ] = 0;
    edge[ 1 ] = 0;
    srand( ( unsigned )time( NULL ) );  //初始化随机数发生器种子
    startt = clock();/////////////////////////////////////////////////////时间起点

    //开辟链表并初始化邻接矩阵
    for( i = 0; i < N; i++ )
    {
        Adj[ i ] = ( struct node* )malloc( LEN_node );
        Adj[ i ] -> node_index = i + 1;
        Adj[ i ] -> node_size = 1;
        Adj[ i ] -> color = i + 1;
        Adj[ i ] -> node_next = NULL;

        Information_temp = ( struct np_kind* )malloc( LEN_np_kind );
        node_set_temp =  ( struct node_set* )malloc( LEN_node_set );
        node_set_temp -> node_ind = i + 1;
        node_set_temp -> node_set_next = NULL;

        Information_temp -> np_color = i + 1;
        Information_temp -> node_set_point = node_set_temp;
        Information_temp -> np_kind_next = NULL;


        if ( i == 0 )
        {
            Information = Information_temp;
        }
        else
        {
            Information_last -> np_kind_next = Information_temp; 
        }

            Information_last = Information_temp;
    }
            head_Information = Information;
            
    //初始化NP
    NP =( struct np* )malloc( LEN_np );
    NP -> np_size = 1;
    NP -> ng_size = N;
    NP -> np_next = NULL;
    head_NP = NP;
    
    
    break_condition = 0;
    for ( k = 0; k < r; k ++ )
    {
        edge_point = Select( edge, head_NP, Adj );
        //测试edge_point
        //printf( "final selected nodes indexes are: %d\t%d\n",edge_point[ 0 ], edge_point[ 1 ] );
        //测试edge_point

        
    
        //更新NP,Information
    if(  Adj[ edge_point[ 0 ] ] -> color != Adj[ edge_point[ 1 ] ] -> color )
    {
        //更新Information
        head_Information = Update_Information(  head_Information, Adj,edge_point );
        head_NP = Update_NP( Adj, head_NP, edge_point ); //更新NP
    }
    /*//测试Information
        test_head_Information = head_Information;
        printf("the Information is:\n");
        while( test_head_Information -> np_kind_next != NULL )
    {
        node_set_temp = test_head_Information -> node_set_point;
        printf( "the np_color is: %d\t", test_head_Information -> np_color );
        printf( "the node_ind is: \t"); 
        system( "pause" );
        while( node_set_temp -> node_set_next != NULL )
        {
            printf( "%d\t",node_set_temp-> node_ind);
             system( "pause" );
            node_set_temp = node_set_temp -> node_set_next;
        }
         printf( "%d\t",node_set_temp-> node_ind);
         printf( "\n");
         system( "pause" );
        test_head_Information =test_head_Information -> np_kind_next ;
    }
    node_set_temp = test_head_Information -> node_set_point;
    printf( "the np_color is: %d\t", test_head_Information -> np_color );
    system( "pause" );
    printf( "the node_ind is: \t");
    while( node_set_temp -> node_set_next!= NULL )
    {
        printf( "%d\t",node_set_temp->node_ind);
         system( "pause" );
         node_set_temp = node_set_temp -> node_set_next;
    }
    printf( "%d\t",node_set_temp->node_ind);
    printf( "\n");
    system("pause");//测试Information





        //测试NP
    test_head_NP = head_NP;
    printf("the NP is:\n" );
    printf("np_size \t  ng_size \t \n" );
    while( test_head_NP -> np_next != NULL )
    {
        printf(" %d \t %d \t \n" ,test_head_NP -> np_size, test_head_NP -> ng_size );
        test_head_NP =test_head_NP -> np_next;
    }
    printf(" %d \t %d \t \n" ,test_head_NP -> np_size, test_head_NP -> ng_size );
    
    system("pause");
        //测试NP
        */

        //更新Adj
        node_size_temp = Update_Adj( Adj,head_Information, edge_point); //更新Adj
    /*    //测试Adj
    printf(" The Adj is:\n");
    for( i = 0; i < N; i ++ )
    {
      test_Adj = Adj[ i ];
      printf(" %d-th node adject's information is : \n", i );
      printf("node_index \t color \t node_size \n");
      while( test_Adj -> node_next != NULL )
      {
          printf("%d \t %d \t %d\n", test_Adj -> node_index, test_Adj -> color,test_Adj -> node_size  );
          test_Adj = test_Adj -> node_next ;
      }

 
          printf("%d \t %d \t %d\n", test_Adj -> node_index, test_Adj -> color,test_Adj -> node_size  );
    }
    system("pause");
    //测试Adj
    */

        if( ( node_size_temp > npmax ) || ( node_size_temp == npmax ) )
        {
            npmax = node_size_temp;
        }
        
        printf( "the npmax is:%d\n", npmax );
            //system( "pause" );

            //结束循环，即停止加边
        break_NP = head_NP;
        break_condition = 0;
        while( break_NP -> np_next != NULL )
        {
            break_condition = break_condition + break_NP -> ng_size;
            break_NP = break_NP -> np_next;
        }
        break_condition = break_condition + break_NP -> ng_size;
        
        if ( break_condition == 1 )
            break;


    //system("pause");

    }
    
  finishh = clock();
  printf( " time is: %f", finishh - startt );
  system( "pause" );
};


//选点函数
long *Select( long *select_node, struct np* head_NP , struct node  *A[ ])
{ 
    double Get_random(   );
    long Node_position( double rand_value, struct np *head_NP, struct node * A[ ], int i_order, int node_index1 );
    double rand_value;
    //选择两个点
    int i;/////////////////////////////////////////////
    
    for ( i = 0; i < 2; i ++ )
    {
        rand_value = Get_random(   );
        if( i == 0)
        {
            /*printf( "the first rand_value is: %f\n",rand_value );
            system( "pause" );*/
            select_node[ i ] = Node_position( rand_value, head_NP, A, 0, 0 );
            //printf( "the first node is: %d\n",select_node[ i ] );//测试
        }
        if( i == 1 )
        {
            /*printf( "\nthe second rand_value is: %f\n",rand_value );
            system( "pause" );*/
            select_node[ i ] = Node_position( rand_value,head_NP, A, 1, select_node[ 0 ] );
            //printf( "\nthe second node is: %d\n",select_node[ i ] );//测试
            
        }
    }
    return ( select_node );
}
    



 //产生随机数的函数
double Get_random(   )
{
    double rand_value;  
    rand_value = rand()/(double)(RAND_MAX);
    return( rand_value );
}


//确定被选择的节点的标号
long Node_position( double rand_value, struct np *head_NP, struct node  *A[ ], int i_order, int node_index1 )
{
    struct np *temp1,*temp2;//分别在计算集团种类的平均值,几率归一化因子时使用;
    struct node *temp3;
    int i, k, m; //i统计集团种类,k判断节点编号,m用来初始化A_temp
    double  x, temp_x, sum_position, normalization_temp, normalization_temp_x, normalization2;//normalization,x在计算几率归一化时使用，sum_Np在计算集团种类的平均值时使用,
    static double sum_Np, normalization;
    //sum_position在确定节点的位置时使用
    long A_temp[ N ];
    

    
    
    if ( i_order == 0 )
    {
        //计算集团种类的平均值
        temp1 = head_NP;
        sum_Np = 0;
        i = 0;
        while( temp1 -> np_next != NULL )
        {
            sum_Np = sum_Np + temp1 -> np_size;
            i = i + 1;
            temp1 = temp1 -> np_next;
        }
        i = i + 1;
        sum_Np = sum_Np + temp1 -> np_size;
        sum_Np = sum_Np / i;
        sum_Np = sum_Np / npmax;

        

        //计算归一化系数
        temp2 = head_NP;
        normalization  = 0;
        while( temp2 -> np_next != NULL )
        {
            x = ( double )temp2 -> np_size / ( double ) npmax;
            temp_x = -( double )alpha * ( x - sum_Np ) * ( x - sum_Np );
            normalization = normalization + x * exp( temp_x ) * temp2 -> ng_size;
            temp2 = temp2 -> np_next;
        }
        x = ( double )temp2 -> np_size / ( double )npmax;
        temp_x = -( double )alpha * ( x - sum_Np ) * ( x - sum_Np );
        normalization = normalization + x * exp( temp_x ) * temp2 -> ng_size;

    
        //确定节点的位置
        sum_position = 0;    
        for( k = 0; k < N; k ++ )
        {   
            x = ( double )A[ k ] -> node_size / ( double )npmax;
            temp_x = -alpha * ( x - sum_Np ) * ( x - sum_Np );
        
            sum_position = sum_position + ( double )1 / ( double )npmax *exp( temp_x ) / normalization;
        
            if ( ( sum_position > rand_value) || ( sum_position == rand_value ) )
                break;

        }

    }

    else  //选择第二个点
    {
        //初始化A_temp矩阵
        for ( m = 0; m < N; m ++ ) 
        {
            A_temp[ m ] = m + 1;
        }
        
        //找出已经存在连接关系的点并置0
        temp3 = A[ node_index1 ];
        normalization_temp = 0;
        while( temp3 -> node_next != NULL )
        {
            
            A_temp[ ( temp3 -> node_index ) - 1 ]  = 0;
            x = ( double )temp3 -> node_size /  ( double )npmax;
            normalization_temp_x = -alpha * ( x - sum_Np ) * ( x - sum_Np );
            normalization_temp = normalization_temp + ( double )1 / npmax *exp( normalization_temp_x );
            temp3 = temp3 -> node_next;
        }
            
            A_temp[ temp3 -> node_index - 1 ]  = 0;
            x = ( double )temp3 -> node_size / ( double )npmax;
            normalization_temp_x = -( double )alpha * ( x - sum_Np ) * ( x - sum_Np );
            normalization_temp = normalization_temp + ( double )1 / npmax *exp( normalization_temp_x );
            normalization2 = normalization - normalization_temp;

            /*//测试A_temp
             printf(" A_temp are:");
            for( m = 0; m < N; m ++ )
                printf(" %d\t", A_temp[ m ]);
            //测试A_temp*/
           
        //确定节点的位置
        sum_position = 0;    
        for( k = 0; k < N; k ++ )
        {   
            if( A_temp[ k ] == 0 )
                continue;

            else
            {
                x = ( double )A[ k ] -> node_size / ( double )npmax;
                temp_x = -( double )alpha * ( x - sum_Np ) * ( x - sum_Np );
        
                sum_position = sum_position + ( double )1 / npmax *exp( temp_x ) / normalization2;
        
                if ( ( sum_position > rand_value) || ( sum_position == rand_value ) )
                    break;
            }
            
        }
    }
    return( k );
}


//更新Information
struct np_kind *Update_Information( struct np_kind * head_Information, struct node*Adj[],long *edge_point )
{
    struct node *p1, *p2;
    struct node_set *node_set_temp1, *node_set_temp3, *node_set_temp4;
    long color_temp;
    struct np_kind *Information_temp,*Information_temp1, *Information_before;
    
    p1 = Adj[ edge_point[ 0 ] ];
    p2 = Adj[ edge_point[ 1 ] ];

    Information_temp = head_Information;
    if( ( p1 -> color > p2 -> color )  )
    {
        color_temp = p2 -> color;
            
        while( Information_temp -> np_kind_next != NULL ) //先找到颜色标号大的集团位置
        {
            if( Information_temp -> np_color == p1 -> color )
                break;
            Information_before = Information_temp;
            Information_temp = Information_temp -> np_kind_next;
        }

        Information_temp1 = head_Information;//找到颜色标号小的位置
        while( Information_temp1 -> np_kind_next != NULL )
        {

            if( Information_temp1 -> np_color == p2 -> color )
                break;
            Information_temp1 = Information_temp1 -> np_kind_next;
        }
            
        node_set_temp1 = Information_temp -> node_set_point;
        node_set_temp4 = Information_temp1 -> node_set_point;
        while( node_set_temp4 -> node_set_next != NULL )
        {
            node_set_temp4 = node_set_temp4 -> node_set_next;
        }
            
            
        while( node_set_temp1 -> node_set_next != NULL)
        {
            node_set_temp3 = ( struct node_set* )malloc( LEN_node_set );
            node_set_temp3 -> node_ind = node_set_temp1 -> node_ind;
            node_set_temp3 -> node_set_next = NULL;
            node_set_temp4 -> node_set_next = node_set_temp3;
            node_set_temp4 = node_set_temp3;
            node_set_temp1 = node_set_temp1 -> node_set_next;
        }
            node_set_temp3 = ( struct node_set* )malloc( LEN_node_set );
            node_set_temp3 -> node_ind = node_set_temp1 -> node_ind;
            node_set_temp3 -> node_set_next = NULL;
            node_set_temp4 -> node_set_next = node_set_temp3;

        //删除颜色大集团的节点
                Information_before -> np_kind_next = Information_temp -> np_kind_next;
    }


    if( ( p1 -> color < p2 -> color )  )
    {
        color_temp = p1 -> color;
        while( Information_temp -> np_kind_next != NULL) //先找到颜色标号大的集团位置
        {
            if( Information_temp -> np_color == p2 -> color )
                break;
            Information_before = Information_temp;
            Information_temp = Information_temp -> np_kind_next;
        }

        Information_temp1 = head_Information;//找到颜色标号小的位置
        while( Information_temp1 -> np_kind_next != NULL )
        {

            if( Information_temp1 -> np_color == p1 -> color )
                break;
            Information_temp1 = Information_temp1 -> np_kind_next;
        }
            
        node_set_temp1 = Information_temp -> node_set_point;
        node_set_temp4 = Information_temp1 -> node_set_point;
        while( node_set_temp4 -> node_set_next != NULL )
        {
            node_set_temp4 = node_set_temp4 -> node_set_next;
        }
            
            
        while( node_set_temp1 -> node_set_next != NULL)
        {
            node_set_temp3 = ( struct node_set* )malloc( LEN_node_set );
            node_set_temp3 -> node_ind = node_set_temp1 -> node_ind;
            node_set_temp3 -> node_set_next = NULL;
            node_set_temp4 -> node_set_next = node_set_temp3;
            node_set_temp4 = node_set_temp3;
            node_set_temp1 = node_set_temp1 -> node_set_next;
        }
            node_set_temp3 = ( struct node_set* )malloc( LEN_node_set );
            node_set_temp3 -> node_ind = node_set_temp1 -> node_ind;
            node_set_temp3 -> node_set_next = NULL;
            node_set_temp4 -> node_set_next = node_set_temp3;

        //删除颜色大集团的节点
                Information_before -> np_kind_next = Information_temp -> np_kind_next;

    }

 return( head_Information );
}


//更新NP
struct np* Update_NP( struct node *Adj[ ], struct np *head_NP, long *edge_point ) //更新NP
{
    struct node *p1, *p2;
    struct np *temp_head_NP, *temp1_head_NP, *temp2_head_NP, *temp3_head_NP, *temp4_head_NP, *temp5_head_NP;
    int isexist;
    long temp_np_size;

    p1 = Adj[ edge_point[ 0 ] ];
    p2 = Adj[ edge_point[ 1 ] ]; 

    temp_np_size = p1 -> node_size + p2 -> node_size;
    //先操作新生成的集团 
    temp_head_NP = head_NP;

    isexist = 0;
    while( temp_head_NP -> np_next != NULL )
    {
        if( temp_head_NP -> np_size == temp_np_size )
        {
            isexist = 1;
            break;
        }

        temp_head_NP = temp_head_NP -> np_next;
    }

    if( temp_head_NP -> np_size == temp_np_size )
        {
            isexist = 1;
        }
    //printf( "isexist is :%d", isexist );
    //system("pause");

    if ( isexist == 0 ) //说明是新生成的集团类型
    {
        temp1_head_NP = ( struct np* )malloc( LEN_np );
        temp1_head_NP -> np_size = temp_np_size;
        temp1_head_NP -> ng_size = 1;
        temp1_head_NP -> np_next = NULL;
        temp_head_NP -> np_next = temp1_head_NP;
    /*    //测试NP
    test_head_NP = head_NP;
    printf("the NP----->>>>isexist == 0 is:\n" );
    printf("np_size \t  ng_size \t \n" );
    while( test_head_NP -> np_next != NULL )
    {
        printf(" %d \t %d \t \n" ,test_head_NP -> np_size, test_head_NP -> ng_size );
        test_head_NP =test_head_NP -> np_next;
    }
    printf(" %d \t %d \t \n" ,test_head_NP -> np_size, test_head_NP -> ng_size );
    
    system("pause");
        //测试NP
        */
    }


    if( isexist == 1 )//说明是已经存在的集团
    {
        temp_head_NP -> ng_size = temp_head_NP-> ng_size  + 1;
    }

    //开始选择被选择的集团
    //第一个集团
    temp2_head_NP = head_NP;
    if ( ( temp2_head_NP -> np_size == p1 -> node_size ) && (  ( temp2_head_NP -> ng_size - 1 ) == 0) )
        {
            head_NP = temp2_head_NP -> np_next;
        }

    else
    {
        while( temp2_head_NP -> np_size != p1 -> node_size )
            {
                temp3_head_NP = temp2_head_NP;
                temp2_head_NP = temp2_head_NP -> np_next;
            }


        temp2_head_NP -> ng_size = temp2_head_NP -> ng_size - 1;


        if(  temp2_head_NP -> ng_size == 0  )
            {
                temp3_head_NP -> np_next = temp2_head_NP -> np_next;
            }
    }

/*//测试NP
    test_head_NP = head_NP;
    printf("the NPppppppp is:\n" );
    printf("np_size \t  ng_size \t \n" );
    while( test_head_NP -> np_next != NULL )
    {
        printf(" %d \t %d \t \n" ,test_head_NP -> np_size, test_head_NP -> ng_size );
        test_head_NP =test_head_NP -> np_next;
    }
    printf(" %d \t %d \t \n" ,test_head_NP -> np_size, test_head_NP -> ng_size );
    
    system("pause");
        //测试NP
    */

    //第二个集团
    temp4_head_NP = head_NP;

    if ( ( temp4_head_NP -> np_size == p2 -> node_size ) && ( 0 == temp4_head_NP -> ng_size - 1))
        {
            head_NP = temp4_head_NP -> np_next;
        }
    else
        {
        while( temp4_head_NP -> np_size != p2 -> node_size )
            {
                temp5_head_NP = temp4_head_NP;
                temp4_head_NP = temp4_head_NP -> np_next;
            }
        temp4_head_NP -> ng_size = temp4_head_NP -> ng_size - 1;

        if( temp4_head_NP -> ng_size == 0 )
            {
                temp5_head_NP -> np_next  = temp4_head_NP -> np_next;
            }
        }

    /*test_head_NP = head_NP;
    printf("the NPnnnnnnnnnnnnn is:\n" );
    printf("np_size \t  ng_size \t \n" );
    while( test_head_NP -> np_next != NULL )
    {
        printf(" %d \t %d \t \n" ,test_head_NP -> np_size, test_head_NP -> ng_size );
        test_head_NP =test_head_NP -> np_next;
    }
    printf(" %d \t %d \t \n" ,test_head_NP -> np_size, test_head_NP -> ng_size );
    
    system("pause");
    */
    return( head_NP );
}

///更新Adj
long Update_Adj( struct node *Adj[ ], struct np_kind  *head_Information, long *edge_point )
{
    struct node *p1, *p2, *p3, *p4, *p5;
    struct np_kind  *temp_Information;
    struct node_set *temp_node_set;

    long node_size_temp, color_temp;
    p1 = Adj[ edge_point[ 0 ] ];
    p2 = Adj[ edge_point[ 1 ] ];

        //  更新Adj
        p3 = ( struct node* ) malloc( LEN_node );
        p3 -> node_index = p2-> node_index;
        p3 -> node_size = p2 -> node_size;
        p3 -> color = p2 -> color;
        p3 -> node_next = NULL;

        p4 = ( struct node* ) malloc( LEN_node );
        p4 -> node_index = p1 -> node_index;
        p4 -> node_size = p1 -> node_size;
        p4 -> color = p1 -> color;
        p4 -> node_next = NULL;
        
        while( p1 -> node_next != NULL )
        {
            p1 = p1 -> node_next;
        }
        p1 -> node_next = p3;

        
        while( p2 -> node_next != NULL )
        {
            p2 = p2 -> node_next;
        }
        p2 -> node_next = p4;


    p1 = Adj[ edge_point[ 0 ] ];
    p2 = Adj[ edge_point[ 1 ] ];
    node_size_temp = npmax;
    
    if( p1 -> color != p2 -> color ) //集团之间加边
    {
        node_size_temp = p1 -> node_size + p2 -> node_size;

        if( ( p1 -> color > p2 -> color ) || ( p1 ->color == p2 -> color ) )
        {
            color_temp = p2 -> color;
        }
        else
        {
            color_temp = p1 -> color;
        }

        temp_Information = head_Information;
        while( temp_Information -> np_color  != color_temp )//找出颜色标号小的集团在Informatiom中的位置
        {
            temp_Information = temp_Information -> np_kind_next;
        }
        temp_node_set = temp_Information -> node_set_point;

        while( temp_node_set -> node_set_next != NULL )//找出颜色标号小的集团中节点标号的最后位置
        {
            p5 = Adj[ temp_node_set -> node_ind - 1 ];
            while(  p5 -> node_next != NULL )
            {
                p5 -> color = color_temp;
                p5 -> node_size = node_size_temp;
                p5 = p5 -> node_next;
            }
            p5 -> color = color_temp;
            p5 -> node_size = node_size_temp;

            temp_node_set = temp_node_set -> node_set_next;

        }

        p5 = Adj[ temp_node_set -> node_ind - 1 ];
        while(  p5 -> node_next != NULL )
        {
            p5 -> color = color_temp;
            p5 -> node_size = node_size_temp;
            p5 = p5 -> node_next;
        }
        p5 -> color = color_temp;
        p5 -> node_size = node_size_temp;

    }


    return( node_size_temp );
    }