【数据结构】单向链表,单向循环链表,双向循环链表

单向链表

头文件

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

#ifndef _LINKLIST_H
#define _LINKLIST_H

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

typedef int datatype;

typedef struct node
{
    datatype data;
    struct node *next;
}linklist,*plinklist;

extern void linklist_init(plinklist *plist);//初始化链表
extern void linklist_create(plinklist plist, int len);//从头结点创建链表
extern void linklist_create_tail(plinklist plist, int len);//从链表尾创建链表
extern void linklist_sort(plinklist plist);//实现链表的逆转
extern void linklist_show(plinklist plist);//显示链表

#endif

单向链表

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

#include "linklist.h"

void linklist_init(plinklist *plist)//初始化链表
{
    *plist = (plinklist)malloc(sizeof(linklist));//申请空间
    if(*plist == NULL)
    {
        perror("malloc");
        exit(1);
    }
    (*plist)->next = NULL;//初始化为空
}

void linklist_create(plinklist plist, int len)//从头结点创建链表
{
    plinklist new;

    while(len--)//创建len个结点
    {
        new = (plinklist)malloc(sizeof(linklist));//申请新空间
        if(new == NULL)
        {
            perror("malloc");
            exit(1);
        }
        new->data = len+1;//完成新结点的赋值
        
        //现在需要将新申请的结点和已有的结点链接在一起
        //注意是在头部插入
        new->next = plist->next;//将新申请的new结点插入到链表的最前面
        plist->next = new;
    }
}

void linklist_create_tail(plinklist plist, int len)//从链表尾创建链表
{
    plinklist new;
    plinklist tail = plist;//tail表示链表的最后一个结点，在整个过程中，必须保证头结点（plist）的值不变
    int i;

    for(i=0; i<len; i++)
    {
        new = (plinklist)malloc(sizeof(linklist));//申请新空间
        if(new == NULL)
        {
            perror("malloc");
            exit(1);
        }
        new->data = i+1;
        
        //现在需要将新申请的结点和已有的结点链接在一起
        //注意是在尾部插入
        new->next = tail->next;//tail->next为空，new将成为新的尾结点
        tail->next = new;//将new结点插入到tail的后面
        tail = new;//tail后移，new成为新的尾结点

    }
}

void linklist_sort(plinklist plist)//实现链表的逆转
{
    //思想
    //在创建时把最早申请的结点放到了最后面，最后申请的结点放到了最前面
    //所以逆转的过程就相当于创建时过程的重复执行，把最前面的又放到最后面
    //逆转过程和入栈｜出栈是一样的
    //出栈｜入栈只是为了方便理解

    plinklist p = plist->next;//所有的操作必须保证头结点不变，用p指向链表的第一个元素，负责逆转过程中原链表的的移位
    plinklist tem = NULL;//临时变量，负责将原链表元素转移到逆转后的链表（相当于：出栈后入栈）

    plist->next = NULL;//切断头结点与原链表的联系，以便重新建立链表

    while(p != NULL)//p辅助移位，相当于依次出栈
    {
        tem = p;//标记出栈的元素，即将入栈
        p = p->next;//移位，依次出栈

        //将出栈的元素加入到逆转后的链表，相当于再次入栈
        //插入过程和从头部创建链表过程一样
        tem->next = plist->next;
        plist->next = tem;//tem作为链表的第一个元素

    }
}

