双向链表的查找 c语言,C语言实现双向链表的创建、插入、打英查找、删除等

#include

#include

#include "malloc.h"

typedef struct DoubleNode

{

int data;

DoubleNode

*pleft; // front point

DoubleNode *pright; //

behind point

}DoubleNode;

DoubleNode * CreateDoubleNode(int data)

{

DoubleNode *pNewNode =

(DoubleNode *)malloc(sizeof(DoubleNode));

assert(NULL !=

pNewNode);

pNewNode->data =

data;

pNewNode->pleft =

pNewNode->pright = pNewNode;

return pNewNode;

}

DoubleNode * CreateDoubleLinkList()

{

DoubleNode *pNewNode =

(DoubleNode *)malloc(sizeof(DoubleNode));

assert(NULL !=

pNewNode);

pNewNode->data =

0;

pNewNode->pleft =

pNewNode->pright = NULL;

return pNewNode;

}

DoubleNode * AddDoubleAtLast(DoubleNode *pHead, int

data)

{

assert(NULL !=

pHead);

DoubleNode *pAddNode =

CreateDoubleNode(data);

assert(NULL !=

pAddNode);

DoubleNode *pLast =

pHead;

DoubleNode *pBeforeLast

= NULL;

while (NULL !=

pLast)

{

pBeforeLast = pLast;

pLast = pLast->pright;

}

assert(NULL !=

pBeforeLast);

pBeforeLast->pright =

pAddNode;

pAddNode->pleft =

pBeforeLast;

pAddNode->pright =

NULL;

return pHead;

}

int GetDoubleLinkListLength(DoubleNode *pHead)

{

assert(NULL !=

pHead);

int ListLength =

0;

DoubleNode *pNode =

pHead->pright;

while (NULL !=

pNode)

{

ListLength++;

pNode = pNode->pright;

}

return ListLength;

}

void PrintDoubleLinkList(DoubleNode *pHead)

{

assert(NULL !=

pHead);

DoubleNode *pNode =

pHead;

while (NULL !=

pNode)

{

printf("%d\t", pNode->data);

pNode = pNode->pright;

}

printf("\n");

}

DoubleNode *FindeDoubleNode(DoubleNode *pHead, int data)

{

assert(NULL !=

pHead);

DoubleNode *pNode =

pHead;

while (NULL !=

pNode)

{

if (data == pNode->data)

{

return

pNode;

}

pNode = pNode->pright;

}

return NULL;

}

void InsertDoubleNodeAfter(DoubleNode *pNode, int data)

{

assert(NULL !=

pNode);

DoubleNode *pInsert =

(DoubleNode *)malloc(sizeof(DoubleNode));

assert(NULL !=

pInsert);

pInsert->data =

data;

if (NULL ==

pNode->pright)//insert node at last

{

pNode->pright = pInsert;

pInsert->pleft = pNode;

pInsert->pright = NULL;

}

else

{

pInsert->pright = pNode->pright;

pInsert->pleft = pNode;

pNode->pright->pleft = pInsert;

pNode->pright = pInsert;

}

}

DoubleNode * DeleteDoubleNode(DoubleNode **pHead, int

data)

{

assert(NULL !=

*pHead);

DoubleNode *pDel =

FindeDoubleNode(*pHead, data);

if (NULL == pDel)

{

return NULL;

}

else if (NULL ==

pDel->pleft)

{

*pHead = (*pHead)->pright;

if (NULL != *pHead)

{

(*pHead)->pleft = NULL;

}

}

else if (NULL ==

pDel->pright)

{

pDel->pleft->pright = NULL;

pDel->pleft = NULL;

pDel->pright = NULL;

}

else

{

pDel->pleft->pright =

pDel->pright;

pDel->pright->pleft =

pDel->pleft;

pDel->pleft = NULL;

pDel->pright = NULL;

}

free(pDel);

pDel = NULL;

return *pHead;

}

DoubleNode * CreateCircleDoubleNode(int data)

{

DoubleNode *pNewNode =

(DoubleNode *)malloc(sizeof(DoubleNode));

assert(NULL !=

pNewNode);

pNewNode->data =

data;

pNewNode->pright =

pNewNode;

pNewNode->pleft =

pNewNode;

return pNewNode;

}

DoubleNode * AppendDoubleNodeList(DoubleNode *pHead, int

data)

{

assert(NULL !=

pHead);

DoubleNode *pNew =

CreateCircleDoubleNode(data);

assert(NULL !=

pNew);

DoubleNode *pTempHead =

pHead->pright;

DoubleNode *pTail =

pHead;

while (pHead !=

pTempHead)

{

pTail = pTempHead;

pTempHead = pTempHead->pright;

}

pTail->pright =

pNew;

pNew->pleft =

pTail;

pHead->pleft =

pNew;

pNew->pright =

pHead;

return pHead;

}

void PrintCircleDoubleLinkList(DoubleNode *pHead)

