数据结构之链表

最新推荐文章于 2024-08-21 00:26:54 发布

-浓烟下的诗歌电台

最新推荐文章于 2024-08-21 00:26:54 发布

阅读量182

点赞数

分类专栏：语言学习家园文章标签： C语言数据结构(链表) 入门级别

本文链接：https://blog.csdn.net/weixin_43142013/article/details/88087344

版权

语言学习家园专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Notion daily Link:Notion daily Link~

不带表头结点的单向链表操作

 /*****************************************************
            copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
            File name：
            Author：Jerey_Jobs    Version:0.1    Date: 
            Description：
            Funcion List: 
            *****************************************************/
            //单向带表头
            #include <stdio.h>
            #include <stdlib.h>
        
        typedef struct link
        {
            //值域
            int num;//测试
            /*char name[20];姓名
             * char sex;性别
             * int age;年龄*/
            
            //指针域
            struct link* next;
        }Node,* Link;
        
        void create_new_node(Link *);
        
        //链表初始化
        void create_link(Link *head)
        {
            create_new_node(head);//创建表头 里面的值是不确定的
            (*head)->next = NULL;
        }
        
        //结点初始化
        int judgement_malloc(Link *new_node)
        {
            if(NULL == *new_node)
            {
                printf("Malloc assign space error!\n");
                return 0;
            }
            else
            {
                return 1;
            }
        }
        
        //malloc()分配空间
        void create_new_node(Link *new_node)
        {
            int i=10;//这里最多判断分配十次
            do
            {
                *new_node = (Link)malloc(sizeof(Node));
                i--;
            }while(!judgement_malloc(new_node) && i);
        
        }
        
        //头插
        void insert_head_node(Link *head,Link new_node)
        {
            new_node->next = (*head)->next;
            (*head)->next = new_node;
        }
        
        //尾插
        void insert_tail_node(Link *head,Link new_node)
        {
            Link p;
            p = (*head);
            if((*head)->next == NULL)
            {
                (*head)->next = new_node;
                new_node->next = NULL;
            }
            else
            {
                while(p->next != NULL)
                {
                    p = p->next;
                }
                p->next = new_node;
                new_node->next = NULL;
            }
        }
        
        
        //中间插入 (前插)
        void insert_mid_node(Link *head,Link new_node,int loc)
        {
            Link p,q;
            p = (*head);
        
            if((*head)->next == NULL)
            {
                printf("Only head_node exists in LinkList!\n");
            }
            else
            {
                while((p->next !=NULL) && (p->num !=loc))
                {
                    q = p;
                    p = p->next;
                }
                if(p->next == NULL)
                {
                    if(p->num !=loc)
                    {
                        printf("The Linklist no such node!\n");
                    }   
                    else
                    {
                        if(p == (*head)->next)
                        {
                            new_node->next = (*head)->next;
                            (*head)->next = new_node;
                        }
                        else
                        {
                            new_node->next = p;
                            q->next = new_node;
                        }
                    }
                }
                else
                {
                    if(p == (*head)->next && (p->num) == loc)
                    {
                        (*head)->next = new_node;
                        new_node->next = p;
                    }
                    else
                    {
                        q->next = new_node;
                        new_node->next = p;
                    }
                }
            }
        }
        
        //指定删除
        void delete_node(Link *head,int loc)
        {
            Link q,p;
            p = (*head);
        
            if((*head)->next ==NULL)
            {
                printf("The LinkList only head_node exsitment!\n");
            }
            else
            {
                while((p->next !=NULL) && (p->num) !=loc)
                {
                    q = p;
                    p = p->next;
                }
                if(p->next == NULL)
                {
                    if(p->num !=loc)
                    {
                        printf("No such node in there!\n");
                    }
                    else
                    {
                        if(p == (*head)->next)
                        {
                            (*head)->next = NULL;
                            free(p);
                        }
                        else
                        {
                            q->next = NULL;
                            free(p);
                        }
                    }
                }
                else
                {
                    if((p == (*head)->next) && (p->num = loc))
                    {
                        (*head)->next = p->next;
                        free(p);
                    }
                    else
                    {
                        q->next = p->next;
                        free(p);
                    }
                }
            }
        }
        
        //永久释放
        void release_node(Link *head)
        {
            Link p;
            p = (*head);//从表头下一个结点开始
            if(NULL == (*head)->next)
            {
                printf("The LinkList no data!\n");
            }
            else
            {
                while((*head)->next !=NULL)
                {
                    p = (*head);
                    (*head) = (*head)->next;
                    free(p);
                }
            }
        }
        
        //访问链表
        void display_node(Link head)
        {
            Link p;
            int count =0;
            p = head->next;
            if(head == NULL)
            {
                printf("The LinkList is Empty!\n");
            }
            else
            {
                while(p !=NULL)
                {
                    printf("The number of %d exsits in LinkList\n",p->num);
                    p = p->next;
                    count++;
                }
                printf("There are %d node in LinkList!\n",count);
            }
        }
        
        int main()
        {
            Link head;//创建头结点
            head = NULL;//防止野指针
        //初始化...
            create_link(&head);
            Link new_node;//创建结点
        
            int i,number,location;
            printf("The LinkList initializing....\n");
            for(i=0;i<10;i++)
            {
                create_new_node(&new_node);
                new_node->num = 2*(i+1);
                //insert_head_node(&head);//头插
                insert_tail_node(&head,new_node);//尾插
            }
            display_node(head);//呈现
        
        
        //中间插入初始化
            create_new_node(&new_node);
            /*使用二级地址来创建新的结点*/
            printf("\nMid_insertment initializing...\n");
            printf("please input vulue to be inserted:");
            scanf("%d",&number);
            new_node->num = number;
            printf("please input location exsited in LinkList:");
            scanf("%d",&location);
            insert_mid_node(&head,new_node,location);
            display_node(head);
        
        
        //指定删除
            printf("\nDeletement_node initializing...\n");
            printf("please input value which exsits LinkList!:\n");
            scanf("%d",&location);
            delete_node(&head,location);
            display_node(head);
        
        
        //释放并呈现
            release_node(&head);
            display_node(head);
            return 0;
        }