void linklist_show(plinklist plist)//显示链表
{
    plinklist tem = plist->next;//同样是为了不改变头结点，所以需要临时结点指针

    while(tem != NULL)
    {
        printf("%d	",tem->data);
        tem = tem->next;
    }
    printf("
");
}

 

主文件

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

//用单向链表实现数据逆转
//首先建立一个包含若干整数的单向链表，然后实现逆转

#include "linklist.h"

int main()
{
    plinklist plist;
    int length;

    linklist_init(&plist);//完成初始化_

    printf("Pls input the length of linklist:");
    scanf("%d",&length);
#if 0
    linklist_create(plist,length);//从头结点创建链表
    linklist_show(plist);//显示链表
    linklist_sort(plist);//逆转链表
    linklist_show(plist);

#else
    printf("******************************************
");
    linklist_create_tail(plist,length);//从尾结点创建链表
    linklist_show(plist);//显示链表
    linklist_sort(plist);//逆转链表
    linklist_show(plist);

#endif

    return 0;
}

---

单向循环链表(josephu问题)

头文件 

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

#ifndef _LINKLIST_H
#define _LINKLIST_H

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

typedef int datatype;

typedef struct node
{
    datatype data;
    struct node *next;
}linklist,*plinklist;


extern void josephu_init(plinklist *plist);//完成初始化
extern void josephu_create(plinklist *plist, int len);//创建链表
extern datatype josephu(plinklist plist);//完成数3出局
extern void josephu_show(plinklist plist);//显示链表


#endif

josephu

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

//用单向循环链表现实"数3出局"游戏(Josephu问题)
//首先建立一个包含若干整数的单向循环链表,然后从第一个节点开始数,把数到3的那个节点删除
//接着下一个节点开始数,数到3继续删除,以此类推,打印出最后剩余的那个节点

#include "linklist.h"

void josephu_init(plinklist *plist)//完成初始化
{
    #if 1//无头结点的初始化
         *plist = NULL;
    #else//有头结点的初始化
         *plist = (plinklist)malloc(sizeof(linklist));
         if(*plist == NULL)
         {
             perror("malloc");
             exit(1);
         }
         (*plist)->next = *plist;
    #endif
}

void josephu_create(plinklist *plist, int len)//创建链表,因为初始化时没有头结点,所以参数需要传*plist
{
    plinklist new;
    plinklist tail;//尾指针，从链表尾部插入新结点
    int i;

    for(i=0; i<len; i++)
    {
        if(0 == i)//因为无头结点，所以第一次也需要申请空间，并指向自己
        {
            *plist = (plinklist)malloc(sizeof(linklist));
            if(*plist == NULL)
            {
                perror("malloc");
                exit(1);
            }
            (*plist)->data = i+1;
            (*plist)->next = *plist;//只有一个结点，指向自己

            tail = *plist;//初始化尾指针
        }
        else
        {
            new = (plinklist)malloc(sizeof(linklist));
            if(new == NULL)
            {
                perror("malloc");
                exit(1);
            }
            new->data = i+1;
            //将新结点new和已有结点连在一起
            //注意是在尾部插入
            new->next = tail->next;
            tail->next = new;//将new结点插入到tail后面
            tail = new;//new变成新的尾结点
        }
    }
}

datatype josephu(plinklist plist)//完成数3出局
{
    plinklist head = plist;//指向每次变化的"头结点"，每出局一个人，下一个人将变成头结点
    plinklist tem;//临时指针，指向每次出局的人

    while(head != head->next)//只剩下一人时退出循环
    {
        tem = head->next->next;//tem将出局
        head->next->next = tem->next;//tem->next将是下一个"头结点"
        head = tem->next;//新"头结点"

        printf("%d	",tem->data);
        free(tem);//tem出局
    }
    return head->data;
}

void josephu_show(plinklist plist)//显示链表
{
    plinklist tem = plist;//保证头结点不变
    while(tem != NULL && tem->next != plist)//循环遍历
    {
        printf("%d	",tem->data);
        tem = tem->next;
    }
    //注意最后一次循环是tem->next = plist,所以最后一个结点并没有输出
    printf("%d
",tem->data);

}

主文件

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

//用单向循环链表现实"数3出局"游戏(Josephu问题)
//首先建立一个包含若干整数的单向循环链表,然后从第一个节点开始数,把数到3的那个节点删除
//接着下一个节点开始数,数到3继续删除,以此类推,打印出最后剩余的那个节点

#include "linklist.h"

int main()
{
    plinklist plist;
    datatype result;
    int len;

    josephu_init(&plist);//完成初始化

    printf("Pls input the length of josephu:");
    scanf("%d",&len);

    josephu_create(&plist,len);//创建josephu链表
    josephu_show(plist);//显示josephu链表
    
    result = josephu(plist);//解决方案
    printf("
The last is %d
",result);

    return 0;
}

 

---

 双向循环链表

头文件

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

#ifndef _DOUBLELIST_H
#define _DOUBLELIST_H

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

typedef int datatype;

typedef struct node
{
    datatype data;
    struct node *next,*prior;
}double_list,*double_plist;

extern void double_init(double_plist *plist);//双向链表的初始化
extern void double_sort(double_plist plist);//完成双向链表的奇数升序偶数降序排列
extern void double_create(double_plist plist, int len);//头插法创建双向链表
extern void double_show(double_plist plist);//显示双向链表

#endif

 双向循环链表

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

//用双向循环链表实现顺序递增存储若干个自然数
//比如输入一个整数10,则建立一个双向循环链表,里面的每个节点分别存放1,2,3,4,5,6,7,8,9,10
//然后通过某些操作,将其重新排列成1,3,5,7,9,10,8,6,4,2,即奇数升序偶数降序,并在屏幕上打印出来

#include "double_list.h"

void double_init(double_plist *plist)//双向链表的初始化
{
    *plist = (double_plist)malloc(sizeof(double_list));
    if(*plist == NULL)
    {
        perror("malloc");
        exit(1);
    }

    (*plist)->next = (*plist)->prior = *plist;//双向链表的前后指针都指向自己

}

void double_sort(double_plist plist)//完成双向链表的奇数升序偶数降序排列
{
    double_plist pnext = plist->next;//指向链表的第一个节点
    double_plist prior = plist->prior;//指向链表的最后一个节点
    double_plist tem = NULL;//临时指针,用于辅助定位将被移动的节点

    while(pnext != prior)//没有到达链表尾
    {
        if(pnext->data%2 !=0)//为奇数,直接跳过
            pnext = pnext->next;
        else//为偶数,将pnext移动到偶数后面一位奇数位置,用tem指向回去辅助移动偶数链表节点
        {
            pnext = pnext->next;

            //将pnext前面的节点剪切出来
            tem = pnext->prior;//tem指向要被移动的节点
            pnext->prior = tem->prior;//将奇数节点前向指针连接起来
            tem->prior->next = pnext;//将奇数节点后向指针连接起来

            //将偶数节点(tem)插入到链表尾(prior)
            tem->next = prior->next;//tem将成为新的尾结点
            prior->next->prior = tem;//链表首尾相连
            //prior和新的尾结点tem相连
            tem->prior = prior;
            prior->next = tem;
        }
    }
}

void double_create(double_plist plist, int len)//头插法创建双向链表
{
    double_plist new;
    while(len--)//创建len个节点
    {
        new = (double_plist)malloc(sizeof(double_list));
        if(new == NULL)
        {
            perror("malloc");
            exit(1);
        }
        new->data = len+1;

        //向plist后面插入一个新的节点
        //双向链表的头插法
        new->next = plist->next;
        plist->next->prior = new;
        new->prior = plist;
        plist->next = new;
    }
}

void double_show(double_plist plist)//显示双向链表
{
    double_plist tem = plist->next;//保证头结点不变

    while(tem != plist)//遍历一个循环
    {
        printf("%d	",tem->data);
        tem = tem->next;
    }
    printf("
");
}

主文件 

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

//用双向循环链表实现顺序递增存储若干个自然数
//比如输入一个整数10,则建立一个双向循环链表,里面的每个节点分别存放1,2,3,4,5,6,7,8,9,10
//然后通过某些操作,将其重新排列成1,3,5,7,9,10,8,6,4,2,即奇数升序偶数降序,并在屏幕上打印出来

#include "double_list.h"

int main()
{
    double_plist plist;
    int len;

    double_init(&plist);//双向链表初始化

    printf("Pls input the length of double list:");
    scanf("%d",&len);

    double_create(plist,len);//创建双向链表
    double_show(plist);//显示双向链表

    double_sort(plist);//完成奇数升序偶数降序排序
    double_show(plist);

    return 0;
}