数据结构-线性表

转载请注明出处数据结构-线性表rds.

线性表的顺序存储结构

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


# define OK 1
# define ERROR 0
# define TRUE 1
# define FALESE 0


// status 是函数的类型，其值是函数结果的状态代码，如OK等
typedef int status;


// 线性表的顺序存储结构代码
const int Maxsize = 20;
typedef int Elemtype;
typedef struct
{
    Elemtype data[Maxsize];
    int length; // 线性表当前长度
}Sqlist;



// getelem函数
/*
list中第i个元素的值作为e返回
*/
status Getelem(Sqlist list,int i,Elemtype *e)
{
    if(list.length == 0 || list.length < i)   
    {
        return ERROR;
    } 
    *e = list.data[i - 1];
    return *e;
}

// listinsert函数
/*
list中第i个位置插入新元素e
*/
status Listinsert(Sqlist *list,int i,Elemtype e)
{
    int k ;
    if (list->length == Maxsize)
    {
        return ERROR;
    }
    if ( i < 0 || i > list->length + 1)
    {
        return ERROR;
    }
    if ( i <= list->length)
    {
        for ( int k = list->length - 1; k >= i - 1; k --)
        {
            list->data[ k + 1 ] = list->data[k];
        }
    }
    list->data[i - 1] = e; // 将新元素插入，注意这里data下标是i - 1!

    list->length ++ ; // 这一步不要忘记！

    return OK; 

}

//Listdelete
status Listdelete (Sqlist *list,int i,Elemtype e)
{
    if(list->length == 0) // 第一次写的时候未考虑表为空的情况
    {
        return ERROR;
    }
    else if (i <= 0 || i > list->length) // 注意这两个条件是可以并起来的
    {
        return ERROR;
    }
    e = list->data[i - 1]; 
    printf("已删除e!\n");
    for(int k = i - 1; k <= list->length - 1; k ++)
    {
        list->data[k] = list->data[k + 1];
    }
    list->length --;

    return OK;
}

// listprint函数
status Listprint(Sqlist *list)
{
    printf("list: ");
    for(int i = 0; i < list->length; i ++)
    {
        printf("%d ",list->data[i]);
    }
    printf("\n");
    return OK;
}



int main()
{
    printf("hello world!\n");
    printf("------------------------------------------------------\n");
    printf("|选择菜单：\n");
    printf("|1.插入数字\n");
    printf("|2.按照位置删除\n");
    printf("------------------------------------------------------\n");
    printf("请输入一个数字：\n");

    //初始化一个list
    Sqlist list ;
    list.length = 0;
    
    //输入操作
    while(1)
    {
        int option;
        scanf("%d",&option);
        system("cls");
        if(option == 1)
        {
            //输入1 listinsert
            //插入元素
            
            int cnt;
            printf("请输入将要插入多少个元素：\n");
            scanf("%d",&cnt);
            for(int i = 1; i <= cnt ; i ++)
            {
                int e;
                printf("请输入要插入的数字:\n");
                scanf("%d",&e);
                // printf("i = %d ,e = %d\n",i,e);
                Listinsert(&list,i,e);
                Listprint(&list);
            }
        }
        else if (option == 2)
        {
            // 输入2 listdelete
            system("cls");
            printf("请输入要删除list中的第几个数字\n");
            int deln;
            scanf("%d",&deln);
            int e = 0;
            Listdelete(&list,deln,e);
            Listprint(&list);
        }
    }

    system("pause");
    return 0;
}

顺序表实现集合合并（合并后冒泡排序）

/*
    顺序表实现集合合并
*/
# include<stdlib.h>
# include<stdio.h>

# define OK 1
# define ERROR 0
# define Maxsize 100

typedef int Elemtype;

// 定义顺序表结构体
typedef struct list_struct
{
    Elemtype *data;// 基坐标
    int length; // 记录顺序表用到了哪里
}list_struct;
typedef list_struct *plist;


int list_init(plist list)
{
    list->data = (Elemtype *) malloc(Maxsize * sizeof(Elemtype));
    list->length = 0;
    return OK;
}

int list_insert(plist list,Elemtype e)
{
    list->data[list->length ++] = e;
    return OK;
}

int list_delete(plist list,Elemtype e)
{
    int j  = -1;
    for(int i = 0 ; i < list->length ; i ++)
    {
        if(list->data[i] == e)
        {
            j = i;
            break;
        }
    }
    while(j < list->length && j != -1)
    {
        // 覆盖掉即为删除
        list->data[j] = list->data[j + 1];
        j ++;
    }
    list->length --;

    return OK;
}

