第六节-双链表

双链表

结构特点：
template
struct DNode{
T data;
DNode *llink;
DNode *rlink;
};
**设指针p指向双链表中某一结点，则有下式成立： 
p->llink->rlink = p = p->rlink->llink **

建立空双链表：
first->rlink=NULL
first->llink=NULL
Last=first

插入操作：

q->rlink=p->rlink;
q->llink=p;
p->rlink=q;
q->rlink->llink=q;

处理原则：先处理每个方向的 远端指针，再处理近端指针，否则会把原后继节点弄丢
双向删除：

p->llink->rlink=p->rlink;
p->rlink->llink=p->rlink;
delete§;
建造空的双链表：
template
DoubleLink ::DoubleLink(){
head=new Node;
head->rlink=NULL;
head->llink=NULL;
}
头插法：
template
void DoubleLink::Append(T data){
Node *s;
s=new Node;
s->data=data;
s->rlink=head->rlink;
head->rlink=s;
s->llink=head;
if (s->rlink)
s->rlink->llink=s;
return;
}
双链表的遍历：
template
void DoubleLink::Display(){
Node *p;
p=head->rlink;
while§ {
cout<data<<" ";
p=p->rlink;
}
cout<<endl;
return;
}
双链表的析构：
template
DoubleLink::~DoubleLink(){
Node *p,*q;
p=head;
while§
{
q=p->rlink;
delete p;
p=q;

}

静态链表的优缺点：
优点：
插入和删除时不需要移动元素，直接修改指针即可，因此效率较高
缺点：
静态链表是借助于数组实现的，因此，不能动态的修改数组的大小，存在着跟静态数组一样不能按需进行存储空间的分配

约瑟夫环的问题：
顺序表：
创建一个长度为n的顺序表
从第index（初值0）个元素出发，依次计数，每数到d，就将该元素删除
index=(index+d-1)%顺序表的长度
重复上述工作，直到顺序表中只剩一个元素
循环链表：
#include
using namespace std;
struct Node
{ int data; Node *pNext;};

int main(){
int n, k, m, i;//从k开始报数，数到m出列
struct Node *p, *q, head;
cin >> n>>k>>m;
if(m1) { int left; left=k-1; if(left0) left=n; cout<<left; return 0; }
first = (Node)new Node;
p = first;first->data=1;
for (i = 2; i <= n; i++) {
q=new Node; q->data=i;p->next =q;p=p->pNext;
}
p->pNext = first;
p = first;
for(i=1;i<=k-1;i++) //寻找报数的起点
p=p->pNext;

while (p != p->pNext) //只剩下一个结点的
{
for (i = 1; i<m - 1; i++)
{
p = p->pNext;
}
q = p->pNext; //q为要出队的元素
p->pNext=q->pNext;
delete q;
p=p->pNext;
}
cout << p->data <<endl;
return 0;

}