带表头结点的单向链表操作

/*****************************************************
copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
File name：
Author：Jerey_Jobs    Version:0.1    Date: 
Description：
Funcion List: 
*****************************************************/

#include <stdio.h>
#include <stdlib.h>

struct link
{
    int num;//用于测试
    /*char name[20];姓名
     * int age; 年龄
     * char tel;电话
     * char sex; 邮箱*/
    struct link *next;
};

typedef struct link Node;
typedef struct link* Link;


//创建链表
create_link(Link *head)
{
    *head =NULL;
}

//初始化
int judgement_malloc(Link *new_node)
{
    if(NULL == *new_node)
    {
        printf("Malloc assign space error!\n");
        return 0;
    }
    else
    {
        return 1;
    }
}

//此处调用判断函数
void create_new_node(Link *new_node)
{
    int i =10;
    //Link new_node; 创建节点不需要传入头参数
    do
    {
        *new_node = (Link)malloc(sizeof(Node));//大小为整个结构体的大小
        i--;
    }while(!judgement_malloc(new_node) && i);

}

//头插
void insert_head_node(Link *head,Link new_node)
{
    new_node->next = *head;
    *head = new_node;
}

//尾插
void insert_tail_node(Link *head,Link new_node)
{
    Link p;
    p = *head;

    if(NULL == (*head))
    {
        //printf("This is a Empty LinkList!\n"); 这里是空链表
        *head = new_node;//空表变实表
        new_node->next = NULL;
    }
    else
    {
        while(p->next !=NULL)
        {
            p = p->next;
        }
        p->next = new_node;
        new_node->next = NULL;
    }
}


//修改内容 中间插入
void insert_mid_node(Link *head,Link new_node,int loc)
{
    Link p,q;
    q = p = *head;

    if(NULL == p)
    {
        printf("The LinkList is Empty!\n");
    }
    else
    {
        while((p->next) !=NULL && (p->num) !=loc)//检测中判断
        {
            q = p;//让q一直跟在p在后面
            p = p->next;
        }
        //检测中判断
        if((p->next == NULL))
        {
            if((p->num) != loc)
            {
                printf("Your wanna location unexsit in there!\n");
                free(new_node);
            }
            else//loc 存在
            {
                if(p == *head)
                {
                    new_node->next = *head;
                    *head = new_node;
                }
                else//插值location 在尾结点前面一个节点处
                {
                    p->next = new_node;
                    new_node->next = NULL;
                }
            }
        }
        else//location 值 在头部 或中间
        {
            if((p == *head) && p->num == loc)
            {
                new_node->next = *head;
                *head = new_node;
            }
            else//location值在中间
            {
                q->next = new_node;
                new_node->next = p;
            }
        }
    }
}

