链表

链表:物理存储结构上非连续,数据元素的逻辑顺序是通过链表中的指针链接次序实现的.

实际中链表的结构有很多种,有以下情况的组合:

1.单向,双向

2.带头,不带头 

3.循环,非循环

我们常见的链表主要是  无头单向非循环链,带头双向循环链表

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int LDataType;

typedef struct listNode{
    LDataType _data;/*存放数据的最小单元*/
    struct listNode* _next;/*下一个数据的存放位置*/
}listNode;

//定义一个链表
typedef struct list{
    listNode* _head;/*存放第一个节点的地址*/
}list;

void listInit (list* lst){
    if (lst == NULL)
        return;
    //初始化为空的链表
    lst->_head = NULL;
}

//创建节点
listNode* creatNode(LDataType val){
    listNode* node = (listNode*)malloc(sizeof(listNode));
    node->_data = val;
    node->_next = NULL;
    return node;
}

//尾插
void listPushBack(list* lst, LDataType val){
    if (lst == NULL)
        return;
    /*第一种:空链表插入第一个数据*/
    if (lst->_head == NULL){
    //创建节点
        lst->_head = creatNode(val);
    }
    else{
    //遍历,找到最后一个节点
        listNode* tail = lst->_head;
        while (tail->_next != NULL){
            tail = tail->_next;
        }
        //插入
        tail->_next = creatNode(val);
    }
}

//尾删
void listPopBack(list* lst){
    if (lst == NULL||lst->_head==NULL)
        return;
    listNode* tail = lst->_head;
    listNode* prev = NULL;
    //遍历,找到最后一个节点 
    while (tail->_next != NULL){
        prev = tail;
        tail = tail->_next;
    }
    //删除节点
    free(tail);
    //修改指向
    if (prev == NULL)/*删除的为头结点,更新头结点*/
        lst->_head = NULL;
    else
        prev->_next = NULL;
}

//头插 
void listPushFront(list* lst,LDataType val){
    if (lst == NULL)
        return;
    //空的链表,插入第一个数据
    if (lst->_head == NULL)
        lst->_head = creatNode(val);
    else{
    listNode* node = creatNode(val);
    listNode* next = lst->_head;
    lst->_head = node;
    node->_next = next;
    }
}

//头删
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* cur, LDataType val){
    listNode* node = creatNode(val);
    listNode* next = cur->_next;
    cur->_next = node;
    node->_next = next;
}

//删除某一项后面的那一项
void listEraseAfter(listNode* cur){
    listNode* next = cur->_next;
    if (next == NULL){
        return;
        listNode* nextnext = next->_next;
        free(next);
        cur->_next = nextnext;
    }
}

//查找某一个数据,返回指针
listNode* listFind(list* lst, LDataType val){
    if (lst == NULL || lst->_head == NULL)
        return NULL;
    //从第一个节点开始遍历
    listNode* cur = lst->_head;
    while (cur){
        if (cur->_data == val)
            return cur;
        cur = cur->_next;
    }
    return NULL;
}

//销毁链表
void listDestroy(list* lst){
    listNode* cur = lst->_head;
    while (cur){
        listNode* next = cur->_next;
        //释放节点
        free(cur);
        cur = next;
    }
    lst->_head = 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);
}

int main(){
     test();
    

    system("pause");
    return 0;
}