单链表的实现

定义结构体：

typedef struct
{
    int val;
}Element_T;

typedef struct link
{
    Element_T data;
    struct link *next;
}linke_list_T;

linke_list_T *Init(); //初始化链表

  此结点作为头结点使用

linke_list_T* Init()
{
    linke_list_T *head = (linke_list_T *)malloc(sizeof(linke_list_T));
    if(head == NULL)
    {
        exit(-1) ;
    }
    head->next = NULL; 
    return head;
}

void show_list(linke_list_T *list); //显示链表数据

void show_list(linke_list_T *list)
{
     linke_list_T *nodetmp = list->next;
     while(nodetmp != NULL)
     {
         printf("结点元素为：%d\n",nodetmp->data.val);
         nodetmp = nodetmp->next;
     }
}

void insert_tail(linke_list_T *list,Element_T *elem); //尾部插入数据

void insert_tail(linke_list_T *list,Element_T *elem)
{
    linke_list_T *nodetmp = (linke_list_T *)malloc(sizeof(linke_list_T));
    linke_list_T *node = list;		//辅助结点（保存头结点位置）
    if(nodetmp == NULL)		//判断内存申请是否成功
    {
        return ;
    }
    while(node->next != NULL)	//遍历找到尾结点
    {
        node = node->next;
    }
    nodetmp->data.val = elem->val;		//新结点的数据域保存要添加的数据
    nodetmp->next = NULL;				//新结点指向置为空
    node->next = nodetmp;				//尾结点指向新结点
}

void insert_front(linke_list_T *list,Element_T *elem); //头部插入

void insert_front(linke_list_T *list,Element_T *elem)
{
    linke_list_T *nodetmp = (linke_list_T *)malloc(sizeof(Element_T));
    linke_list_T *node = list;
    if(nodetmp == NULL)
    {
        return ;
    }
    nodetmp->data.val = elem->val;
    nodetmp->next = node->next;
    node->next = nodetmp;
}

void reverse_list(linke_list_T *list); //反转链表

void reverse_list(linke_list_T *list)
{
    linke_list_T *head = list->next;
    linke_list_T *next = NULL;
    linke_list_T *pre = NULL;

    while(head != NULL)
    {
        next =head->next;
        head->next = pre;
        pre = head;
        head = next;
    }
    list->next = pre;
}

void swap_list(linke_list_T *list); //两两交换节点数据

void swap_list(linke_list_T *list)
{
    if(list->next == NULL || list->next->next == NULL)
    {
        return ;
    }
    linke_list_T *pre;
    linke_list_T *node2;
    linke_list_T *node1;
    linke_list_T *next;
    pre = list;
    while(pre->next != NULL && pre->next->next != NULL)
    {
        node1 = pre->next;
        node2 = pre->next->next;
        next = node2->next;

        pre->next = node2;
        node2->next = node1;
        node1->next = next;
        pre = node1;
    }    
}

void delete_Node(linke_list_T *list,int poision); //删除倒数第position个结点

void delete_Node(linke_list_T *list,int poision)
{
    linke_list_T *fast = list;
    linke_list_T *slow = list;
    linke_list_T *pre = NULL;

    while(poision-- > 0)
    {
        fast = fast->next;

    }

    while(fast != NULL)
    {
        pre = slow;
        slow = slow->next;
        fast = fast->next;
    }
    pre->next = slow->next;
}

void intersect_list(linke_list_T *list1,linke_list_T *list2); //链表相交

void intersect_list(linke_list_T *list1,linke_list_T *list2)
{
    linke_list_T *list_1 = list1->next;
    linke_list_T *list_2 = list2->next;
    int size1 = 0;
    int size2 = 0;
    int gap = 0;

    while(list_1 != NULL)
    {  
        size1++;
        list_1 = list_1->next;
    }
    while(list_2 != NULL)
    {  
        size2++;
        list_2 = list_2->next;
    }
    if(size1 >= size2)
    {
        list_1 = list1->next;
        list_2 = list2->next;
        gap = size1 - size2;
    }
    else
    {
        list_1 = list2->next;
        list_2 = list1->next;
        gap = size2 - size1;
    }
    while(gap--)
    {
        list_1 = list_1->next;
    }

    while(list_1 != NULL)
    {
        if(list_1->data.val == list_2->data.val)
        {
            printf("相交的结点数据为：%d\n",list_1->data);
            return;
        }
    
        list_1 = list_1->next;
        list_2 = list_2->next;
    }

}

void tail_delete_list(linke_list_T *list); //尾部删除结点

void tail_delete_list(linke_list_T *list)
{
    linke_list_T *delete = list->next;
    linke_list_T *node = list;
    if(delete == NULL)
        return ;
    
    while(delete->next)
    {
        node = delete;
        delete = delete->next;
    }
    printf("删除结点为：%d\n",delete->data.val);
    node->next = delete->next;
    free(delete);
}

void front_delete_list(linke_list_T *list); //头部删除结点

void front_delete_list(linke_list_T *list)
{
    linke_list_T *delete = list->next;
    linke_list_T *node = list;
    if(delete == NULL)
        return;
    
    printf("头部删除结点为：%d\n",delete->data.val);
    node->next = delete->next;
    free(delete);
}

void id_delete_list(linke_list_T *list,int poision); //按id删除结点

void id_delete_list(linke_list_T *list,int poision)
{
    linke_list_T *delete = list->next;
    linke_list_T *node = list;

    while(delete != NULL && poision != delete->data.val)
    {
        node = delete;
        delete = delete->next;
    }

    if(delete == NULL)
    {
        printf("未找到\n");
        return ;
    }

    printf("按id删除结点为：%d\n",delete->data.val);
    node->next = delete->next;
    free(delete);
}

void id_insert_list(linke_list_T *list,Element_T *element); //按值插入结点

void id_insert_list(linke_list_T *list,Element_T *element)
{
    linke_list_T *pre = list;
    linke_list_T *insert = (linke_list_T *)malloc(sizeof(element));
    //此时未定义链表长度，若定义链表长度，若超过结点长度，直接尾插
    while(pre->next != NULL && pre->next->data.val < element->val)
    {
        pre = pre->next;
    }

    insert->data.val = element->val;
    insert->next = pre->next;
    pre->next = insert;
}

说明：此文章为学习笔记，如有侵权请联系删除。