C：链表内部源码实现，简易

这是简易链表实现，单层的

typedef struct Node
{
    int data; // 数据
    struct Node *pNext; // 下一个跟自己相同数据结构的指针
}NODE,*PNODE;

PNODE init_Node(int len);
void show_Node(PNODE pHead);
int length_Node(PNODE pHead);
bool isEmpty_Node(PNODE pHead);
// 不存在这个，因为如果有两个数据节点，只能插入到第一个或者第二个的位置，不存在后面拼接，插入到第二个位置就是把原来第二个的位置的指针指向现在的插入的数据，其实，在最后面的数据永远都是最后面的。
//bool append_Node(PNODE pHead, int value);
bool insert_Node(PNODE pHead, int value, int index);
bool delete_Node(PNODE pHead, int *value, int index);
// 泛型
bool sort_Node(PNODE pHead);

int main()
{
    int *cou = NULL;
    PNODE nod = init_Node(2);
    show_Node(nod);
    insert_Node(nod, 32, 0);
    insert_Node(nod, 22, 1);
    insert_Node(nod, 92, 1);
    insert_Node(nod, 12, 3);
//    show_Node(nod);
//    delete_Node(nod, cou, 1);
//    show_Node(nod);
//    delete_Node(nod, cou, 1);
    show_Node(nod);
    sort_Node(nod);
    show_Node(nod);
    return 0;
}

PNODE init_Node(int len)
{
    
    PNODE pHead = (PNODE)malloc(sizeof(NODE));
    if (NULL == pHead) {
        exit(-1);
    }
    PNODE pL = pHead;
    for (int i = 0; i <len; i ++) {
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if (NULL == pNew) {
            exit(-1);
        }
        
        pNew->data = i;
        pL->pNext = pNew;
        pL = pNew;
    }
    pL->pNext = NULL;
    return pHead;
}
void show_Node(PNODE pHead)
{
    if (isEmpty_Node(pHead))
        return;
    PNODE pE = pHead->pNext;
    while (NULL != pE) {
        printf("%d ",pE->data);
        pE = pE->pNext;
    }
    printf("\n");
}
bool isEmpty_Node(PNODE pHead)
{
    if (NULL == pHead->pNext) {
        printf("该链表为空\n");
        return true;
    }
    return false;
}
int length_Node(PNODE pHead)
{
    if (isEmpty_Node(pHead))
        return 0;
    int cou = 0;
    PNODE pE = pHead->pNext;
    while (NULL != pE) {
        ++cou;
        pE = pE->pNext;
    }
    printf("\n");
    return cou;
}
//bool append_Node(PNODE pHead, int value)
//{
//    if (isEmpty_Node(pHead))
//        return false;
//    PNODE pE = pHead;
//    while (NULL != pE) {
//        printf("%d ",pE->data);
//        pE = pE->pNext;
//    }
//    PNODE pNew = (PNODE)malloc(sizeof(NODE));
//    pNew->data = value;
//    pNew->pNext = NULL;
//    PNODE pNewd = pE->pNext;
//    pNewd = pNew;
//    return true;
//}

bool insert_Node(PNODE pHead, int value, int index)
{
    if (isEmpty_Node(pHead))
        return false;
    
    PNODE p = pHead;
    int i = 0;
    while (NULL != p && i < index) {
        p = p->pNext;
        ++i;
    }
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    if (NULL == pNew) {
        exit(-1);
    }
    pNew->data = value;
    
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;
    return true;
}
bool delete_Node(PNODE pHead, int *value, int index)
{
    int i = 0;
    if (index > length_Node(pHead) - 1) {
        return false;
    }
    PNODE p = pHead;
    while (i < index) {
        p = p->pNext;
        ++i;
    }
    
    PNODE q = p->pNext;
    p->pNext = q->pNext;
    free(q);
    return true;
}
bool sort_Node(PNODE pHead)
{
    PNODE p, q;
    int i, j, z;
    int length = length_Node(pHead);
    
    for (i = 0, p = pHead->pNext; i <length - 1; ++i, p = p->pNext) {
        for (j = i + 1, q = p->pNext; j < length; ++j,q = q->pNext) {
            if (p->data > q->data) {
                z = q->data;
                q->data = p->data;
                p->data = z;
            }
        }
    }
    
    return true;
}