顺序表链表的简单接口的实现 完

#include<stdlib.h>
#include<stdio.h>
//typedef int LDataType;
定义结点：数据+指针
//typedef struct ListNode
//{
// LDataType _data;
// struct ListNode* _next;
//}ListNode;
//
定义链表的结构体
//typedef struct List
//{
// //保存第一个节点的地址
// struct ListNode* _head;
//}List;
//
//struct ListNode* creatListNode(LDataType val)
//{
// struct ListNode* node = (ListNode*)malloc(sizeof(ListNode));
// node->_data = val;
// node->_next = NULL;
// return node;
//}
//
void ListInitial()
{
head->NULL;
if (lst == NULL)
{
return;
}
lst->head = NULL;
}
//
尾插操作。
//void ListPushBack(List* lst, LDataType val)
//{
// //插入的时候是两种情况，一种是空的，一种是非空
// //空的就是需要去创建，修改指针的指向
// //非空的就是遍历到最后一个位置，进行插入，遍历的标准就是哪一个下一个是空的
// if (lst == NULL)
// return;
// if (lst->_head == NULL)
// {
// //插入第一个节点
// //创建节点
// lst->_head=creatListNode(val);
// }
// else
// {
// //从第一个节点开始遍历找到最后一个节点
// struct ListNode* tail = lst->_head;
// while (tail->_next != NULL)
// {
// tail = tail->_next;
// }
// tail->_next=creatListNode(val);
// }
//}
//
尾删
//void ListPopBack(List* lst)
//{
// if (lst == NULL || lst->_head == NULL)
// return;
// //遍历，找到最后一个节点
// struct ListNode* prev = NULL;
// struct ListNode* tail = lst->_head;
// while(tail->_next!=NULL)
// {
// prev = tail;
// tail = tail->_next;
// }
// //释放最后一个节点
// free(tail);
// //更新next
// if (lst->_head->_next==NULL)//只有一个节点
// {
// //将头结点置为空
// lst->_head == NULL;
// }
// else
// prev->_next = NULL;
//}
//
头插
单链表的头插
//void ListPushFront(List* lst, LDataType val)
//{
// if (lst == NULL)
// return;
// //创建节点
// struct ListNode* node = creatListNode(val);
// //node head
// lst->_head = node;
// node->_next = lst->_head;
//}
//
头删
//void ListPopFront(List* lst)
//{
首先进行的是判空的操作
// if (lst == NULL || lst->_head == NULL)
// return;
// struct ListNode* next = lst->_head->_next;
// free(lst->_head);
// lst->_head = next;
//}
//
给某一个节点插入新的数据
//void ListInsertAfter(ListNode* node, LDataType val)
//{
// if (node == NULL)
// return;
// //创建新的节点
// ListNode* newNode = creatListNode(val);
// ListNode* next = node->_next;
// node->_next = newNode;
// newNode->_next = next;
//}
//
删除某一个数据 遍历 给一个位置。删除该位置的下一个位置
//void ListEraseAfter(ListNode* node)
//{
// if (node == NULL || node->_next == NULL)
// return;
// struct ListNode* next = node->_next;
// struct ListNode* nextnext = next->_next;
// //释放节点
// free(next);
// node->_next = nextnext;
//}
查找
//struct ListNode* ListFind(List* lst, LDataType val)
//{
// //遍历
// if (node == NULL || node->_next == NULL)
// return NULL;
// //从头结点开始遍历
// struct ListNode* cur = lst->_head;
// while (cur)
// {
// if (cur->_data == val)
// return cur;
// cur = cur->_next;
// }
// return NULL;
//}
//
销毁 注意位置的记录
//void ListDestory(List* lst)
//{
// if (lst == NULL )
// return ;
// //确定指针的位置
// ListNode* cur = lst->_head;
// while (cur)
// {
// //保存下一个结点的位置。
// ListNode* next = cur->_next;
// //释放当前姐弟啊
// free(cur);
// //更新到下一个节点的位置。
// cur = next;
// }
// lst->_head=NULL;
//}
//
删除某一个节点
//void ListErase(ListNode* node)
//{
// //需要记录位置
// if (node == NULL || node->_next == NULL)
// return NULL;
// //记录该节点的前一个位置和后一个位置 prev node next
// struct ListNode* prev = head->_next;
// struct ListNode* next = node->_next;
// while (next)
// {
// prev->_next = next;
// free(node);
// }
// return NULL;
//}
//void test()
//{
// List lst;
// //ListInit(&lst);
// /ListPushBack(&lst, 1);
// ListPushBack(&lst, 2);
// ListPushBack(&lst, 3);
// ListPushBack(&lst, 4);
// ListPushBack(&lst, 5);
//
// ListPopBack(&lst);
// ListPopBack(&lst);
// ListPopBack(&lst);
// ListPopBack(&lst);
// ListPopBack(&lst);
///
// //头插
// //ListPushFront(&lst, 1);
// //ListPushFront(&lst, 2);
// //ListPushFront(&lst, 3);
// //ListPushFront(&lst, 4);
// //ListPushFront(&lst, 5);
//
// 头删
// //ListPopFront(&lst);
// //ListPopFront(&lst);
// //ListPopFront(&lst);
// //ListPopFront(&lst);
// //ListPopFront(&lst);
//
// ListNode* cur = ListFind(&lst,3);
// ListEraseAfter(cur);
// ListInsertAfter(cur, 4);
//
//
//}
//
//int main()
//{
// test();
// return 0;
//}

