数据结构：单链表

封装链表：

   原因： 尾添加效率低、非法下标的判断效率也非常低

    1.单链表

        结点：

            数据域

            指针域

        单链表数据项：

            头结点

            尾结点

            结点数量

//封装带头结点的单链表

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>



#define TYPE int



//  封装带头结点的单链表



typedef struct Node

{

    TYPE data;

    struct Node* next;

}Node;



Node* create_node(TYPE val)

{

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

    node->data = val;

    node->next = NULL;

    return node;

}



//  单链表结构

typedef struct List

{

    Node* head;     //  头指针

    Node* tail;     //  尾指针

    size_t size;    //  结点数量

}List;



//  创建单链表

List* create_list(void)

{

    List* list = malloc(sizeof(List));

    list->head = create_node(0);    //  带头结点的链表

    list->tail = NULL;

    list->size = 0;

    return list;

}



//  头添加

void add_head_list(List* list,TYPE val)

{

    Node* node = create_node(val);

    if(0 == list->size)

    {

        list->head->next = node;

        list->tail = node;

    }

    else

    {

        node->next = list->head->next;

        list->head->next = node;

    }

    list->size++;

}



//  尾添加

void add_tail_list(List* list,TYPE val)

{

    Node* node = create_node(val);

    if(0 == list->size)

    {

        list->head->next = node;

        list->tail = node;

    }

    else

    {

        list->tail->next = node;

        list->tail = node;

    }

    list->size++;

}



//  遍历

void show_list(List* list)

{

    for(Node* n=list->head->next; n; n=n->next)

    {

        printf("%d ",n->data);  

    }

    printf("\n");

}



//  头删除

bool del_head_list(List* list)

{

    if(0 == list->size) return false;

    Node* temp = list->head->next;

    list->head->next = temp->next;

    if(1 == list->size) list->tail = NULL;

    list->size--;

    free(temp);

    return true;

}



//  尾删除

bool del_tail_list(List* list)

{

    if(0 == list->size) return false;

    free(list->tail);

    if(1 == list->size)

    {

        list->head->next = NULL;

        list->tail = NULL;

    }

    else

    {

        Node* prev = list->head->next;

        while(prev->next != list->tail) prev = prev->next;

        prev->next = NULL;

        list->tail = prev;

    }

    list->size--;

    return true;

}



//  插入

bool insert_list(List* list,size_t index,TYPE val)

{

    if(0 >= index || index >= list->size) return false;



    Node* node = create_node(val);

    Node* prev = list->head->next;

    for(int i=1; i<index; i++) prev = prev->next;



    node->next = prev->next;

    prev->next = node;

    list->size++;

    return true;

}



//  按值删除

bool del_value_list(List* list,TYPE val)

{

    if(val == list->head->next->data)

        return del_head_list(list);

    if(val == list->tail->data)

        return del_tail_list(list);



    for(Node* n=list->head->next; n->next; n=n->next)

    {

        if(val == n->next->data)

        {

            Node* temp = n->next;

            n->next = temp->next;

            free(temp);

            list->size--;

            return true;

        }

    }

    return false;

}



//  按位置删除

bool del_index_list(List* list,size_t index)

{

    if(index >= list->size) return false;

    if(0 == index) return del_head_list(list);

    if(index == list->size-1) return del_tail_list(list);



    Node* prev = list->head->next;

    for(int i=1; i<index; i++) prev = prev->next;



    Node* temp = prev->next;

    prev->next = temp->next;

    free(temp);

    list->size--;

    return true;

}



//  按位置修改

bool modify_index_list(List* list,size_t index,TYPE val)

{

    if(index >= list->size) return false;

    Node* n = list->head->next;

    for(int i=0; i<index; i++) n=n->next;

    n->data = val;

    return true;

}



//  按值修改 全部改

size_t modify_value_list(List* list,TYPE old,TYPE val)

{

    size_t cnt = 0;

    for(Node* n=list->head->next; n; n=n->next)

    {

        if(n->data == old)

        {

            n->data = val;

            cnt++;

        }

    }

    return cnt;

}



//  查询

int query_list(List* list,TYPE val)

{

    Node* n = list->head->next;

    for(int i=0; n; i++)

    {

        if(n->data == val) return i;

        n = n->next;

    }

    return -1;

}



//  访问

bool access_list(List* list,size_t index,TYPE* val)

{

    if(index >= list->size) return false;

   

    Node* n = list->head->next;

    while(index--)  n = n->next;

    /*

    for(int i=0; i<index; i++)

    {

        n = n->next;    

    }

    */

    *val = n->data;

    return true;

}



//  排序

void sort_list(List* list)

{

    for(Node* i=list->head->next; i->next; i=i->next)

    {

        for(Node* j=i->next; j; j=j->next)

        {

            if(j->data > i->data)

            {

                TYPE temp = j->data;

                j->data = i->data;

                i->data = temp;

            }

        }

    }

}



//  清空

void clear_list(List* list)

{

    //while(list->size) del_head_list(list);    耦合度高

    while(list->head->next)

    {

        Node* temp = list->head->next;

        list->head->next = temp->next;

        free(temp);

    }

    list->tail = NULL;

    list->size = 0;

}

//  销毁

void destory_list(List* list)

{

    clear_list(list);

    free(list->head);

    free(list);

}



int main(int argc,const char* argv[])

{

    List* list = create_list();

    for(int i=0; i<10; i++)

    {

        add_tail_list(list,i);  

    }

    show_list(list);

    del_head_list(list);

    del_tail_list(list);

    del_tail_list(list);

    show_list(list);

    insert_list(list,6,88);

    insert_list(list,6,88);

    del_value_list(list,8);

    show_list(list);

    del_index_list(list,1);

    show_list(list);

    modify_value_list(list,88,22);

    sort_list(list);

    show_list(list);

    TYPE num = -100;

    access_list(list,1,&num);

    printf("num=%d\n",num);

}

 

    2.静态链表

    结点:

        数据域

        游标

    静态链表的结点存储在连续内存中，通过游标来访问下一个结点

    这种链表在插入删除时需要修改游标的值，而不用申请、释放结点内存就可以达到类似链式结构的效果

    牺牲了随机访问的功能、也没达到链表动态申请内存的效果,只是给没有指针的变成语言的一种实现链表的方式,适用范围不大

   typedef struct Node

    {

        int data;

        int i;   //游标

    }

    Node list[100];

    int main()

    {

        Node* head = &list[0];

        head->i = 5;

        list[5].i = 3;

        list[3].i = 8;




    }

    3.循环链表

    链表的最后一个结点的next不再指向NULL。而是指向头结点,这种链表称为单向循环链表,简称循环链表，

    好处是:可以通过任意结点来遍历整个链表