//删除操作
void delete_node(Link *head,int loc)
{
    Link p,q;
    p = q = *head;

    if(NULL == p)
    {
        printf("The LinkList is Empty!\n");
    }
    else
    {
        while((p->num != loc) && (p->next != NULL))
        {
            q = p;
            p = p->next;
        }
        if(p->next == NULL)
        {
            if(p->num !=loc)
            {
                printf("NO such node!\n");
            }
            else
            {
                if(p == *head)
                {
                    //*head = *head->next;
                    (*head) = (*head)->next;
                    free(p);
                }
                else
                {
                    q->next = NULL;
                    free(p);
                }
            }
        }
        else
        {
            if(p == *head)
            {
                (*head) = (*head)->next;
                free(p);
            }
            else
            {
                q->next = p->next;
                free(p);
            }
        }
    }
}


/*每次malloc()分配都要释放
 * 下面是只被释放一次的例子
void release_node(Link head)
{
    Link p;
    p = head;

    if(NULL == head)
    {
        printf("No release! in LinkList!\n");
    }
    else
    {
        while(p !=NULL)
        {
            free(p);
            p = p->next;//没释放一次指针往后结点移动一结
        }
    }
}
*/


//永久释放 基于二级指针
void release_node(Link *head)
{
    Link p;
    p = *head;

    if(NULL == (*head))
    {
        printf("No release in LinkList!\n");
    }
    else
    {
        while((*head) != NULL)//检测中作处理
        {
            p = (*head);
            (*head) = (*head)->next;
            free(p);
        }
    }
}

//显示
void display_node(Link head)
{
    Link p;
    p = head;
    int count = 0;
    if(NULL == head)
    {
        printf("This is A Empty LinkList!\n");
    }
    else
    {
        while(p !=NULL)
        {
            printf("The number of %d in the Node!\n",p->num);
            p = p->next;
            count ++;
        }
        printf("一共有%d个结点\n",count);
    }

}

int main()
{
    Link head;//创建头结点
    head = NULL;//防止野指针
    create_link(&head);//链表初始化 此处是二级地址

    Link new_node;//采用一级指针

    
//链表初始化.......
    int i;//写值
    int number,location;

    for(i=0;i<10;i++)
    {
        create_new_node(&new_node);//创建新的结点 为一级指针(每循环一次 都会创建一个新的结点)
        new_node->num = i+1;//奇数
        //count++;
        //将这些节点链接在一起
        //头插
        //insert_head_node(&head,new_node);
        //尾插
        insert_tail_node(&head,new_node);
    }

//展示
    display_node(head);

//插入中值
    printf("Insertment initializing...\n");
    printf("please input your value to be inserted:");
    scanf("%d",&number);
    create_new_node(&new_node);
    new_node->num = number;
    printf("please input your value exsiting in the LinkLint:");
    scanf("%d",&location);

    insert_mid_node(&head,new_node,location);
    display_node(head);


//删除操作
    printf("Deletement initializing...\n");
    printf("please input correctly values existing in LinkList:");
    scanf("%d",&location);
    delete_node(&head,location);
    display_node(head);


//释放
    release_node(&head);
    display_node(head);

    return 0;
}

带表头结点的单向循环链表操作

/*****************************************************
copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
File name：
Author：Jerey_Jobs    Version:0.1    Date: 
Description：
Funcion List: 
*****************************************************/

#include <stdio.h>
#include <stdlib.h>

struct node
{//值域
    int num;//用于测试
    /* char name[20];姓名
     * char sex;性别
     * int age;年龄
     * int phone[11];手机号码*/
    
    struct node *next;//指针域
};

//后续创建方便
typedef struct node Node;
typedef struct node *Link;

