python双向链表删除元素_带头双向链表的增删打印等操作实现

#include

#include

typedef int LDataType;

//双向带头循环链表的节点

typedef struct ListNode

{

LDataType _data;

//指向下一个节点的起始位置

struct ListNode* _next;

//指向上一个节点的起始位置

struct ListNode* _prev;

}ListNode;

//双向带头循环链表

typedef struct List

{

struct ListNode* _head;

}List;

ListNode* createListNode(LDataType val)

{

ListNode* node = (ListNode*)malloc(sizeof(ListNode));

node->_data = val;

node->_next = NULL;

node->_prev = NULL;

}

void listInit(List* lst)

{

if (!lst)return;

//空链表

lst->_head = createListNode(0);

lst->_head->_next = lst->_head->_prev = lst->_head;

}

//尾插 O(1)；

void listPushBack(List* lst, LDataType val)

{

if (!lst)return;

struct ListNode* last = lst->_head->_prev;

struct ListNode* newNode = createListNode(val);

last->_next = newNode;

newNode->_prev = last;

newNode->_next = lst->_head;

lst->_head->_prev = newNode;

}

//尾删

void listPopBack(List* lst)

{

if (!lst)return;

if (lst->_head == lst->_head->_prev)

return;

struct ListNode* last = lst->_head->_prev;

struct ListNode* prev = lst->_head->_prev->_prev;

free(last);

prev->_next = lst->_head;

lst->_head->_prev = prev;

}

//打印

void printList(List* lst)

{

struct ListNode* cur = lst->_head->_next;

while (cur != lst->_head)

{

printf("%d", cur->_data);

cur = cur->_next;

}

printf("\n");

}

//头插

void listPushFront(List* lst, LDataType val)

{

if (!lst)return;

struct ListNode* next = lst->_head->_next;

struct ListNode* newNode = createListNode(val);

lst->_head->_next = newNode;

newNode->_prev = lst->_head;

newNode->_next = next;

next->_prev = newNode;

}

//头删

void listPopFront(List* lst)

{

if (!lst||lst->_head == lst->_head->_next)return;

struct ListNode* next = lst->_head->_next->_next;

struct ListNode* prev = lst->_head->_next;

lst->_head->_next = next;

next->_prev = lst->_head;

free(prev);

}

//删除某一节点

void listErase(List* lst,struct ListNode* node)

{

//不能删除head节点

if (!lst || lst->_head == node)return;

struct ListNode* prev = node->_prev;

struct ListNode* next = node->_next;

prev->_next = next;

next->_prev = prev;

free(node);

}

//某一节点前插入

void listInsert(ListNode* lst, struct ListNode* node, LDataType val)

{

if (!lst)return;

struct ListNode* newNode = createListNode(val);

struct ListNode* prev = node->_prev;

//prev newNode node

node->_prev = newNode;

newNode->_next = node;

newNode->_prev = prev;

prev->_next = newNode;

}

listDestroy(List* lst)

{

if (lst)

{

if (lst->_head)

{

struct ListNode* cur = lst->_head->_next;

while (cur != lst->_head)

{

struct ListNode* next = cur->_next;

free(cur);

cur = next;

}

free(lst->_head);

}

}

}

void test()

{

List lst;

listInit(&lst);

listPushBack(&lst, 1);

printList(&lst);

listPushBack(&lst, 2);

printList(&lst);

listPushBack(&lst, 3);

printList(&lst);

listPushBack(&lst, 4);

printList(&lst);

listPushBack(&lst, 5);

printList(&lst);

listPopFront(&lst);

printList(&lst);

listPopFront(&lst);

printList(&lst);

listPopFront(&lst);

printList(&lst);

listPopFront(&lst);

printList(&lst);

listPopFront(&lst);

printList(&lst);

}

int main()

{

test();

return 0;

}