{

assert(NULL !=

pHead);

printf("%d\t",

pHead->data);

DoubleNode *pNode =

pHead->pright;

while (pHead !=

pNode)

{

printf("%d\t", pNode->data);

pNode = pNode->pright;

}

printf("\n");

}

DoubleNode * InsertSortDoubleLinkList(DoubleNode **pHead, int

data)

{

assert(NULL !=

*pHead);

DoubleNode *pNew =

(DoubleNode *)malloc(sizeof(DoubleNode));

assert(NULL !=

pNew);

pNew->data =

data;

if (pNew->data <

(*pHead)->data)

{

pNew->pright = *pHead;

pNew->pleft = (*pHead)->pleft;

pNew->pleft->pright =

pNew;

(*pHead)->pleft = pNew;

*pHead = pNew;

}

else

{

DoubleNode *pFindPos =

(*pHead)->pright;

DoubleNode *pFindPosNext = NULL;

while (pFindPos != *pHead &&

pNew->data > pFindPos->data)

{

pFindPos =

pFindPos->pright;

}

pFindPosNext = pFindPos;

pFindPos = pFindPos->pleft;

// pNew between pFindPos and

pFindPosNext

pFindPos->pright = pNew;

pNew->pleft = pFindPos;

pFindPosNext->pleft = pNew;

pNew->pright = pFindPosNext;

}

return *pHead;

}

DoubleNode *FindCircleNode(DoubleNode *pHead, int data)

{

assert(NULL !=

pHead);

DoubleNode *pFind =

NULL;

DoubleNode *pNode =

pHead;

do

{

if (pNode->data == data)

{

pFind =

pNode;

break;

}

pNode = pNode->pright;

} while (pNode !=

pHead);

return pFind;

}

DoubleNode * FindSameNode(DoubleNode *pHead1, DoubleNode

*pHead2)

{

assert(NULL !=

pHead2);

assert(NULL !=

pHead1);

DoubleNode *pSameHead =

NULL;

DoubleNode *pTempNode1 =

pHead1;

DoubleNode *pTempNode2 =

pHead2;

do

{

do

{

if

(pTempNode1->data == pTempNode2->data)

{

if (NULL == pSameHead)

{

pSameHead =

CreateDoubleNode(pTempNode1->data);

}

else

{

if (NULL == FindCircleNode(pSameHead,

pTempNode1->data))

{

AppendDoubleNodeList(pSameHead, pTempNode1->data);

}

}

}

pTempNode2

= pTempNode2->pright;

} while (pHead2 != pTempNode2);

pTempNode1 = pTempNode1->pright;

} while (pHead1 !=

pTempNode1);

return

pSameHead;

}

DoubleNode * DelCircleNode(DoubleNode *pHead, int data)

{

assert(NULL !=

pHead);

DoubleNode *pTempHead =

pHead;

DoubleNode *pFind =

NULL;

do

{

if (pTempHead->data == data)

{

if

(pTempHead == pHead)

{

pFind = pHead;

pHead =

pHead->pright;

pTempHead =

pTempHead->pright;

free(pFind);

pFind = NULL;

}

else

{

pFind = pTempHead;

pTempHead =

pTempHead->pright;

pFind->pright->pleft =

pFind->pleft;

pFind->pleft->pright =

pTempHead;

free(pFind);

pFind = NULL;

}

}

else

{

pTempHead

= pTempHead->pright;

}

} while (pHead !=

pTempHead && NULL != pTempHead);

return pHead;

}

void DelSameNode(DoubleNode **pHead1, DoubleNode

**pHead2)

{

assert(NULL !=

*pHead2);

assert(NULL !=

*pHead1);

DoubleNode *pSameList =

FindSameNode(*pHead1, *pHead2);

if (NULL !=

pSameList)

{

DoubleNode *pSameNode = pSameList;

do

{

*pHead1 =

DelCircleNode(*pHead1, pSameNode->data);

*pHead2 =

DelCircleNode(*pHead2, pSameNode->data);

pSameNode

= pSameNode->pright;

} while (pSameList != pSameNode);

}

}

int main()

{

DoubleNode *pHead =

CreateCircleDoubleNode(1);

assert(NULL !=

pHead);

AppendDoubleNodeList(pHead, 3);

AppendDoubleNodeList(pHead, 4);

AppendDoubleNodeList(pHead, 7);

AppendDoubleNodeList(pHead, 9);

AppendDoubleNodeList(pHead, 11);

PrintCircleDoubleLinkList(pHead);

DoubleNode *pHead2 =

CreateCircleDoubleNode(2);

AppendDoubleNodeList(pHead2, 3);

AppendDoubleNodeList(pHead2, 6);

AppendDoubleNodeList(pHead2, 7);

AppendDoubleNodeList(pHead2, 9);

AppendDoubleNodeList(pHead2, 11);

PrintCircleDoubleLinkList(pHead2);

DelSameNode(&pHead,

&pHead2);

PrintCircleDoubleLinkList(pHead);

PrintCircleDoubleLinkList(pHead2);

return 0;

}