链表

单向链表

typedef struct _LINKED_NODE LINKED_NODE;
struct _LINKED_NODE {
    int data;
    LINKED_NODE *next;
};

 

链表节点建立

LINKED_NODE *createLinkedNode(int nValue)
{
    LINKED_NODE *pNode=NULL;

    pNode=(LINKED_NODE *)malloc(sizeof(LINKED_NODE));
    if(pNode==NULL) return NULL;

    pNode->data=nValue;
    pNode->next=NULL;

    return pNode;
}

 

插入数据

int insertLinked(LINKED_NODE *pHead, int nValue)
{
    LINKED_NODE *pNodeNew=NULL;

    pNodeNew=createLinkedNode(nValue);
    if(pNodeNew==NULL) return 0;

    LINKED_NODE *pNodeCur=pHead;

    if(pNodeCur==NULL) {
        pNodeCur=pNodeNew;
        return 1;
    }

    while(pNodeCur->next!=NULL) pNodeCur=pNodeCur->next;
    pNodeNew=pNodeCur->next;

    return 1;
}

 

int insertLinked(LINKED_NODE **pNode, LINKED_NODE *pNewNode)
{
    if(*pNode==NULL) {
        *pNode=pNewNode;
        return 1;
    }

    insertLinked(&(*pNode)->next,pNewNode);

    return 0;
}

int insertLinked(LINKED_NODE **pHead, int nValue)
{
    if(pHead==NULL) return 0;

    LINKED_NODE *pNodeNew=NULL;

    pNodeNew=createLinkedNode(nValue);
    if(pNodeNew==NULL) return 0;

    LINKED_NODE **pNodeCur=pHead;

    if(*pNodeCur==NULL) {
        *pNodeCur=pNodeNew;
        return 1;
    }

    return insertLinked(pNodeCur, pNodeNew);
}

 

删除数据

int deleteLinked(LINKED_NODE *pHead, int nvalue)
{
    if(pHead==NULL) return 0;

    LINKED_NODE *pNodeCur=pHead;
    LINKED_NODE *PNodePrev=NULL;

    while(pNodeCur&&pNodeCur->data!=nvalue) {
        PNodePrev=pNodeCur;
        pNodeCur=pNodeCur->next;
    }

    if(pNodeCur==NULL) return 0;

    if(PNodePrev) PNodePrev->next=pNodeCur->next;
    else pHead=pNodeCur->next;

    free(pNodeCur);

    return 1;
}

 

int deleteLinked(LINKED_NODE **pHead, int nvalue)
{
    if(pHead==NULL||*pHead==NULL) return 0;

    LINKED_NODE **pNodeCur=pHead;
    LINKED_NODE *pTemp=NULL;

    while(*pNodeCur) {
        pTemp=*pNodeCur;
        if(pTemp->data==nvalue) {
            *pNodeCur=pTemp->next;
            free(pTemp);
        } else
            pNodeCur=&pTemp->next;  /****/
    }

    return 1;
}

 

查找数据

LINKED_NODE *findData(LINKED_NODE *pHead, int nValue)
{
    if(pHead==NULL) return NULL;

    LINKED_NODE *pNodeCur=pHead;

    while(pNodeCur&&pNodeCur->data!=nvalue) pNodeCur=pNodeCur->next;

    return pNodeCur;
}

 

删除链表

int deleteAllLinked(LINKED_NODE *pHead)
{
    if(pHead==NULL) return 0;

    LINKED_NODE *pNodeCur=NULL;

    while(pHead->next) {
        pNodeCur=pHead;
        pHead=pHead->next;

        free(pNodeCur);
        pNodeCur=NULL;
    }

    free(pHead);
    pHead=NULL;

    return 1;
}

 

int deleteAllLinked(LINKED_NODE **pHead)
{
    if(pHead==NULL||*pHead==NULL) return 0;

    LINKED_NODE **pNodeNext=NULL;

    pNodeNext=&(*pHead)->next;

    free(*pHead);
    *pHead=NULL;

    deleteAllLinked(pNodeNext);

    return 1;
}

 

翻转链表

void rotateAllLinked(LINKED_NODE *pHead)
{
    if(pHead==NULL) return 0;
　　
    LINKED_NODE *pTemp;
    LINKED_NODE *pNodeCur=pHead->next;
    LINKED_NODE *pNodePrev=pHead;

    pHead->next=NULL;

    if(pNodeCur) {
        pTemp=pNodeCur->next;

        pNodeCur->next=pNodePrev;

        pNodePrev=pNodeCur;
        pNodeCur=pTemp;
    }

    pHead=pNodePrev;
}

 

双向链表

typedef struct _DOUBLE_LINKED_NODE DOUBLE_LINKED_NODE;
struct _DOUBLE_LINKED_NODE {
    int data;
    DOUBLE_LINKED_NODE *prev;
    DOUBLE_LINKED_NODE *next;
};

 

插入数据

int doubleLinkedInsert(DOUBLE_LINKED_NODE *pHead, int nvalue)
{
    DOUBLE_LINKED_NODE *pNodeNew=NULL;

    pNodeNew=(DOUBLE_LINKED_NODE *)malloc(sizeof(DOUBLE_LINKED_NODE));
    if(pNodeNew==NULL) return 0;

    pNodeNew->data=nvalue;
    pNodeNew->next=NULL;
    pNodeNew->prev=NULL;

    DOUBLE_LINKED_NODE *pNodeCur=pHead;

    if(pNodeCur==NULL) {
        pNodeCur=pNodeNew;
        return 1;
    }

    while(pNodeCur->next!=NULL) pNodeCur=pNodeCur->next;
    pNodeNew=pNodeCur->next;
    pNodeNew->prev=pNodeCur;

    return 1;
}

 

删除数据

int doubleLinkedDelete(DOUBLE_LINKED_NODE *pHead, int nvalue)
{
    if(pHead==NULL) return 0;

    DOUBLE_LINKED_NODE *pNodeCur=pHead;

    while(pNodeCur&&pNodeCur->data!=nvalue) pNodeCur=pNodeCur->next;

    if(pNodeCur==NULL) return 0;

    if(pNodeCur->prev) pNodeCur->prev->next=pNodeCur->next;
    else pNodeCur->next->prev=NULL;

    if(pNodeCur->next) pNodeCur->next->prev=pNodeCur->prev;
    else pNodeCur->prev->next=NULL;

    free(pNodeCur);
    pNodeCur=NULL;

    return 1;
}

 

查找数据

DOUBLE_LINKED_NODE *doubleLinkedFind(DOUBLE_LINKED_NODE *pHead, int nvalue)
{
    if(pHead==NULL) return 0;

    DOUBLE_LINKED_NODE *pNodeCur=pHead;

    while(pNodeCur&&pNodeCur->data!=nvalue) pNodeCur=pNodeCur->next;

    return pNodeCur;
}

 

翻转链表

void doubleLinkedInsert(DOUBLE_LINKED_NODE *pHead)
{
    DOUBLE_LINKED_NODE *pTemp;
    DOUBLE_LINKED_NODE *pNodeCur=pHead->next;
    DOUBLE_LINKED_NODE *pNodePrev=pHead;

    pHead->next=NULL;

    if(pNodeCur) {
        pTemp=pNodeCur->next;
        pNodeCur->next=pNodePrev;
        pNodePrev->prev=pNodeCur;

        pNodePrev=pNodeCur;
        pNodeCur=pTemp;
    }

    pHead=pNodePrev;
    pHead->prev=NULL;
}

 

单向循环链表

逆转链表