シングルチェーン表の添削は基本操作を調べます.

    //    
    typedef int dataType;   
    typedef struct _node  
    {  
        dataType data;              //           
        struct _node *next;          //          
    }LinkNode,*LinkedList;  

    //                            

    //1.    ， data NULL        
    LinkedList listCreatNode(dataType data)
    {
        LinkedList p = NULL;

        p = (LinkedList)malloc(sizeof(LinkNode));
        if(p == NULL)
        {
            perror("listCreatNode err");
            return NULL;
        }
        p->data = data;
        p->next = NULL;
        return p;
    }

    //2.                     
    int listInsertHead(LinkedList L,dataType data)
    {
        LinkedList node = listCreatNode(data);
        if(node == NULL)
        {
            perror("listCreatNode err");
            return -1;
        }
        node->next = L->next;   //                 （    ）
        L->next = node;         //                （      ）
        return 0;

    }
    //3.                    
    int listInsertTail(LinkedList L,dataType data)
    {
        LinkedList temp;
        temp = L;
        LinkedList node = listCreatNode(data);
        if(node == NULL)
        {
            perror("listCreatNode err");
            return -1;
        }
        while(temp->next != NULL)   //        
        {
            temp = temp->next;
        }
        temp->next = node;
        return 0;
    }
    //4.      
    int listInsertIndex(LinkedList L,int i,dataType data)
    {
        int n = 0;
        LinkedList temp = L;

        while(temp->next && n < (i-1))
        {
            n++;
            temp = temp->next;
        }
        if(n < (i-1) || !temp)
        {
            return -2;//      
        }
        LinkedList node = listCreatNode(data);
        if(node == NULL)
        {
            perror("listCreatNode err");
            return -1;
        }
        node->next = temp->next;
        temp->next = node;
        return 0;

    }
    //5.       ，         
    int listGetValue(LinkedList L,int i,dataType *data)
    {
        int n = 0;
        LinkedList temp = L;
        while(temp->next && n < i)
        {
            n++;
            temp = temp->next;
        }
        if(n < i)
        {
            return -2;//      
        }
        *data = temp->data;
        return 0;
    }
    //6.     ，            
    dataType* listGetIndex(LinkedList L,int *i,dataType data)
    {
        int n = 0;
        LinkedList temp = L;
        while(temp->next)
        {
            temp = temp->next;
            n++;
            if(data == temp->data)
            {
                *i = n;
                return &(temp->data);
            }
        }
        return NULL;
    }
    //7.       
    /*!
     * @brief listChangeValue
     *                 
     * @param L             
     * @param olddata               
     * @param newdata               
     *        - 
     *        - 
     * @return  > 0        
                < 0     ，   
     */
    int listChangeValue(LinkedList L,dataType olddata,dataType newdata)
    {
        LinkedList temp = L;
        int flag = 0;
        while(temp->next)
        {
            if(temp->data == olddata)
            {
                temp->data = newdata;
                flag++;
            }
            temp = temp->next;
        }
        if(flag)
            return flag;
        else
            return -1;
    }
    //8.    
    /*!
     * @brief listDeleteValue
     *              
     * @param L             
     * @param data             
     *        - 
     *        - 
     * @return  > 0        
                < 0     ，   
     */
    int listDeleteValue(LinkedList L,dataType data)
    {
        LinkedList temp = L;
        LinkedList tempn = L->next;
        int flag = 0;
        while(tempn->next)
        {

            if(tempn->data == data)
            {
                temp->next = tempn->next;
                free(tempn);
                flag++;
            }
            temp = temp->next;
            tempn = temp->next;
        }
        if(flag)
            return flag;
        else
            return -1;
    }
    //9.    
    int listClearList(LinkedList L)
    {
        LinkedList temp = L;
        while(L->next)
        {
            temp = L;
            L= L->next;
            free(temp);
        }
        return 0;
    }
    //10.    printList
    int printLinkList(LinkedList L)
    {
        LinkedList temp = L;
        while(temp->next)
        {
            temp = temp->next;
            printf("%4d ",temp->data);
        }
        printf("\r
");
        return 0;
    }
    //    
    int main()
    {

        //  
        int m_data = 0,m_index = 0;
        LinkedList hList;
        hList = listCreatNode(NULL);    //     

        for(int i = 100;i < 110;i++)
            listInsertTail(hList,i);    //      
        printLinkList(hList);

        listInsertHead(hList,99);       //           
        printLinkList(hList);

        listInsertIndex(hList,2,98);    //            
        printLinkList(hList);

        listGetValue(hList,2,&m_data);  //        
        printf("getValue=%d\r
",m_data);

        listGetIndex(hList,&m_index,103);//             
        printf("getIndex=%d\r
",m_index);

        listChangeValue(hList,105,100); //       
        printLinkList(hList);

        listDeleteValue(hList,100);     //            
        printLinkList(hList);


        listClearList(hList);           //      


        system("pause");

        return 0;
    }

 100  101  102  103  104  105  106  107  108  109
  99  100  101  102  103  104  105  106  107  108  109
  99   98  100  101  102  103  104  105  106  107  108  109
getValue=98
getIndex=6
  99   98  100  101  102  103  104  100  106  107  108  109
  99   98  101  102  103  104  106  107  108  109
       . . .