列联表检验的原假设 假设某个单向回圈连结串列的长度大于1，且表中既无头结点也无头指标。已知s为指向连结串列中第s个元素，试编写演算法

假设某个单向回圈连结串列的长度大于1，且表中既无头结点也无头指标。已知s为指向连结串列中第s个元素，试编写演算法  

假设某个单向回圈连结串列的长度大于1，且表中既无头结点也无头指标。已知s为指向连结串列中第s个元素，试编写演算法

如果回圈连结串列没有头，那么哪一个链结是0号元素呢？第s个元素就应该是从0号元素往后查询，将0号算在内沿着指标指向的目标访问s次就可以查询到第s个，第s个元素的编号就是第s-1号。那么0号结点就是头结点，指向它的指标就是头指标，怎能没有头结点和头指标呢？
有的头结点是另一个意思，就是头结点当指标用，next指标指向第一个节点。本质上还是头指标。

回圈连结串列的特点是表中最后一个节点的指标指向头结点（如无头结点则指向第一个元素结点）

就是形成了一个环才叫回圈连结串列的，如果是双向连结串列则构成了2个环

建立无头结点回圈连结串列

typedef struct LNode
{
int password; 密码
int No; 序号
struct LNode *next; 下一成员指标
}member; 成员结构体
typedef int status;
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#include <stdio.h>
#include <stdlib.h>
status CreateList_Circle(member **,int);
status DeleteNode(member **);
status main()
{
int n,m;
member *head=NULL,*p=NULL; 头指标即首成员地址，遍历指标p
printf ("Please enter number of people:n");
scanf ("%d",&n); 总成员数
while (n<=0)
{
printf ("n must be positive, please enter again:n");
scanf ("%d",&n);
}
if(!CreateList_Circle(&head,n)) 建立回圈连结串列，返回头指标head
return OVERFLOW;
printf ("Please enter initial m:n");
scanf ("%d",&m); 初始m
while (m<=0)
{
printf ("m must be positive, please enter again:n");
scanf ("%d",&m);
}
printf ("nThe order is:n");
p=head;
while (n>=2) 寻找出列成员
{
int i;
m=(m%n==0)?n:m%n; 化简m值
for (i=1;i<m;i++)
p=p->next; p指向出列成员
printf ("%dn",p->No); 输出出列成员序号
m=p->password; 修改m
DeleteNode(&p); 删除连结串列中的出列成员
n--; 成员数自减
}
printf ("%dn",p->No); 输出最后一个成员序号
return OK;
}
status CreateList_Circle(member **p_head,int n)
{
此演算法建立一个无头结点的回圈连结串列，结点数n,*p_head返回连结串列头指标即首结点地址
int i;
member *tail,*p;
*p_head=(member *)malloc(sizeof(member));
if (!(*p_head)) return OVERFLOW;
(*p_head)->No=1; 储存成员一序号
printf ("Please enter password of No. 1:n");
scanf ("%d",&(*p_head)->password); 储存成员一密码
tail=*p_head;
tail->next=NULL;
for (i=2;i<n+1;i++)
{
p=(member *)malloc(sizeof(member));
if (!p) return OVERFLOW;
p->No=i; 储存成员序号
printf ("Please enter password of No. %d:n",i);
scanf("%d",&(p->password)); 储存成员密码
tail->next=p;
tail=p;
}
tail->next=*p_head;
return OK;
}
status DeleteNode(member **pp)
{
此演算法删除连结串列中的结点*pp,操作实质是将*pp下一结点复制到*pp后将其free
member *temp;
(*pp)->password=((*pp)->next)->password;
(*pp)->No=((*pp)->next)->No;
temp=(*pp)->next;
(*pp)->next=(*pp)->next->next;
free(temp);
return OK;
}

在回圈连结串列中,头指标和连结串列指标的动态变化决定连结串列的长度吗

。。。一般来说连结串列的长度是由内容来定的，指标决定读写的内容范围

删除无头结点单回圈连结串列中值为x的元素？主要是不会引用无头节点连结串列。

#include #include typedef struct _DLNode { struct _DLNode *next; int value; } DLNode; /* * 1. 如果链有没有节点，就返回NULL * 2. 如果连结串列只有一个节点，输入节点的前驱节点就是它本身，则返回输入节点 * 3. 如果连结串列有多于一个节点，就返回输入节点的前驱节点 */ DLNode* getPriorNode(DLNode *node) { DLNode *next; if (!node) { return NULL; } next = node->next; while (node != next->next) { next = next->next; } return next; } void delPriorNode(DLNode *node) { DLNode *prior = getPriorNode(node); if (prior) { getPriorNode(prior)->next = prior->next; } } void printList(DLNode *node) { DLNode *next; if (!node) { return; } printf("%d", node->value); next = node->next; while (node != next) { printf("-->%d", next->value); next = next->next; } printf("n"); } void main() { DLNode n1, n2, n3, n4, n5, n6; n1.value = 1; n2.value = 2; n3.value = 3; n4.value = 4; n5.value = 5; n6.value = 6; n1.next = &n2; n2.next = &n3; n3.next = &n4; n4.next = &n5; n5.next = &n6; n6.next = &n1; printf("Original list: "); printList(&n1); delPriorNode(&n3); printf("Deleted node 3's prior node(node 2): "); printList(&n1); }

在带表头的双回圈连结串列中,只给尾指标为rear.试编写演算法:求连结串列中资料为最小值的结点指标p

p = rear;
q = rear;
while (q->prior != rear)
{
if (q->data < p->data)
p = q;
q = q->prior;
}

已知list是指向无头结点的单链表的指标变数，写出删除该连结串列下标为i的（第i+1）结点的演算法

int j=0;
p=list;
while(j<i)
{
q=p;
p=p->next;
}
q->next=p->next;

求C++程式码实现无头结点的单向回圈连结串列类!

struct SNode {
int content;
SNode * next;
};
class Node {
private:
SNode *head = NULL;
public:
SNode * input (int c) {
SNode * p = new SNode;
p -> content = c;
if (head == NULL) {
head = p;
p ->next = p;
}
p -> next = head ->next;
head -> next = p;
return head;
}
};
sorry啊手懒，所以只写了个插入节点的函式==好久木有用C++了，可能写的不大好

试编写演算法求单回圈连结串列的表长

int length(slist L)
{
int *p,*q,i=0;
p=slist->first;
q=p->next;
for(;q!=p;i++)
q=q->next;
return i+1;
}

试编写一个演算法,计算带头结点的回圈单链表的长度

int length(struct list * head)
{
int i = 0;
struct list *tmp;
if( head == NULL)
return 0;
if( head -> next == head)
return 1;
tmp = head->next;
while(tmp != head)
{
i++;
tmp = tmp -> next;
}
return i;
}