//malloc()初始化
int judgement_malloc(Link *new_node)
{
    if((*new_node) == NULL)
    {
        printf("Malloc Assign Space error!\n");
        return 0;
    }
    else
    {
        return 1;
    }
}
//新建结点
void create_new_node(Link *new_node)
{
    int count = 10;//设有10个测试数据
    do
    {
        (*new_node) = (Link)malloc(sizeof(Node));
        count--;
    }while(!judgement_malloc(new_node) && count);
}

//链表初始化(带头结点的循环链表)
void create_link(Link *head)
{
    create_new_node(head);
    (*head)->next = (*head);//表头结点的指针域指向它本身
}

//循环头插
void insert_head_node(Link *head,Link new_node)
{
    new_node->next = (*head)->next;
    (*head)->next = new_node;
}


//循环尾插
void insert_tail_node(Link *head,Link new_node)
{
    Link p;
    p = (*head)->next;
    if(p->next == (*head))
    {
        p->next = new_node;
        new_node->next = (*head);
    }
    else
    {
        while(p->next !=(*head))
        {
            p = p->next;
        }
        /*直接法
         * p->next = new_node;
        new_node->next = (*head);*/

        new_node->next = p->next;//间接法
        p->next = new_node;
    }
}

//中间插入(后插)
void insert_mid_node(Link *head,Link new_node,int loc)
{
    Link p,q;
    p = *head;
    
    while(p->next !=(*head))
    {
        if(p->next->num == loc)
        {
            q = p->next;//记录匹配loc值指针的下一个节点，loc正好在末尾p->next=(*head)未到 中插
           /*
            new_node->next = p->next;
            p->next = new_node;*/
           /*后插*/
           new_node->next = q->next;
           q->next = new_node;
        }
        p = p->next;
    }
}

//结点删除(算法同上)
void delete_node(Link *head,int loc)
{
    Link p,q;
    p = *head;

    while(p->next !=(*head))
    {
        if(p->next->num == loc)
        {
            q = p->next;
            p->next = q->next;
            free(q);
            return;
        }
        p = p->next;
    }
}

//清空链表
void Clean_Link(Link head)
{
    Link p;
    while(head->next !=head)
    {
        p = head->next;
        head->next = p->next;
        free(p);
    }
}

//永久释放
void release_node(Link *head)
{
    Link p;
    while((*head)->next !=(*head))
    {
        p = (*head)->next;
        (*head)->next = p->next;
        free(p);
    }
    p = (*head);
    (*head) = NULL;
    free(p);
}


//呈现
void display_node(Link head)
{
    Link p;
    int count=0;
    //p = head->next;
    if(head == NULL)
    {
        printf("The LinkList is Empty!\n");
        return;
    }
    if(head->next == NULL)
    {
        printf("The LinkList is clearred! aleardy\n");
    }
    else
    {
        p = head->next;
        while(p !=(head))
        {
            printf("The number of %d in there!\n",p->num);
            p = p->next;
            count++;
        }
        printf("There are %d node exsit in LinkList!\n",count);
    }
}


int main()
{
    Link head;//新建表头结点
    head = NULL;
    create_link(&head);//新建链表
    Link new_node;//新建结点

    int i,number,location;
    for(i=0;i<10;i++)
    {
        create_new_node(&new_node);
        new_node->num = 2*(i+1);
        insert_tail_node(&head,new_node);
        //insert_head_node(&head,new_node);
    }

//呈现
    display_node(head);

//中间插入
    printf("\nMid_insertment Initalizing...\n");
    printf("please input value to be inserted in LinkList:");
    scanf("%d",&number);
    create_new_node(&new_node);
    new_node->num = number;
    printf("Please input value to be located in LinkList:");
    scanf("%d",&location);
    insert_mid_node(&head,new_node,location);
    display_node(head);

//删除操作
    printf("\nDeletement Initalizing...\n");
    printf("Please input vuale to be deleted from LinkList:");
    scanf("%d",&location);
    delete_node(&head,location);
    display_node(head);

//清空链表但保留其结构
    printf("\nCleaning Initalizing...\n");
    Clean_Link(head);
    display_node(head);

//释放
    release_node(&head);
    display_node(head);

    return 0;
}

带表头结点的双向循环链表操作

/*****************************************************
copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
File name：
Author：Jerey_Jobs    Version:0.1    Date: 
Description：
Funcion List: 
*****************************************************/

