1. 循环单链表解决约瑟夫问题算法
用一组地址任意的存储单元存放线性表中的数据元素。 以元素(数据元素的映象) + 指针(指示后继元素存储位置) = 结点 (表示数据元素 或 数据元素的映象) 以“结点的序列”表示线性表 称作线性链表（单链表） 单链表是一种顺序存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。 因此，查找第 i 个数据元素的基本操作为：移动指针，比较 j 和 i 单链表 1、链接存储方法 链接方式存储的线性表简称为链表（Linked List）。 链表的具体存储表示为： ① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的） ② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)） 注意： 链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。 2、链表的结点结构 ┌──┬──┐ │data│next│ └──┴──┘ data域--存放结点值的数据域 next域--存放结点的直接后继的地址（位置）的指针域（链域） 注意： ①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 ②每个结点只有一个链域的链表称为单链表（Single Linked List）。 【例】线性表（bat，cat，eat，fat，hat，jat，lat，mat）的单链表示如示意图 3、头指针head和终端结点指针域的表示 单链表中每个结点的存储地址是存放在其前趋结点next域中，而开始结点无前趋，故应设头指针head指向开始结点。 注意： 链表由头指针唯一确定，单链表可以用头指针的名字来命名。 【例】头指针名是head的链表可称为表head。 终端结点无后继，故终端结点的指针域为空，即NULL。 4、单链表的一般图示法 由于我们常常只注重结点间的逻辑顺序，不关心每个结点的实际位置，可以用箭头来表示链域中的指针，线性表（bat，cat，fat，hat，jat，lat，mat）的单链表就可以表示为下图形式。 5、单链表类型描述 typedef char DataType; //假设结点的数据域类型为字符 typedef struct node{ //结点类型定义 DataType data; //结点的数据域 struct node *next;//结点的指针域 }ListNode typedef ListNode *LinkList; ListNode *p; LinkList head; 注意： ①*LinkList和ListNode是不同名字的同一个指针类型（命名的不同是为了概念上更明确） ②*LinkList类型的指针变量head表示它是单链表的头指针 ③ListNode类型的指针变量p表示它是指向某一结点的指针 6、指针变量和结点变量 ┌────┬────────────┬─────────────┐ ││ 指针变量 │ 结点变量 │ ├────┼────────────┼─────────────┤ │ 定义 │在变量说明部分显式定义 │在程序执行时，通过标准 │ ││ │函数malloc生成 │ ├────┼────────────┼─────────────┤ │ 取值 │ 非空时，存放某类型结点 │实际存放结点各域内容 │ │ │的地址 ││ ├────┼────────────┼─────────────┤ │操作方式│ 通过指针变量名访问 │ 通过指针生成、访问和释放 │ └────┴────────────┴─────────────┘ ①生成结点变量的标准函数 p=( ListNode *)malloc(sizeof(ListNode))； //函数malloc分配一个类型为ListNode的结点变量的空间,并将其首地址放入指针变量p中 ②释放结点变量空间的标准函数 free(p)；//释放p所指的结点变量空间 ③结点分量的访问 利用结点变量的名字*p访问结点分量 方法一：(*p).data和(*p).next 方法二：p-﹥data和p-﹥next ④指针变量p和结点变量*p的关系 指针变量p的值——结点地址 结点变量*p的值——结点内容 (*p).data的值——p指针所指结点的data域的值 (*p).next的值——*p后继结点的地址 *((*p).next)——*p后继结点 注意： ① 若指针变量p的值为空（NULL），则它不指向任何结点。此时，若通过*p来访问结点就意味着访问一个不存在的变量，从而引起程序的错误。 ② 有关指针类型的意义和说明方式的详细解释 可见，在链表中插入结点只需要修改指针。但同时，若要在第 i 个结点之前插入元素，修改的是第 i-1 个结点的指针。 因此，在单链表中第 i 个结点之前进行插入的基本操作为: 找到线性表中第i-1个结点，然后修改其指向后继的指针。
2. 顺序表，单链表，双链表，单循环链表，循环双链表各自有什么特点和区别紧急....求大神，最好详细一点
访问方式： 单链表：如果访问任意结点每次只能从头开始顺序向后访问 单循环链表：可以从任何一个结点开始，顺序向后访问到达任意结点 双向链表：可以从任何结点开始任意向前向后双向访问操作：单链表和单循环链表：只能在当前结点后插入和删除双链表：可以在当前结点前面或者后面插入，可以删除前趋和后继（包括结点自己）存储：单链表和单循环链表存储密度大于双链表
3. 数据结构单循环链表
题中没有一个答案是正确的。应该是：
s=rear->link;
rear->link=s->link;
delete s;
4. 单向循环链表
算法f 30的功能是，删除并返回链表中指针s所指结点的前驱
你的程序并不是实现上面的功能，
而是实现删除并返回链表中指针s所指结点
typedef struct node //链表结点结构体
{
DataType data； //链表结点成员：数值
struct node *next； //链表结点成员：后续结点指针
}*LinkList；
DataType f 30(LinkList s) //将循环链表的s结点指针作为参数传递进来
{
LinkList pre，p； //声明两个结构体变量
DataType e；
pre=s； //pre指向s结点
p=s->next； //p指向s结点的下一结点(也就是p指向pre的后继)
while( p!=s) //当p不指向s指向的结点，这个是用于判断循环链表从s结点开始遍历，遍历是否完毕的
{
pre=p; //pre指向它的后续结点，也就是现在的p
p=p->next; //p指向p的后续，这样始终保证，pre指向p的前驱
}
//当上述循环执行完毕后，p指向s，pre指向s的前驱
pre ->next=p->next; //此时pre指向s的前驱，p指向s，所以这一句就将s的前驱的next指向了s的next，将s结点从链表中取出
e=p->data;
free(p); //删除p指向的结点，也就是s结点
return e;
}
5. 线性表在最后一元素后插一元素和删第一元素，仅有头指针和仅有尾指针的单循环链表哪个存储方式运算时间少
既然是单链表， 删除 只有尾指针就够了。。
插入就要遍历到前一个指针， 然后就插入呗。。。
都是O1
6. 编写程序,建立一个带有节点的单向链表，输入字符串，并按从小到大顺序组织到链表中
int main()
{
Link head; //链表(不带头节点)
int n;
printf("输入链表的长度n: ");
scanf("%d",&n);
printf("连续输入%d个数据(以空格隔开): ",n);
head=CreateLink(n);
printf(" 原本链表的节点是: ");
DispLink(head);
LinkSort(head);
printf(" 从大到小排序之后: ");
DispLink(head);
printf("
");
return 0;
}
链表的具体存储表示为：
① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）
② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）
链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。
以上内容参考：网络-单链表
7. 用带头指针的单循环链表实现队列和用带尾指针的单循环链表实现队列,哪种方法更好
尾指针。
头指针的话，虽然出队列只要一步操作，但入队列操作需要先遍历到尾部，再插入新结点，复杂度是O（n)。
尾指针的话，入队列只要直接在尾部插入新结点即可，出队列也只要把尾结点的next指向下一个结点即可。两种操作都是O(1)复杂度。
8. C++ 单向循环链表
我实在不知道你们这个题目是什么意思，竟然继承链表来实现队列，帮你实现了，VC6.0通过
//list.h
#ifndef LIST_H
#define LIST_H
#include<iostream>
using namespace std;
struct Node
{
int data;
Node *next;
};
class List
{
public:
List();
~List();
List(List&rhs);
List &operator=(List&);
int operator >>(int x);//让>>从尾部输入x
int operator <<(int x);//让<<删除x
virtual void push(int x);
void push(int x,int idx);
void deletex (int x);
virtual void pop();
virtual int top();
bool empty();
int get_num()
{
return m_nNum;
}
Node *get_head()
{
return m_pHead;
}
protected:
int m_nNum;
Node *m_pHead;
};
List::List()
{
m_nNum=0;
m_pHead=new Node;
m_pHead->data=NULL;
m_pHead->next=NULL;
}
List::List(List&rhs)
{
if(this->get_num!=rhs.get_num)
{
cout<<"链变大小不同，不能复制"<<endl;
}
else
{
Node*tmp1=m_pHead->next ;
Node*tmp2=rhs.m_pHead->next;
while(tmp1!=m_pHead)
{
tmp1->data=tmp2->data;
tmp1=tmp1->next;
tmp2=tmp2->next;
}
}
}
List&List::operator=(List&rhs)
{
if(this->get_num()!=rhs.get_num())
{
cout<<"链变大小不同，不能复制"<<endl;
}
else
{
Node*tmp1=m_pHead->next ;
Node*tmp2=rhs.m_pHead->next;
while(tmp1!=m_pHead)
{
tmp1->data=tmp2->data;
tmp1=tmp1->next;
tmp2=tmp2->next;
}
}
return *this;
}
List::~List()//释放所有的内存
{
Node *i=m_pHead->next;
while(i!=m_pHead)
{
Node *j=i->next;
delete i;
i=j;
}
delete m_pHead;
}
void List::pop()
{
if(empty())
{
cout<<"链表为空"<<endl;
return ;
}
else
{
Node*tmp=m_pHead->next->next ;
delete m_pHead->next ;
m_pHead->next=tmp;
--m_nNum;
return;
}
}
void List::push(const int x,const int idx)//在idx位置后插入x
{
if(m_nNum==0)
{
Node *idx_node=new Node;
m_pHead->next=idx_node;
idx_node->data=x;
idx_node->next=m_pHead;
}
else
{
Node *tmp=m_pHead;
for(int i=0;i<idx;++i)
{
tmp=tmp->next;
}
Node *tmpnext=tmp->next;
Node *idx_node=new Node;
tmp->next=idx_node;
idx_node->data=x;
idx_node->next=tmpnext;
}
++m_nNum;
}
void List::push(const int x)
{
push(x,m_nNum);
}
void List::deletex (int x)//删除值为x的所有点
{
Node *tmp=m_pHead;
int idx=0;
while(idx<m_nNum)
{
Node *preNode=tmp;
tmp=tmp->next;
if(tmp->data==x)
{
Node*tmpNext=tmp->next;
tmp->next=tmpNext;
delete tmp;
tmp=tmpNext;
++idx;
}
tmp=tmp->next;
++idx;
}
}
inline int List::top ()
{
if(empty())
{
cout<<"空链表"<<endl;
return false;
}
return m_pHead->next->data ;
}
inline bool List::empty()
{
return m_nNum==0;
}
int List::operator <<(int x)
{
deletex(x);
return 0;
}
int List::operator >>(int x)
{
push(x);
return 0;
}
#endif
////deque.h
#ifndef QUEUE_H
#define QUEUE_H
#include "list.h"
class Queue:public List
{
public:
Queue(){}
Queue(Queue&);
virtual void pop();
virtual void push(int x);
virtual int top();
};
Queue::Queue(Queue&rhs)
{
if(this->get_num!=rhs.get_num)
{
cout<<"队列大小不同，不能复制"<<endl;
}
else
{
Node*tmp1=m_pHead->next ;
Node*tmp2=rhs.m_pHead->next;
while(tmp1!=m_pHead)
{
tmp1->data=tmp2->data;
tmp1=tmp1->next;
tmp2=tmp2->next;
}
}
}
void Queue::pop()
{
if(empty())
{
cout<<"队列为空"<<endl;
return ;
}
else
{
Node*tmp=m_pHead->next->next ;
delete m_pHead->next ;
m_pHead->next=tmp;
return;
--m_nNum;
}
}
int Queue::top()
{
if(empty())
{
cout<<"队列为空"<<endl;
return false;
}
return m_pHead->next->data ;
}
void Queue::push(int x)
{
Node *new_node=new Node;
Node *tmp=m_pHead;
for(int i=0;i<m_nNum;++i)
{
tmp=tmp->next;
}
tmp->next=new_node;
new_node->next =m_pHead;
new_node->data =x;
++m_nNum;
}
#endif
///main.cpp
/*--------------------------
这个主函数用于测试list
#include"list.h"
#include<iostream>
using namespace std;
int main()
{
List xx;
if(xx.empty())
cout<<"空"<<endl;
for(int i=0;i<3;++i)
xx.push(i);
cout<<xx.top()<<endl;
xx.pop();
cout<<xx.top()<<endl;
return 0;
}
-----------------------------------*/
#include "queue.h"
#include<iostream>
using namespace std;
int main()
{
List *xx=new Queue;//检验多态
xx->pop();
for(int i=0;i<3;++i)
xx->push(i);
cout<<xx->top()<<endl;
xx->pop();
cout<<xx->top()<<endl;
return 0;
}