简单c语言链表函数,C语言链表相关函数

typedef struct nNode Node;

struct nNode

{

// 向上指针

Node* nUp;

// 向下指针

Node* nDown;

// 字符串字节数

int iSize;

// 字符串指针

char* acStr;

};

typedef struct

{

Node* nTop;

Node* nBottom;

int iSize;

} List;

// 新建节点

Node* Node_new(char* acStr)

{

Node* nNode = (Node*)malloc(sizeof(Node));

// 设置向上指针

nNode->nUp = NULL;

// 设置向下指针

nNode->nDown = NULL;

// 字符串字节数

if(acStr != NULL)

nNode->iSize = strlen(acStr);

else

nNode->iSize = 0;

// 设置字符串

if(nNode->iSize != 0)

{

nNode->acStr = (char*)malloc(sizeof(char)*(nNode->iSize) + 1);

strcpy(nNode->acStr, acStr);

nNode->acStr[nNode->iSize] = '\0';

}

return nNode;

}

// 删除节点

void Node_delete(Node* nNode)

{

free(nNode->acStr);

free(nNode);

}

// 输出节点的值

void List_print(Node* nNode)

{

// 输出字符串

printf("%s\n", nNode->acStr);

}

// 新建链表

List* List_new(void)

{

List* lList = (List*)malloc(sizeof(List));

lList->iSize = 0;

lList->nTop = Node_new("");

lList->nBottom = Node_new("");

lList->nTop->nDown = lList->nBottom;

lList->nBottom->nUp = lList->nTop;

return lList;

}

// 删除链表

void List_delete(List* lList)

{

Node* nNode;

for(; lList->iSize>0; )

{

nNode = lList->nTop->nDown;

lList->nTop->nDown = lList->nTop->nDown->nDown;

Node_delete(nNode);

lList->iSize --;

}

if(lList->nTop != NULL)

Node_delete(lList->nTop);

if(lList->nBottom != NULL)

Node_delete(lList->nBottom);

lList->iSize = 0;

}

// 节点从链表顶部加入

void List_pushTop(List* lList, Node* nNewNode)

{

// 新节点 nUp 指针连接到链表顶部节点

nNewNode->nUp = lList->nTop;

// 新节点 nDown 指针连接到链表顶部节点的下一节点

nNewNode->nDown = lList->nTop->nDown;

// 链表顶部节点的下一节点 nUp 指针连接到新节点

lList->nTop->nDown->nUp = nNewNode;

// 链表顶部节点 nDown 指针连接到新节点

lList->nTop->nDown = nNewNode;

lList->iSize ++;

}

// 节点从链表顶部取出

Node* List_popTop(List* lList)

{

// 备份将要弹出的节点

Node* nNode = lList->nTop->nDown;

if(lList->iSize > 0)

{

// 链表顶部节点下下节点的 nUp 指针连接到链表顶部节点

lList->nTop->nDown->nDown->nUp = lList->nTop;

// 链表顶部节点的 nDown 指针连接到下下节点

lList->nTop->nDown= lList->nTop->nDown->nDown;

nNode->nUp = NULL;

nNode->nDown = NULL;

lList->iSize --;

}

return nNode;

}

// 节点从链表底部加入

void List_pushBottom(List* lList, Node* nNewNode)

{

// 新节点 nDown 指针连接到链表底部节点

nNewNode->nDown = lList->nBottom;

// 新节点 nUp 指针连接到链表底部节点的上一节点

nNewNode->nUp = lList->nBottom->nUp;

// 链表底部节点的上一节点 nDown 指针连接到新节点

lList->nBottom->nUp->nDown = nNewNode;

// 链表底部节点 nUp 指针连接到新节点

lList->nBottom->nUp = nNewNode;

lList->iSize ++;

}

// 节点从链表底部取出

Node* List_popBottom(List* lList)

{

// 备份将要弹出的节点

Node* nNode = lList->nBottom->nUp;

if(lList->iSize > 0)

{

// 链表底部节点上上节点的 nDown 指针连接到链表底部节点

lList->nBottom->nUp->nUp->nDown = lList->nBottom;

// 链表底部节点的 nUp 指针连接到上上节点

lList->nBottom->nUp = lList->nBottom->nUp->nUp;

nNode->nUp = NULL;

nNode->nDown = NULL;

lList->iSize --;

}

return nNode;

}

// 节点从链表指定位置插入

void List_insert(List* lList, Node* nNewNode, int iIndex)

{

Node* nOldNode = lList->nTop->nDown;

int i;

for(i=0; inDown;

// 把 nNewNode 节点插到 nOldNode 节点上面

nNewNode->nUp = nOldNode->nUp;

nNewNode->nDown = nOldNode;

nOldNode->nUp->nDown = nNewNode;

nOldNode->nUp = nNewNode;

lList->iSize ++;

}

// 从链表中移除指定节点

void List_remove(List* lList, Node* nOldNode)

{

// 断开 nOldNode节点的前后链接

nOldNode->nUp->nDown = nOldNode->nDown;

nOldNode->nDown->nUp = nOldNode->nUp;

lList->iSize --;

}

// 遍历链表

void List_traverse(List* lList, void (*visit)(Node*))

{

// 得到顶部节点指针

Node* nNode = lList->nTop;

int i, iSize = lList->iSize;

for(i=0; inDown;

visit(nNode);

}

}

// 这个节点在链表是第几个节点

int getIndex(List* lList, Node* nOldNode)

{

int i, iIndex = 0, iSize = lList->iSize;

Node* nNode = lList->nTop;

for(i=0; inDown;

if(nOldNode == nNode)

return i;

}

return -1;

}

int main(void)

{

Node* nNode = NULL;

// 创建链表

List* lList = List_new();

// 新建节点

nNode = Node_new("北京");

List_pushBottom(lList, nNode);

nNode = Node_new("上海");

List_pushBottom(lList, nNode);

List_traverse(lList, List_print);

// 删除链表

List_delete(lList);

return 0;

}