int list_combine(plist lista,plist listb)
{
    // 已经经过主函数处理，这里lista的长度已经比listb的长度大
    // listb长度小，所以让listb插入到a中去

    // 先删除重复元素

    for(int i = 0 ; i < listb->length ; i ++)
    {
        for(int j = 0 ; j < lista->length ; j ++)
        {
            if(listb->data[i] == lista->data[j])
            {
                //删除 listb中的data[i]
                list_delete(listb,listb->data[i]);
            }
            else continue;
        }
    }

    // listb中剩下的插入lista
    int listaidx = lista->length;
    for(int i = 0 ; i < listb->length ; i ++)
    {
        lista->data[listaidx ++] = listb->data[i];
        lista->length ++;
    }

    return OK;
}

int list_printf(plist list)
{
    for(int i = 0 ; i < list->length ; i ++)
    {
        printf("%d-",list->data[i]);
    }
    printf("\n");

    return OK;
}

// 冒泡排序
int list_sort(plist list)
{
    for(int j = 0; j < list->length ; j ++)
    {
        for(int i = 0 ; i < list->length - j - 1 ; i ++) // 这里要多减去一个1，因为本来最后的一个下标是list->length - 1 而不是list->length，这里是i从0开始，因为最大的一定放到了最后面，所以后面j个一定是最大的了不用去继续排序，而前面是小的仍要从0开始
        {
            if( list->data[i] > list->data[i + 1] )
            {
                int n = list->data[i];
                list->data[i] = list->data[i + 1];
                list->data[i + 1] = n;
                // printf("冒泡排序：%d和%d已经交换\n",list->data[i + 1],list->data[i]);
            }
        }
    }

    return OK;
}


int main()
{
    int an,bn,e;
    plist lista = (plist)malloc(sizeof(list_struct));
    plist listb = (plist)malloc(sizeof(list_struct));
    list_init(lista);
    list_init(listb);

    printf("请输入集合a中元素个数\n");
    scanf("%d",&an);
    printf("请输入集合a中的元素\n");
    while(an --)
    {
        scanf("%d",&e);
        list_insert(lista,e);
    }

    printf("请输入集合b中元素个数\n");
    scanf("%d",&bn);
    printf("请输入集合b中的元素\n");
    while(bn --)
    {
        scanf("%d",&e);
        list_insert(listb,e);
    }
    
    if(lista->length > listb->length) 
    {
        list_combine(lista,listb);
        printf("合并并排序后的集合为:");
        list_sort(lista);
        list_printf(lista);
    }
    else 
    {
        list_combine(listb,lista);
        printf("合并并排序后的集合为:");
        list_sort(listb);
        list_printf(listb);
    }
    
    

   

    // printf("listb为:");
    // list_printf(listb);
    // list_sort(listb);

    system("pause");
    return 0;
}

线性表的链式存储结构

单链表

// 单链表
# include<stdio.h>
# include<stdlib.h>


# define OK 1
# define ERROR 0
# define TRUE 1
# define FALESE 0


typedef int status;


typedef int Elemtype;

typedef struct Node
{
    Elemtype data;
    Node *next;
}Node;

typedef struct Node *Linklist;  

Linklist chainlist_creat(void)
{
    Linklist headnode = (Linklist)malloc(sizeof(Node)); // 这里必须使用molloc函数去为结点申请内存空间，这样才会返回一个指向该块内存的指针，我们才能找到那块内存。堆储存区的内存是可以自由使用的，但是在不使用的时候就要记得free。栈储存区的在函数运行完会自动回收内存
    Linklist list = headnode; // 这里直接创建了一个指向node类型的指针(头指针),并将它初始化了。
    /*
        headnode是一个指向头结点类型的指针
    */
    headnode->next = NULL; 
    headnode->data = 0; // 储存链表长度
    return list;
}

// 链表插入
status chainlist_insert(Linklist list, Elemtype e, int i)
{
    Linklist p;
    p = list;
    int j = 0; 
    while(j < i && p)
    {
        p = p->next;
        j ++;
    }
    if (!p) 
    {
        printf("p为null\n");
        return ERROR;
    }

    Linklist pnewnode = (Linklist)malloc(sizeof(Node));
    pnewnode ->data = e;
    pnewnode ->next = p->next;
    p->next = pnewnode;
    list->data ++;
    printf("链表现在长度为：%d\n",list->data);
    return OK;
}

