单循环链的计算方法

㈠ 写算法，求出单循环链表L中值为最大的结点的指针。已知各结点中有data和next两个字段

中间变量指针a, 初始化为头节点的指针。中间变量(存数据的)b，初始化头节点的data的值

从头开始遍历，比较每个节点的data和b的大小
节点的data大的，把该节点指针和data保存到a和b中
节点data小的，什么都不做

遍历完，a就是你要求的

㈡ 用带尾指针的单循环链表作为队列的存储结构 设计算法以实现队列的各运算

typedef struct LNode {
//定义链表节点
int data;
struct LNode *next;
}LNode, *LinkList;

LinkList Head; //定义全局变量链表头

//构造空链表
LinkList InitList( )
{
static LinkList head;
head = (LinkList) malloc (sizeof(LNode));
if( ! head) exit (OVERFLOW);
head->next = NULL;
return head;
}

//输入数据插入到链表后，创建循环链表
Status CreateList(LinkList head ,int m)
{
LinkList p,q;
int i;
p = head;
for(i=1;i<m+1;i++) {
q = (LinkList)malloc(sizeof(LNode));
q->data = i;
q->next = NULL;
p->next = q;
p = p->next;
if(i == m) { p->next = Head->next; } //链成循环链表
}
return OK;
}

㈢ 3.以单循环链表作为存储结构，设计一个解决约瑟夫问题的算法。约瑟夫问题为：设编号为1，2，......，n

以前做的你试试吧

# include<stdio.h>
# include<malloc.h>
# define LEN sizeof(struct people)

struct people //定义结构体people
{
int num;
struct people *next;
};

struct people *creat(int n) //创建节点，并按在节点赋值以作为节点序号
{
struct people *p;
p=(struct people *) malloc(LEN);
p->num=n;
return(p);
}

void main()
{
struct people *p,*head,*p1; //p指针为创建指针；head指向num=0节点；p1为实际运算时所用指针
int num,jump,start,i,j=1;
printf("\n********************************* Josephus问题 *********************************\n");
printf("请输入参与人数：\n");
scanf("%d",&num);
printf("请输入间隔数：\n");
scanf("%d",&jump);
printf("请输入从第几人开始：\n");
scanf("%d",&start);
while(num<1||jump<1||start<1) //防止输入出错，增强强壮性
{
getchar();
printf("输入人数有误，请重新输入:\n");
printf("请输入参与人数：\n");
scanf("%d",&num);
printf("请输入间隔数：\n");
scanf("%d",&jump);
printf("请输入从第几人开始：\n");
scanf("%d",&start);
}
head=p=creat(1); //给head和p赋初值
for(i=2;i<=num;i++) //根据输入的num数，创建num个节点
{
p->next=creat(i);
p=p->next;
}
p->next=head; //将最后一个节点的next指向head，使链表成环
for(i=1;i<start;i++) //根据输入的Start数，将p向后移Start-1位，将值给p1
p=p->next;
p1=p; //将p1指向要开始计数的前一个节点
printf("结果排序如下：\n");
if(num!=1)
{
do //当num不为1时，p1每向后移一位，j的值增加一位
{
if(jump==1) //当junp=1时顺序输出各数
{
printf("%d\t",p1->next->num);
p1->next=p1->next->next;
j=1;
}
else
{
p1=p1->next;
j++;
if(j==jump) //当j的值等于jump值时，输出p1指向的下一个节点的num值，并将p1的下一个节点跳过，j重新计数
{
printf("%d\t",p1->next->num);
p1->next=p1->next->next;
j=1;
}
}
}while(p1->next!=p1); //当p1指向节点的next等于它本身时，循环结束
}
printf("%d\n",p1->num);
}

㈣ 设已有一个单循环链表，结点有三个域，pre 、data、next ，请设计一个算法，大家帮帮忙啊

struct node{
int data;
node *pre,next;
}

假设单循环链表中，头结点指针为head,所有结点的next域已全部赋值。

void Change(node *head)
{
if(head == NULL)
{
return;
}
if(head->next == NULL)
{
head->pre = head;
head->next = head;
return;
}

node *p,*q;
p=head;
q=head->next;
while(q->next != NULL)
{
q->pre = p;
p = p->next;
q = q->next;
}
q->next = head;
head->pre = q;
}

㈤ 关于C语言版数据结构中的单循环链表

void showlist(linklist head){//遍历输出链表
listnode *p;
p=head;
if(p->next=head){//这行里的p->next=head应写成p->next==head
printf("list is empty!\n");
return;
}
else{
while((p=p->next)!=head){
printf("%d ",p->data);
}
}
}

㈥ 试编写算法求单循环链表的表长

typedef struct Node
{int data;
struct Node *next;
}Node,*Link;
typedef structu
{Link *head,*tail;
int len;
}LinkList;

int length(LinkList L)
{return L.len;
}

㈦ 有两个带头结点的单循环链表L1和L2，编写算法将链表L2链接到链表L1之后成为一个单循环链表

list * connect(list* L1,list* L2)
{
list * p=L1
while(p->next)
p=p->next; //找到L1最后一个节点
p->next=L2->next; //把L2的节点连到L1的末端
while(p->next)
p=p->next; //找到L2最后一个节点
p->next=L1; //将next指向L1头节点，形成循环链表
return L1;
}

㈧ 单循环赛制怎么计算

单循环比赛的场数，可用下面的公式计算(简单的数学组合公式）：

比赛场数= 队数*(队数-1)/2

如6个队或7个队参加比赛，则比赛场数为：

6 *(6-1)/2 =15(场) 7*(7-1)/2 =21(场)

比赛轮数：在循环制的比赛中，各队都参加完一场比赛即为一轮。(所有队数同时进行一场比赛为一轮)

参加比赛的队数为单数时，比赛轮数等于队数。如5个队参加比赛，即比赛轮数为五轮。

参加比赛的队数为双数时，比赛轮数等于队数减一。如6个队参加比赛，则比赛轮数为五轮。

(8)单循环链的计算方法扩展阅读：

循环赛的各个参赛者（队）的名次需在整个比赛结束以后，统计各自的积分才能最终全部确定，所以一旦开赛就不便增减参赛者，不然就会影响各参赛者成绩的计算，不时闹出的退赛风波就暴露了这个弱点。

另外，循环赛的每一场比赛除了产生当事双方的成绩以外，还可能影响到第三方的名次，这就为产生各种涉及人情、关系、利益的比赛埋下了隐患，以影响比赛的公平公正。由此可见，循环赛是种封闭式的、易受干扰的比赛制度。

为避免循环赛运行时可能出现的麻烦，可选用排位赛制度予以代之。

㈨ 单链表、单循环链表和双向链表

1.单链表不行，因为单链表没有办法得到其前驱；
2. 单循环链表可以，假设链表的元素大于等于2：
struct Node
{
Node * next;
int data;
};

循环链表 Node * list;
Node *pnode = p;

while(pnode->next != p)
{
pnode = pnode->next;
}

//找到其前驱了
int tmp = pnode->data;
pnode->data = p->data;
p->data->tmp;

3.双向链表可以，假设链表的元素大于等于2，且p不为链表头。
struct Node
{
Node * next;
Node * pre;
int data;
}

双向链表list;
Node *pnode = p;
if(p->pre != NULL)
{
int tmp = p->data;
p->data = p->pre->data;
p->pre->data = tmp;
}