链表

一，传统链表的创建

1. 链表的有头结点 （有一个结构体 表示大小头结点）

2. 链表的结构体是只有数据和指向下一个的指针

第一个结构是链表

``` struct LinedNode
    {
    void* data;             //数据
    struct LinedNode* next; //指针
    } LinedNode;
```

第二个结构是链表头结点和链表大小的表示

struct LListNode
{
sturct LinedNode LLinedNode;
int m_size; //链表的大小
} LListNode;


二，链表头文件的声明

1. 初始化链表的头结点

2. 插入数据（位置，数据）插入

3. 删除数据（位置，数据）删除

4. 计算结点数量

5. 链表置空

6. 链表销毁

    ``` 
    typedef void* ListNode;
    //1,初始化链表的信息
    ListNode Init_LinedNode(int Capcatiy);

    //2,插入数据
    void Insert_LinedNodeData(ListNode* list, int pos, void* data);

    //3,删除数据（位置，数据）
    void Remove_ByPostionLinedeNodeData(ListNode* list, int pos);
    void Remove_ByValueLinedNodeData(ListNode* list, void* data, int (*MyObjectCmp)(void*, void*));

    //4,计算结点的数量
    int getLinedNode(ListNode* list);

    //5, 链表置空
    void Emtry_LinedNodeData(ListNode* list);

    //6,链表销毁
    void Destroy_LinedNodeData(ListNode* list);

    ```

三,头文件的链表的实现

```
#define _CRT_SECURE_NO_WARNINGS
#include "ListNode.h"



//1,初始化链表的信息
ListNode Init_LinedListNode(int capcatiy)
{
//1,条件判断
if (!capcatiy) return;

//2,开辟内存保存链表的信息
LLinedNode* linednode = (LLinedNode*)malloc(sizeof(LLinedNode*));
linednode->LedNode.next = NULL;
linednode->s_size = 0;



return linednode;
}

//2,按照位置插入数据到链表中
void Insert_LinedListNodeData(ListNode list, int pos, void* data)
{
//1,条件判断
if (!list) return;
if (!data) return;
LLinedNode* headnode = list;
if (pos < 0 || pos > headnode->s_size)
    pos = headnode->s_size; //置尾

//2,插入数据一些操作
LinedNode* ParentNode = headnode->LedNode.next;
int i;
for (i = 0; i <= pos; i++)
    ParentNode = ParentNode->next; //找到pos节点


LinedNode* ChilderNode = NULL;
ChilderNode->data = data;
ChilderNode->next = NULL;
ChilderNode = ParentNode->next;
ParentNode->next = ChilderNode;


//链表信息更改
headnode->s_size++;

    }


//3,按照位置删除数据
void Remove_LinedListNodeData(ListNode list, int pos)
{
//1,条件判断
if (!list) return;
LLinedNode* headnode = list;
if (pos < 0 || pos > headnode->s_size)
    return;


//双向指针
LinedNode* parentNode = headnode->LedNode.next;
LinedNode* ChilderNode = parentNode->next;

int i;
for (i = 0; i < headnode->s_size; i++)
{

}



}

//4,按照数据删除数据
void Remove_ByValueListedNodeData(ListNode list, void* data,
int(*ByValue)(void*, void*))
{
}

//5,得到数据的节点
int get_LinedNode(LinedNode list)
{
}

//6,将链表置空
void Emtry_LinedNode(ListNode list)
{
}

//7,销毁链表
void Destroy_LinedNode(ListNode list)
{
}

```