《数据结构》实验报告(链表进阶)：约瑟夫回环 链表去重

目录

一、约瑟夫回环问题（循环链表 解法）

 ！注  ！

二、链表去重

---

一、约瑟夫回环问题（循环链表 解法）

        n个数据元素构成一个环，从环中任意位置开始计数，计数到m将该元素从表中取出，重复上述过程，直至表中只剩下一个元素。

        提示：用一个无头结点的循环单链表来实现n个元素的存储。

算法代码：

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define ERROR 0
#define OK 1

typedef  int ElemType;   /*定义表元素的类型*/
typedef struct LNode{    /*线性表的单链表存储*/
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

LinkList ListCreate(int n);   /*创建元素个数为n的循环链表(不带头结点)*/
void PrintList(LinkList L,int n);   /*打印链表中的n个数据*/
int JosephRing(LinkList L,int n,int m);   /*约瑟夫环循环取出操作*/

LinkList ListCreate(int n){
    ElemType e;
    int i;
    LNode *L;
    LNode *head;   //先分配头节点方便插入数据，最后释放
    head=(LinkList)malloc(sizeof(LNode));
    head->next = head;
    LNode *p = head;   //指针p指向链表中“最后”一个结点
    LNode *r;
    for(i=1;i<n+1;i++){
        r=(LinkList)malloc(sizeof(LNode));   /*为新结点分配空间*/
        printf("输入要插入的元素%d：",i);
        scanf("%d",&e);
        r->data=e;
        r->next=head;
        p->next=r;
        p = r;
    }
    L = head->next;   //L指向链表中第一个结点
    p->next = L;
    free(head);
    return L;
}/*ListCreate*/

void PrintList(LinkList L,int n){
    LNode *p;
    p = L;
    int i;
    for(i=0;i<n;i++){
        printf("%5d  ",p->data);
        p=p->next;
    }
}/*PrintList*/

/*约瑟夫回环*/
int JosephRing(LinkList L,int n,int m){   /*n个数据元素构成环，计数到m取出*/
    LNode *p;
    LNode *q;
    p = L;
    int i,j;
    for(i=1;i<n;i++)  //外层循环执行一次删除一个结点
	{
	    if(1 == m){
            q = p;   //q指向删除结点
            p = q->next;
            printf("\n第%d个删除的元素是：%d",i,q->data);
            free(q);
        }
        else{
            for(j=2;j<=m-1;j++)
	        p=p->next;   //循环退出p指向第m-1个结点
            q=p->next;
	        p->next=q->next;  //删除第m个结点
	        printf("\n第%d个删除的元素是：%d",i,q->data);
	        free(q);
            p = p->next;  //从下一个元素开始重新计数
        }
    }
    return (p->data);  //返回表中最后一个数据
}/*JosephRing*/

int main()
{
	int n,m;
	printf("1-请输入链表元素个数n(n>0)：");
	scanf("%d",&n);
    LinkList L = NULL;
	L = ListCreate(n);  //创建含n个元素的循环链表
	printf("\n2-打印表中数据：");
	PrintList(L,n);
	printf("\n\n3-请输入计数m：");
	scanf("%d",&m);
	printf("\n\n4-表中最后一个元素为：%d",JosephRing(L,n,m));
    return 0;
}

运行结果：

 ！注  ！

       有的代码对计数m使用了m%=n取余操作，但该操作只适用于第一个元素的删除，会导致接下来删除的元素不正确。

具体实例分析：

数据元素个数 n = 5  ; 计数 m = 6 

①直接使用原始m值计数：

第一个删除的数据应该是 1

第二个删除的数据应该是 3

第三个删除的数据应该是 2

 第四个删除的数据应该是 5 (最终剩下的数据为 4 )

②使用 m = m%n 计数：

m = 6 % 5 = 1

第一个删除的数据应该是 1

 

第二个删除的数据应该是 2

以此类推，最后剩下的数据是 5

 

 m%n 取余操作避免了m>n情况下一定会先完整遍历一遍表中所有数据的过程。

1、按照 m = m % n 计数操作下第一个删除的元素和按原始m计数操作下第一个删除的元素是相同的。

2、但删除一个元素后表中数据个数 - 1，接下来继续使用该m计数删除的元素和使用原始m计数删除的数据就不一定相同了( m > n 情况下)。

二、链表去重

        设一带头结点的单链表，设计算法将表中值相同的元素仅保留一个结点。

        提示：指针p从链表的第一个元素开始，利用指针q从指针p位置开始向后搜索整个链表，删除与之值相同的元素；指针p继续指向下一个元素，开始下一轮的删除，直至p＝＝null为至，既完成了对整个链表元素的删除相同值。

算法代码：

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1

typedef  int ElemType;   /*定义表元素的类型*/
typedef struct LNode{    /*线性表的单链表存储*/
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

LinkList CreateList(int n);   /*创建一个长度为n的链表*/
void PrintList(LinkList L);   /*输出带头结点单链表的所有元素*/
void distinct(LinkList L);    /*链表去重*/

LinkList CreateList(int n){
    LNode *p,*q,*head;
    int i;
    head=(LinkList)malloc(sizeof(LNode));
    head->next=NULL;
    p=head;
    for(i=0;i<n;i++){
       q=(LinkList)malloc(sizeof(LNode));
       printf("请输入数据 %i：",i+1);
       scanf("%d",&q->data);            /*输入元素值*/
       q->next=NULL;                    /*结点指针域置空*/
       p->next=q;                       /*新结点连在表末尾*/
       p=q;                             /*p始终指向链表中最后一个结点*/
    }
    return head;  //head-指向头结点
}/*CreateList*/

void PrintList(LinkList L){
    LNode *p;
    p=L->next;   /*p指向单链表的第1个元素*/
    while(p!=NULL){
        printf("%5d",p->data);
        p=p->next;
    }
}/*PrintList*/

void distinct(LinkList L){
    LNode *p;
    LNode *q;
    LNode *t;
    p = L->next;   /*p指向单链表的第1个元素*/
    while(p){
        t = p;   //t始终指向q前一个元素
        q = p->next;   /*q指向p后一个元素*/
        while(q){
            if(q->data == p->data){
                t->next = q->next;
                q = q->next;
            }
            else{
                t = q;
                q = q->next;   //q向后搜索整个链表
            }
        }
        p = p->next;   //p继续指向下一元素，开始下一轮删除
    }
}/*distinct*/


int main(){
    int n;
    LinkList L=NULL;            /*定义指向单链表的指针*/
    printf("1-请输入链表元素个数n：");   /*输入单链表的元素个数*/
    scanf("%d",&n);
    if(n>0){
        printf("\n");
        L=CreateList(n);
        printf("\n2-打印链表数据：");
        PrintList(L);
        distinct(L);   //链表去重
        printf("\n\n3-去重后的链表：");
        PrintList(L);
    }else
        printf("ERROR");
    return 0;
}

运行结果：