// 链表打印
status chain_printf(Linklist list)
{
    printf("链表为：\n");
    Linklist p = list->next;
    while(p)
    {
        printf("%d-",p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}
// 链表查找
status chain_find(Linklist list,int i,Elemtype *e)
{
    Linklist p = list->next;
    int j = 1;
    while(p && j < i)
    {
        p = p->next;
        j ++;
    }
    if (!p)
    {
        return ERROR;
    }
    *e = p->data;
    return OK;
}
// 单链表删除
status chain_del(Linklist list,int i)
{
    Linklist p;
    p = list;
    int j = 1;
    while( j < i && p)
    {
        p = p->next;
        printf("删除操作——遍历到%d\n",p->data);
        j ++;
    }
    if( !p )
    {
        return ERROR;
    }
    int e;
    Linklist q = p->next;
    e = q->data;
    printf("第%d个元素%d已删除！\n",i,e);
    p->next = p->next->next;
    list->data --;
    free(q);

    return OK;
}


int main()
{
    Linklist list = chainlist_creat();
    while(1)
    {
        printf("-------------------------菜单---------------------\n");
        printf("0.清屏\n");
        printf("1.在第i个位置后面插入新元素e\n");
        printf("2.按位置查找,输出第i位置的元素e\n");
        printf("3.删除链表中第i个位置的元素\n");
        printf("--------------------------------------------------\n");
        int op;
        scanf("%d",&op);
        if(op == 1)
        {
            int i,e;
            printf("请输入i、e的值(想把新元素插入到第一个位置请输入0 e)\n");
            scanf("%d %d",&i,&e);
            chainlist_insert(list,e,i);
            printf("插入完成！\n");
            chain_printf(list);
        }
        else if (op == 2)
        {
            int i,*e;
            printf("请输入i的值\n");
            scanf("%d",&i);
            chain_find(list,i,e);
            printf("%d\n",*e);
        }
        else if(op == 3)
        {
            int i;
            printf("请输入i的值\n");
            scanf("%d",&i);
            chain_del(list,i);
            chain_printf(list);
            printf("\n");
        }
        else if(op == 0)
        {
            system("cls");
        }
    }
    return 0;

}

静态链表

/*
    静态链表，双数组实现。
    下面的写法很简洁，但是是具有局限性的，首先它删除的结点就不能free利用。还有分头插尾插。。。。。
*/



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

# define OK 1
# define ERROR 0


const int N = 10000;
int head,e[N],ne[N],idx; //head 指针指向头结点 e[]数组保存的是链表中的数，ne[]中是next指针，俩个通过下标关联起来，idx保存的是内存用到了哪个位置

int initlist(void)
{
    head = -1; // 头指针指向-1，链表为空
    idx = 0; // 内存用到了0

    return OK;
}

int Lengthlist(void)
{
    if(head == -1) return 0;
    int p = e[head];
    int cnt = 0;
    while( p > 0)
    {
        p = ne[p]; // 将指针的值赋值给p，若p为-1退出循环
        cnt ++;
    }
    return cnt;
}

int add_to_head(int x)
{
    e[idx] = x; // e[idx]就是新的内存 这里将新的元素e存入新申请的内存
    ne[idx] = head; // e[idx] 指向head的值，head 是指针，指向的是第一个结点。head的值就是第一个结点的位置（下标）
    head = idx ++; // head 指向idx 然后将idx ++ (下一次申请新内存直接ne[idx]即可)

    return OK;
}

// 在第K个位置的后面插入元素e
int insert_to_list(int k,int x)
{
    e[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx ++; // 这里注意，结点k的next指针应该指向的是 新结点 ，而新结点的位置(下标)就是idx，所以就直接是idx赋值给 k结点的next指针，idx ++ 是为了malloc新的“内存”

    return OK;
}

int remove_head(void)
{
    head = ne[head];

    return OK;
}

// 移除第k个位置的后继结点
int remove(int k)
{
    ne[k] = ne[ne[k]];

    return OK;
}

int printflist(void)
{
    int p = head;
    printf("链表为：\n");

    while(p >= 0)
    {
        printf("%d-",e[p]);
        p = ne[p];
    }
    printf("\n");

    return OK;
}

int main()
{
    initlist();
    while (1)
    {
        printf("--------------------menu-----------------------\n1.从头部插入\n2.在第k个结点后面插入元素x\n3.删除第K个结点后面的一个结点\n-----------------------------------------------------------------\n");
        int op;
        scanf("%d",&op);
        if(op == 1)
        {
            int x;
            printf("请输入x的值：\n");
            scanf("%d",&x);
            add_to_head(x);

            printflist();
        }
        else if(op == 2)
        {
            int k,x;
            printf("注意此方法不能插在头部和尾部！！！\n");
            printf("请输入k、x的值：\n");
            scanf("%d%d",&k,&x);
            insert_to_list(k,x);

            printflist();
        }
        else if(op == 3)
        {
            int k;
            printf("请输入k的值：\n");
            scanf("%d",&k);
            remove(k);

            printflist();
        }
    }

    return 0;
    
}

作业：如何快速得到单链表的中间结点

思路：快慢指针

// 作业1
// 随机生成20个随机数的链表，使用快慢指针得到中间元素的值

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

// 返回一个1 - 100之内的数字
int my_rand(void)
{
    srand((unsigned)time(0) + rand());
    int a = rand() % 100;
    return a;
}


// 定义一个结点
typedef struct Node 
{
    int data;
    Node *next;
}Node;

typedef Node *Link_list;


// 生成20个随机数链表，返回头指针
Link_list get_chain(void)
{
    Link_list p = NULL;

    //头结点
    Link_list head = (Link_list)malloc(sizeof(Node));
    p = head;
    head->next = NULL;
    
    // 头插法插入结点
    for(int i = 0; i < 20; i ++)
    {
        Link_list node = (Link_list)malloc(sizeof(Node));
        node->data = my_rand();
        node->next = head->next;
        head->next = node;
        printf("%d-",node->data);
    }
    printf("\n");
    return head;

}

// 获得链表中间值的快慢指针法
int get_chain_midelm(Link_list p)
{
    p = p->next; //指向第一个结点
    Link_list fast_p = p;
    Link_list slow_p = p;

    while(fast_p)
    {
        // printf("遍历到结点的data = %d\n",fast_p->data);
        fast_p = (fast_p->next)->next;
        
        slow_p = slow_p->next;
    }

    int mid = slow_p->data;
    printf("mid = %d\n",mid);

    return mid;
}

int main()
{
    Link_list listp = get_chain();
    get_chain_midelm(listp);
    system("pause");
    return 0;
}

单向循环链表

# include<stdlib.h>
# include<stdio.h>
# define OK 1
# define ERROR 0
typedef struct Node
{
    int data;
    Node *next;
}Node;

typedef Node* Link_list;

// 单向循环链表初始化

Link_list clist_init(void)
{
    Link_list list; // 链表名作为头指针 但是单向循环链表的头指针是指向尾结点的。或者我们称之为尾指针
    Link_list head = (Link_list)malloc(sizeof(Node));// 申请一个头结点

    if(head == NULL) exit(0); // 如果申请失败就 退出

    head->next = head; // 让头结点指向自己，就是一个链表为空的单向循环链表链表

    list = head;

    return list; // 返回尾指针
}

int clist_length(Link_list list)
{
    int length = 0;
    for(Link_list pnode = list; pnode->next != list; )
    {
        pnode = pnode->next;
        length ++;
    }

    return length;
}

//向单向链表头部插入新元素e
void clist_insert_head(Link_list list,int e)
{
    Link_list newnode = (Link_list)malloc(sizeof(Node));
    newnode->data = e;
    newnode->next = list->next;
    list->next = newnode;
}

//打印链表
void clist_printf(Link_list list)
{
    printf("链表为：\n");
    for(Link_list p = list;p->next !=list;)
    {
        p = p->next;
        printf("%d-",p->data);
    }
    printf("\n");
}
// 在单向链表中从尾部插入新的元素e
void clist_insert_end(Link_list list,int e)
{
    Link_list newnode = (Link_list)malloc(sizeof(Node));
    newnode->data = e;
    Link_list p = list;
    while(p->next != list) p = p->next; // 找到了尾结点的前一个结点,并用p指针指向了它
    p->next = newnode;
    newnode->next = list;
    
}
// 在单向循环链表中第i个位置之后插入元素e(即将元素插入到第i + 1个元素)，注意不能涉及到从头插入或从尾部插入！！！
int clist_insert(Link_list list,int e,int i)
{
    if(i < 0 || i > clist_length(list))
    {
        printf("i值错误！\n");

        return ERROR;
    }
    Link_list newnode = (Link_list)malloc(sizeof(Node));
    newnode->data = e;
    // 使指针遍历到第i个结点（p此时指向的就是第i个结点）
    Link_list p = list;
    for(int k = 0; k < i; k ++)
    {
        p = p->next;
    }
    // 开始插入
    newnode->next = p->next;
    p->next = newnode;

    return OK;
}

// 删除链表的第i个元素
int clist_remove(Link_list list,int i)
{
    Link_list p = list;
    for(int k = 0;k < i - 1; k ++)
    {
        p = p->next;
    }
    Link_list r_p = p->next;
    p->next = p->next->next;
    free(r_p);

    return OK;
}

int main()
{
    Link_list list = clist_init();
    while(1)
    {
        printf("=======================================================\n");
        printf("请输入操作数：\n1.向链表头部插入新元素e\n2.输出链表的长度\n3.在链表尾部插入新的元素\n4.在第i个元素后面插入新的元素e\n5.删除第i个结点\n...\n");
        printf("=======================================================\n");
        int op;
        scanf("%d",&op);

        if(op == 1)
        {
            int e;
            printf("请输入元素e的值:\n");
            scanf("%d",&e);
            clist_insert_head(list,e);
            clist_printf(list);
        }
        else if(op == 2)
        {
            int length = clist_length(list);
            printf("链表的长度为：%d\n",length); 
        }
        else if(op == 3)
        {
            int e;
            printf("请输入元素e的值:\n");
            scanf("%d",&e);
            clist_insert_end(list,e);
            clist_printf(list);
        }
        else if(op == 4)
        {
            int i,e;
            printf("请输入i、e的值:\n");
            scanf("%d%d",&i,&e);
            clist_insert(list,e,i);
            clist_printf(list);
        }
        else if(op == 5)
        {
            int i;
            printf("请输入要删除的结点i的值:\n");
            scanf("%d",&i);
            clist_remove(list,i);
            clist_printf(list);
        }
    }

    system("pause");
    return 0;
}

单向循环链表练习-约瑟夫环问题

// 约瑟夫环问题
/*
    一共41人围成一个圈，开始报数，每个报3的人自杀，求出这41个人自杀顺序编号输出

    -----循环列表解决
*/

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

# define OK 1
# define ERROR 0
# define TRUE 1
# define FALSE 0

// 每个人为一个结点,idx是这个人的编号
typedef struct Node
{
    int idx;
    Node *next;
}Node;

typedef Node *Clink_list;

Clink_list cylist;

int clist_init(void)
{
    Clink_list end_node = (Clink_list)malloc(sizeof(Node));
    end_node->idx = 41;
    end_node->next = end_node;
    cylist = end_node;
    for(int i = 40;i >=1;i --)
    {
        Clink_list new_node = (Clink_list)malloc(sizeof(Node));
        new_node->idx = i;
        new_node->next = end_node->next;
        end_node->next = new_node;
    }
    return OK;
}

void clist_printf(void)
{
    Clink_list p = cylist->next;
    while(p->next != cylist->next)
    {
        printf("%d-",p->idx);
        p = p->next;
    }
    printf("%d",p->idx);
    printf("\n");
}

// 一直遍历链表，将答案输出
void answer_clist_remove(void)
{
    Clink_list p = cylist->next;
    int i = 1,cnt = 1;
    while(p != NULL)
    {
        // 每当轮到人报数2，他的下一个人必定报3自杀
        if(i == 2)
        {
            Clink_list throw_p = p->next;
            p->next = p->next->next; // 直接绕过即可，然后下一个人报数1
            printf("%d:编号为%d的人自杀\n",cnt ++ ,throw_p->idx);
            free(throw_p);
        }
        i ++;
        if(i == 3) i = 1;
        p = p->next;
        if(p->next == p) 
        {
            printf("最后一个人编号为%d\n",p->idx);
            break;
        }
    }
}

int main()
{
    clist_init();
    clist_printf();
    answer_clist_remove();
    system("pause");
    return 0;
}

单向循环链表练习2-约瑟夫环问题升级版

// 约瑟夫环问题-升级版
/*
    有1-N个人，每个人手中有一个密码（正整数m，可以控制输入），然后从第一个人开始，第一个人手中的密码为m1
    ,开始报数，当谁报的数为第一个人手中的密码数字m1时，他就自杀，自杀的这个人手中的密码m'为新的自杀数。
    
    输出每个自杀的人的编号
*/

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

# define OK 1
# define ERROR 0
# define TRUE 1 
# define FALSE 0

typedef struct Node
{
    int idx; // 这个人的序号值
    Node *next; 
    int m_number; // 这个人手中的密码
}Node;

typedef Node *Clink_list;

Clink_list clist;

Clink_list clist_init(void)
{
    printf("链表初始化：\n");
    
    Clink_list head = (Clink_list)malloc(sizeof(Node));
    head->idx = 1;
    
    int pwd;
    printf("请输入第1个人的密码设为？\n");
    scanf("%d",&pwd);
    head->m_number = pwd;
    head->next = head;

    clist = head;
    return clist;
}

// 传入数据n个人，将剩下的n-1个人插入到循环列表中
// 尾插法
int clist_init_2(int n)
{
    for(int i = 1;i < n ; i ++)
    {
        int n_nbr;
        printf("请设置第%d个人的密码是？\n",i + 1);
        scanf("%d",&n_nbr);
        
        Clink_list newnode = (Clink_list)malloc(sizeof(Node));
        newnode->idx = i + 1;
        newnode->m_number = n_nbr;
        newnode -> next = clist -> next; // clist表示的就是尾结点
        clist->next = newnode;

        clist = newnode;
    }

    return OK;
}

int clist_printf()
{
    Clink_list p = clist -> next;
    while(p->next != clist)
    {
        printf("第%d个人，密码是：%d\n",p->idx,p->m_number);
        p = p->next;
    }
    printf("第%d个人，密码是：%d\n",p->idx,p->m_number);
    p = p->next; // 上面只是循环到了clist(尾结点)的前一个结点，所以要再走一步输出
    printf("第%d个人，密码是：%d\n",p->idx,p->m_number);

    return OK;
}



int clist_remove(void)
{
    Clink_list p = clist->next;
    int k = 1; // 记录每个人报数
    int cnt = 1; // 记录每个人的序号
    int m = p->m_number;
    while(p->next != p) // 只剩自己一个人的时候退出
    {
        // p 真杀他自己
        if (m == 1) 
        {
            // 使用一个新指针q来遍历到 要自杀的p的前一个结点，从而实现对p的绕过
            Clink_list q = clist;
            while(q->next != p)
            {
                q = q->next; 
            }
            Clink_list cut_p = q->next;
            // 如果要删除的结点是尾结点，需要将尾结点的指针前移
            if(q->next->idx == clist->idx)
            {
                clist = q;
            }
            q->next = q->next->next;
            
            p = p->next;
            printf("第%d个自杀的人的序号是%d，他的密码是%d\n",cnt ++,cut_p->idx,cut_p->m_number);
            m = cut_p->m_number;

            free(cut_p);
            k = 1;
        }
        else if(k == m - 1) // 如果报数到 m - 1，则下一个人需要被自杀，即这时候p的下一个结点需要被删掉
        {
            Clink_list cut_p = p->next; 
            
            if(p->next->idx == clist->idx)
            {
                clist = p;
            }
            p->next = p->next->next;
            printf("第%d个自杀的人的序号是%d，他的密码是%d\n",cnt ++,cut_p->idx,cut_p->m_number);
            m = cut_p->m_number;
            free(cut_p);
            p = p->next;
            k = 1;
        }
        else 
        {
            k++;
            p = p->next;
        }
    }
    printf("第%d个自杀的人的序号是%d，他的密码是%d\n",cnt ++,p->idx,p->m_number);

    return OK;
}

int main()
{
    clist_init();
    printf("一共有n个人，请输入n的值：\n");
    int n;
    scanf("%d",&n);
    clist_init_2(n);
    clist_printf();
    clist_remove();
    system("pause");
    return 0;
}

两个单向循环链表的合并

/*
    将两个单向循环链表链接在一起
*/
# include<stdio.h>
# include<stdlib.h>

# define OK 1
# define ERROR 0
# define FALSE 0
# define TRUE 1

typedef struct Node
{
    int data;
    Node * next;
}Node;

typedef Node *Clink_list;



// 初始化循环链表，传入循环链表名字，返回循环链表名字
Clink_list clist_init(Clink_list clist)
{
    // 先设置尾结点
    Clink_list end_node = (Clink_list)malloc(sizeof(Node));
    end_node -> data = 10;
    end_node -> next = end_node;
    for(int i = 9; i >= 1; i --)
    {
        Clink_list p = (Clink_list)malloc(sizeof(Node));
        p->data = i;
        p->next = end_node->next;
        end_node->next = p;
        end_node = p;
    }
    clist = end_node;

    return clist;
}
int clist_printf(Clink_list clist)
{
    int clength = 1;
    printf("链表为：");
    Clink_list p;
    for(p = clist->next; p != clist;p = p->next) // p遍历到维结点就立马退出了，所以尾结点需要单独输出一次并length++
    {
        printf("%d-",p->data);
        clength ++;
    }
    printf("%d-",p->data);
    printf("\n");

    printf("该链表长度为%d\n",clength ++);
    return OK;
}

Clink_list clist_combine(Clink_list lista,Clink_list listb)
{
    Clink_list ahead = lista->next;
    lista->next = listb->next;
    listb->next = ahead;

    return listb;
}

int main(void)
{
    // 初始化
    Clink_list clist_a = clist_init(clist_a);
    Clink_list clist_b = clist_init(clist_b);

    clist_printf(clist_a);
    clist_printf(clist_b);

    Clink_list clist_c = clist_combine(clist_a,clist_b);
    clist_printf(clist_c);
    
    system("pause");
    return 0;
}

判断链表是否有环

/*
    判断单链表中是否有环：
    双指针算法，使用快慢双指针。
    指针p q 同时开始遍历,一个移动1一个移动2，当p == q 真值为1的时候说明有环
*/

// 这里做一个单向循环列表，一个单向链表用来判断

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

# define OK 1
# define ERROR 0
# define TRUE 1
# define FALSE 0

typedef struct Node
{
    int data;
    Node *next;
}Node;

typedef Node *Link_list;

Link_list list_init(Link_list list)
{
    Link_list head_node = (Link_list)malloc(sizeof(Node));
    head_node->data = 10;
    head_node->next = NULL;
    for(int i = 9;i >= 1; i --)
    {
        Link_list node = (Link_list)malloc(sizeof(Node));
        node->data = i;
        node->next = head_node;
        head_node = node;
    }

    list = head_node;
    return list;
}

int list_printf(Link_list list)
{
    Link_list p = list;
    printf("单向链表为：");
    while(p != NULL)
    {
        printf("%d-",p->data);
        p = p->next;
    }
    printf("\n");

    return OK;
}

Link_list clist_init(Link_list clist)
{
    Link_list end_node = (Link_list)malloc(sizeof(Node));
    end_node->data = 10;
    end_node->next = end_node;
    clist = end_node;
    for(int i = 9;i >= 1; i --)
    {
        Link_list new_node = (Link_list)malloc(sizeof(Node));
        new_node->data = i;
        new_node->next = end_node->next;
        end_node->next = new_node;
    }

    return clist;
}

int clist_printf(Link_list clist)
{
    Link_list p = clist->next;
    printf("链表为：");
    while(p != clist)
    {
        printf("%d-",p->data);
        p = p->next;
    }
    printf("%d-\n",p->data);

    return OK;
}

// 返回0或1，0代表无环，1代表有环
int judge_loop(Link_list list)
{
    int judge = 0; // 0代表无环，1代表有环
    Link_list fast_p = list;
    Link_list slow_p = list;

    while(slow_p != NULL )
    {
        fast_p = fast_p->next;
        if(fast_p == NULL) break;
        fast_p = fast_p->next;
        if(fast_p == NULL) break;
        slow_p = slow_p->next;
        if(fast_p == slow_p)
        {
            judge = 1;
            break;
        }
    }

    return judge;
}

int main()
{
    Link_list lista; // 单向链表
    lista = list_init(lista);
    list_printf(lista);

    Link_list clista;
    clista = clist_init(clista);
    clist_printf(clista);
    
    int jud_clist = 0,jud_list = 0;
    jud_list = judge_loop(lista);
    jud_clist = judge_loop(clista);

    printf("clista有无环：%d\nlista有无环：%d\n",jud_clist,jud_list);

    system("pause");
    return 0;
}

★魔术师发牌问题★

首先手动模拟一下，思路见代码

一个思想，假设是正确的。假设我们的循环链表就是正确的答案。

/*
    魔术师发牌问题:
    魔术师将A 2 3 4 5 6 7 8 9 10 J Q K十三张牌按照一定顺序叠放好，将有花色的一面朝下。
    第一次，魔术师开始数数，数1，停止数数。将最上面的牌翻过来，然后将其放在桌面上展示，是A。
    第二次，魔术师开始数数，数1，2，停止数数。将牌顶的第一张牌放到牌堆最下方，第二张牌翻过来，然后将其放在桌面上展示，是2。
    第三次，魔术师开始数数，数1，2，3，停止数数。将牌顶的第一二张牌放到牌堆最下方，第三张牌翻过来，然后将其放在桌面上展示，是3。
    ......
    直到将所有的牌亮出来为止，问原来的顺序是怎么样的？
*/
# include<stdlib.h>
# include<stdio.h>

# define OK 1
# define ERROR 0
# define TRUE 1
# define FALSE 0

typedef struct Node 
{
    int idx;
    int data;
    Node *next;
}Node;

typedef Node *Clink_list;

// 初始化循环列表 
Clink_list magic_clist_init(Clink_list clist)
{
    Clink_list end_node = (Clink_list)malloc(sizeof(Node));
    end_node->data = 0;
    end_node->idx = 13;
    end_node->next = end_node;
    clist = end_node;

    for(int i = 1 ; i <= 12; i ++) // 由于只有13张牌，所以这里就直接使用数值13.如果扑克牌有14、15等等，把这里的12改成13、14等等即可
    {
        Clink_list new_node = (Clink_list)malloc(sizeof(Node));
        new_node->data = 0;
        new_node->idx = i;
        Clink_list p = end_node->next;
        while(p->next != end_node)
        {
            p = p->next;
        }
        p->next = new_node;
        new_node->next = end_node;
    }

    return clist;
}

int clist_count(Clink_list clist)
{
    Clink_list p = clist->next;
    int cnt = 0;
    // printf("链表：");
    while(p != clist)
    {
        // printf("%d-",p->data);
        cnt ++;
        p = p->next;
    }
    // printf("%d\n",p->data);
    // printf("循环链表中有%d个元素\n",++ cnt);

    return ++cnt;
}
/*
    假设我的链表中的每一个结点的data的值就是正确的顺序。
    向循环链表中的结点添加data = see_n（将要翻过来牌的数），然后将这个结点remove掉

*/
int mclist_remove(Clink_list clist)
{
    int speak_n = 1,see_n = 1;//speak_n表示魔术师的报数,see_n表示下一个翻过来的牌的数,order_n表示正确排序的第几张牌
    Clink_list p = clist->next; // p去遍历
    while(p)
    {
        for(speak_n = 1;speak_n < see_n ; speak_n ++)
        {
            p = p->next;
        }
        p->data = see_n ++;
        printf("牌堆中第%d牌应该是%d\n",p->idx,p->data);

        //删除结点
        Clink_list cut_p = p,q = clist->next;
        // 使用q遍历到想要删除的结点p前面的一个结点
        while(q->next != cut_p)
        {
            q = q->next;
        }
        // 对p结点绕过
        q->next= q->next->next;


        if(clist_count(clist) == 1) break;
        p = q->next;
        // printf("p->data = %d\n",p->data);
        free(cut_p);
    }
    p = p->next;
    p->data = see_n ++;
    printf("牌堆中第%d牌应该是%d\n",p->idx,p->data);

    return OK;
}

int main()
{
    Clink_list clist;
    clist = magic_clist_init(clist);
    clist_count(clist);
    mclist_remove(clist);
    system("pause");
    return 0;
}

拉丁方阵问题

/*
        拉丁方阵是一种n×n的方阵，方阵中恰有n中不同的元素，每种元素恰有n个，并且每种元
    素在一行和一列中恰好出现一次。著名数学家和物理学家欧拉使用拉丁字母来做为方阵里元素
    的符号，拉丁方阵因此而得名。
*/

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

typedef struct Node
{
    int data;
    Node *next;
}Node;

typedef Node *Clink_list;

Clink_list clist_init(Clink_list clist)
{
    Clink_list end_node = (Clink_list)malloc(sizeof(Node));
    clist = end_node;

    end_node->data = 9;
    end_node->next = end_node;

    for(int i = 1;i <= 8; i ++)
    {
        Clink_list new_node = (Clink_list)malloc(sizeof(Node));
        new_node->data = i;
        Clink_list p = end_node;
        while(p->next != end_node)
        {
            p = p->next;
        }
        new_node->next = end_node;
        p->next = new_node;
    }

    return clist;
}

void latin_printf(Clink_list clist)
{
    printf("latin:\n");
    int k = 9;
    while(k --)
    {
        Clink_list p = clist->next;
        while(p != clist)
        {
            printf("%d ",p->data);
            p = p->next;
        }
        printf("%d\n",p->data);
        clist = clist->next;
    }
}

int main()
{
    Clink_list clist ;
    clist = clist_init(clist);
    latin_printf(clist);

    system("pause");
    return 0;
}

双向循环链表

/*
    双向链表
    初始化
    插入
    删除
    输出
*/

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

typedef struct Node
{
    int data;
    Node *prior;
    Node *next;
}Node;

typedef Node *Doublelink_list;

Doublelink_list doublelist_init(Doublelink_list dlist)
{
    Doublelink_list head_node = (Doublelink_list)malloc(sizeof(Node));
    dlist = head_node;
    Doublelink_list end_node = (Doublelink_list)malloc(sizeof(Node));
    head_node->data = 0;
    end_node->data = 0;

    head_node->next = end_node;
    head_node->prior = end_node;
    end_node->next = head_node;
    end_node->prior = head_node;

    return dlist;
}
int doublelist_length(Doublelink_list dlist)
{
    int length = 0;
    for(Doublelink_list p = dlist;p != dlist->prior ; p = p->next)
    {
        length ++ ;
    }
    length ++ ;

    return length;
}

// 在第i个元素之后插入元素e
Doublelink_list doublelist_insert(Doublelink_list dlist,int i,int e)
{
    if(i <= doublelist_length(dlist) - 2 && i >= doublelist_length(dlist)) 
    {
        printf("双向链表与长度与输入的i不符！\n");
        exit(1);
    }
    Doublelink_list p = dlist;
    // 使用p指针遍历到第i个结点本身
    for(int k = 1;k < i ;k ++)
    {
        p = p->next;
    }
    // 插入
    Doublelink_list new_node = (Doublelink_list)malloc(sizeof(Node));
    new_node->data = e;

    new_node->next = p->next;
    new_node->prior = p;
    p->next->prior = new_node;
    p->next = new_node;
    
    return dlist;
}

// 删除第i个位置的元素，并返回其值e
int doublelist_delete(Doublelink_list dlist,int i)
{
    if(i >= doublelist_length(dlist) && i <= 1)
    {
        printf("链表长度与i的值不符！\n");
        exit(1);
    }
    Doublelink_list p = dlist;
    // 先使用p指针遍历到第i个元素的前一个元素
    for(int k = 1; k < i - 1; k ++)
    {
        p = p->next;
    }
    Doublelink_list cut_p = p->next;
    p->next->prior = p;
    p->next = p->next->next;

    int e = cut_p->data;
    printf("被删掉的元素是%d\n",e);
    free(cut_p);

    return e;
}

void doublelist_printf(Doublelink_list dlist)
{
    Doublelink_list p = dlist;
    printf("链表为:");
    while(p != dlist->prior)
    {
        printf("%d-",p->data);
        p = p->next;
    }
    printf("%d\n",p->data);
}

int main()
{
    Doublelink_list dlist;
    dlist = doublelist_init(dlist);
    int dlist_length = doublelist_length(dlist);
    printf("%d\n",dlist_length);

    printf("插入操作：请输入插入操作的个数?\n");
    int cnt = 0;
    scanf("%d",&cnt);
    while(cnt --)
    {
        int i,e;
        printf("请输入要在第几个元素后面插入？插入元素的值是多少？\n");
        scanf("%d%d",&i,&e);
        doublelist_insert(dlist,i,e);
        doublelist_printf(dlist);
    }
    printf("删除操作：请输入删除操作的个数？\n");
    scanf("%d",&cnt);
    while(cnt --)
    {
        int i;
        printf("请输入要删除第几个元素？\n");
        scanf("%d",&i);
        doublelist_delete(dlist,i);
        doublelist_printf(dlist);
    }


    system("pause");
    return 0;
}