//双向链表头插
// 2、带头+双向+循环链表增删查改实现
typedef int LDataType;
//创建节点
typedef struct ListNode
{
LDataType _data;
struct ListNode* _next;
struct ListNode* _prev;
struct ListNode* _head;
}ListNode;
// 创建返回链表的头结点.
//双向带头循环链表
typedef struct List
{
struct ListNode* _head;
}List;

void initList(ListNode* lst)
{
//空的带头的双向循环链表
//构建循环结构
//创建头结点
lst->_head = (struct ListNode*)malloc(sizeof(struct ListNode));
//循环
lst->_head->_prev = lst->_head->_next = lst->_head;
}
struct ListNode* creatNode(LDataType val)
{
struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
node->_data = val;
node->_next = node->_prev = NULL;
return node;
}
// 双向链表销毁
void ListDestory(ListNode* lst)
{
//第一个有效节点
struct ListNode* cur = lst->_head->_next;
while (cur)
{
struct ListNode* next = cur->_next;
free(cur);
cur = next;
}
free(lst->_head);

lst->_head = NULL;

}
// 双向链表打印
void PrintList(ListNode* lst)
{
struct ListNode* cur = lst->_head->_next;
while (cur != lst->_head)
{
printf("%d", cur->_data);
cur = cur->_next;
}
printf("\n");
}
// 双向链表尾插
void ListPushBack(ListNode* lst, LDataType val)
{
//不需要遍历，只需要头的prev来完成寻找最后一个节点
//主要是节点指向的修改 o(1)
//if (lst == NULL)
// return;
//struct ListNode* tail = lst->_head->_prev;
//struct ListNode* newNode = creatNode(val);

head......tail   newNode
//tail->_next = newNode;
//newNode->_prev = tail;

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

ListInsert(lst->_head->_next, val);

}
// 双向链表尾删
void ListPopBack(ListNode* lst)
{
if (lst->_head->_prev== lst->_head)
return;
struct ListNode* tail = lst->_head->_prev;
struct ListNode* prev = tail->_prev;
//修改指针的指向重新进行连接
free(tail);
prev->_next = lst->_head;
lst->_head->_prev = prev;

}
// 双向链表头插
void ListPushFront(ListNode* lst, LDataType val)
{
//改变第一个有效数据
/struct ListNode newNode = creatNode(val);
struct ListNode* next = lst->_head->_next;

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

next->_prev = newNode;
newNode->_next = next;*/

ListInsert(lst->_head, val);

}
// 双向链表头删
void ListPopFront(ListNode* lst)
{
if (lst->_head->_next == lst->_head)
return;
//首先是确保头结点存在
struct ListNode* next = lst->_head->_next;
struct ListNode* nextnext = next->_next;
free(next);
lst->_head->_next = nextnext;
nextnext->_prev = lst->_head;
}
双向链表查找
ListNode* ListFind(ListNode* lst, LDataType val)
{

}
双向链表在node的前面进行插入
void ListInsert(ListNode* node, LDataType val)
{
//找到任意位置的前后位置 newNode node node->next
struct ListNode* newNode = creatNode(val);
struct ListNode* prev = node->_prev;
//修改链接
node->_prev = newNode;
newNode->_next = node;

prev->_next = newNode;
newNode->_prev = prev;

}
双向链表删除pos位置的节点
void ListErase(ListNode* node)
{
//判断地址的有效性
if (node == NULL)
return;
//找到该节点的前后指针，释放空间，修改指针指向
struct ListNode* prev = node->_prev;
struct ListNode* next = node->_next;

free(node);
prev->_next = next;
next->_prev = prev;

}

void test()
{
struct ListNode lst;
initList(&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);

ListPushFront(&lst, 0);
ListPushFront(&lst, 10);
ListPushFront(&lst, 30);
ListPushFront(&lst, 40);
ListPushFront(&lst, 50);

ListPopFront(&lst);
ListPopFront(&lst);
ListPopFront(&lst);
ListPopFront(&lst);
ListPopFront(&lst);


ListPopBack(&lst);
PrintList(&lst);
ListPopBack(&lst);
PrintList(&lst);
ListPopBack(&lst);
PrintList(&lst);
ListPopBack(&lst);
PrintList(&lst);
ListPopBack(&lst);
PrintList(&lst);

}

int main()
{
test();
return 0;
}