#include <stdio.h>
#include <stdlib.h>


//双向结点模板
struct node
{
    int num;
    /*char name[30];
     *char sex;
     int age;*/
    struct node *next;
    struct node *prior;
};

typedef struct node Node;
typedef struct node *Link;


//判断malloc()有无分配成功
int judgement_malloc(Link *new_node)
{
    if(NULL == *new_node)
    {
        printf("malloc assignment defeated!");
        return 0;
    }
    else
    {
        return 1;
    }
}

void create_node(Link *new_node)
{
    int count = 10;
    do
    {
        *new_node = (Link)malloc(sizeof(Node));
//*new_node 是指针域一级指针的空间和值域是共享的 
//可以说分配了一级指针空间 就是分配一个节点的空间
        count --;
    }while(!judgement_malloc(new_node) && count);
}


//创建带表头的循环双向链表
void create_link(Link *head)
{
    create_node(head);
    (*head)->next = *head;
    (*head)->prior = *head;
}


//中间插入后继方式双向带表头结点
void insert_mid_node(Link *head,Link new_node,int loc)
{
    Link p,q;
    p = *head;
    q = p->next;
    if(p->next ==(*head))
    {
        printf("This is A Empty LinkList,No measure insertment!\n");
        free(new_node);
    }
    else
    {
        while((p->next) !=(*head))
        {
            if((q->num)  ==loc)
            {//后插
                new_node->prior = p;
                new_node->next = p->next;
                p->next->prior = new_node;
                p->next = new_node;
                return;
            }
            p = q;
            q = q->next;//让q放在p前面
        }
        if(p->next == (*head) && p->num == loc)
        {//最后一个尾插
            (new_node)->prior = q->prior;
            (new_node)->next = q;
            q->prior->next = new_node;
            q->prior = new_node;
        }
    }
}

//删除操作
void Delete_node(Link *head,int loc)
{
    Link p,q;
    p = *head;
    //q = (*head)->next;

    if(p->next == (*head))
    {
        printf("Only Head_Node exsits in double driection Loop LinkList!\n");
    }
    else
    {
        while(p->next !=(*head))
        {
            if(p->num == loc)
            {
               p->next = q->next;
               free(q);
               return;
            }
            q = p->next;
            p = p->next;
        }
    }
}


//头插双向循环链表实现
void insert_tail_node(Link head,Link new_node)
{
    (new_node)->prior = (head)->prior;
    (new_node)->next = (head);
    (head)->prior->next = new_node;
    (head)->prior = new_node;
}

//后继显示
void display_head(Link head)
{
    Link p;
    int count =0;
    p = head->next;

    while((p) !=head)
    {
        printf("value exists in LinkList:%d\n",p->num);
        p = p->next;
        count++;
    }
    printf("There are %d nodes in there!\n",count);
}

//前驱显示
void display_tail(Link head)
{
    Link p;
    p = head->prior;
    int count =0;

    while(p !=head)
    {
        printf("value exsits in LinkList:%d\n",p->num);
        p = p->prior;
        count++;
    }
    printf("There are %d nodes in there!\n",count);
}


int main()
{
    Link head = NULL;
    create_link(&head);
    Link new_node;
   
    int i,number,location;
    for(i=0;i<10;i++)
    {
        create_node(&new_node);
        new_node->num = i+1;

        insert_tail_node(head,new_node);//尾插
    }

//双向循环链表显示两次
    display_tail(head);//后继显示 逆序
    display_head(head);//前驱显示 正序


//中间插入方式
    create_node(&new_node);
    printf("please input value to be inserted from LinkList:");
    scanf("%d",&number);
    new_node->num = number;
    printf("please input vuale to be arranged form original LinkList:");
    scanf("%d",&location);
    //printf(" %d %d\n",location,new_node->num);
    insert_mid_node(&head,new_node,location);//中间插入
    display_tail(head);//由于这里仅调用后继中间插入 此处为前驱显示并不会显示插入的数
    display_head(head);

//删除操作
    printf("please input ever exsitly value to be deleted from LinkList:");
    scanf("%d",&location);

    Delete_node(&head,location);
    display_tail(head);
    display_head(head);


    return 0;
}