大二数据结构第三次总结

                      第二章 线性表

1.顺序表代码实现：
const int Maxsize=100;
template
class SeqList{
　private:
　　T data[MaxSize]; // 存放数据元素的数组
　　int length; // 线性表的长度
　public:
　　SeqList ( ) ;// 无参构造函数
　　SeqList ( T a[ ], int n ) ; // 有参构造函数
　　~SeqList( ) { } // 析构函数为空
　　int Length ( ) {return length;} // 求线性表的长度
　　　　T Get ( int i ); // 按位查找，取线性表的第 i 个元素
　　int Locate ( T x ) ; // 按值查找，求线性表中值为 x 的元素序号
　　void Insert ( int i, T x ) ; // 在线性表中第 i 个位置插入值为 x 的元素
　　T Delete ( int i ) ; // 删除线性表的第 i 个元素
　　void PrintList ( ) ; // 遍历线性表，按序号依次输出各元素
};　
2.构造函数：
定义了两个构造函数：
无参构造函数（构造一个空的顺序表）
SeqList ( ) {length=0;}
构造一个非空的顺序表
SeqList ( T a[ ], int n ) ; // 有参构造函数
有参构造函数代码：
template
SeqList:: SeqList(T a[], int n)
{
if (n>MaxSize) throw “参数非法”;
for (int i=0; i<n; i++)
data[i]=a[i];
length=n;
}
3.顺序表的插入算法
①如果顺序表已满，抛出上溢异常
② 如果元素插入位置不存在，抛出位置异常
③ 将最后一个元素至第i个元素（i为插入位置）向后移动一个位置
④将元素插入到i位置
⑤ 将顺序表的长度增1
算法代码：
template
void SeqList::Insert(int i, T x){
int j;
if (length>=MaxSize) throw “上溢”;
if (i<1 || i>length+1) throw “位置”;
for (j=length; j>=i; j–)
data[j]=data[j-1];
data[i-1]=x;
length++;
}
4.顺序表的删除算法：
①如果顺序表已空，抛出下溢异常
② 如果元素删除位置不存在，抛出位置异常
③ 取出被删除的元素
④ 将下标为i，i+1…n-1的元素一次移到i-1,i,…n-2的位置
⑤将顺序表的长度减1，返回被删除的元素
删除代码：
template
T SeqList::Delete(int i){
int j;
T x;
if (length==0) throw “下溢”;
if (i<1 || i>length) throw “位置”;
x=data[i-1];
for (j=i; j<length; j++)
data[j-1]=data[j];
length–;
return x;
}
5.查找算法：
两种查找方法：
①按位置查找，即查找指定位置上的元素
② 按值查找，即查找指定的值在顺序表中的位置两种查找方法
代码：
①按位置查找：
template
T SeqList::Get(int i)
{
if (i<1 && i>length) throw “查找位置非法”;
else return data[i-1];
}
②按值查找：
template
int SeqList::Locate(T x){
for (int i=0; i<length; i++)
if (data[i]==x)
return i+1 ; //下标为i的元素等于x，返回其序号i+1
return 0; //退出循环，说明查找失败
}
6.链表结点数据类型的定义：
template
struct Node
{
　　T data;
　　Node *next; //此处也可以省略
};
7.单链表的实现：
template
class LinkList {
　　public:
　　LinkList ( ) {first=new Node; first -> next= NULL ;}
　 LinkList ( T a[ ], int n ) ;
　　~LinkList ( ) ;
　　int Length ( ) ;
　　T Get ( int i ) ;
　　int Locate ( T x ) ;
　　void Insert ( int i, T x ) ;
　　T Delete ( int i ) ;
　　void PrintList ( ) ;
　　private:
　　 Node *first; // 单链表的头指针 , 可以省略
};
8.单链表带表头头插法

template
LinkList:: LinkList(T a[ ], int n) {
first=new Node; //生成头结点
first->next=NULL;
Node *s;
for (int i=0; i<n; i++){
s=new Node;
s->data=a[i]; //为每个数组元素建立一个结点
s->next=first->next;
first->next=s;
}
}
9.单链表带表头尾插法：
template
LinkList:: LinkList(T a[ ], int n) {
Node *r,*s; //尾指针
first=new Node; //生成头结点
r=first;
for (int i=0; i<n; i++) {
s=new Node;
s->data=a[i]; //为每个数组元素建立一个结点
r->next=s; r=s; //插入到终端结点之后
}
r->next=NULL; //单链表建立完毕，将终端结点的指针域置空
}
10.单链表的遍历：
template
LinkList:: PrintList()
{
Node *p;
p=first->next;
while§
{
cout<data;
p=p->next;
}
}
11.单链表不带头结点的头插法：

头插法：
{
first=NULL;
for(int i=0;i<n;i++) {
s=new node;
s->data=a[i];
s->next=first;
first=s;
}
}
12.单链表不带头结点的尾插法
尾插法：
node *r;
head=NULL;
if（n<=0）return;
s=new node;
s->data=a[0];
s->next=head;
head=s;
r=head;
for(int i=1;i<n;i++) {
s=new node;
s->data=a[i];
r->next=s;
r=s;
}
13.单链表按位置查找：
template
T LinkList::Get(int i) {
Node *p; int j;
p=first->next; j=1; //或p=first; j=0;
while (p && j<i) {
p=p->next; //工作指针p后移
j++;
}
if (!p) throw “位置”;
else return p->data;
}
14.单链表插入算法描述
①工作指针p初始化，计数器初始化
②查找第i-1个节点，并使工作指针p指向该节点
③若查找不成功（P==NULL），说明位置错误，抛出位置异常，否则
③.1 生成一个元素值为x的新节点s
③.2 将s插入到p之1 工作指针p初始化，计数器初始化
代码：

template
void LinkList::Insert(int i, T x){
Node *p; int j;
p=first ; j=0; //工作指针p初始化
while (p && j<i-1) {
p=p->next; //工作指针p后移
j++;
}
if (!p) throw “位置”;
else {
Node *s;
s=new Node;
s->data=x; //向内存申请一个结点s，其数据域为x
s->next=p->next; //将结点s插入到结点p之后
p->next=s;
}
}
15.不带头结点的单链表中插入结点
Insert(int i, T x){
Node *p; int j;
if（i<=0） throw “位置非法”；
if （i==1 ）{ s=new Node;s->next=head;head=s;return}
p=first ; j=1; //工作指针p初始化
while (p && j<i-1) {
p=p->next; //工作指针p后移
j++;
}
if (!p) throw “位置”;
else {
Node *s;
s=new Node;
s->data=x; //向内存申请一个结点s，其数据域为x
s->next=p->next; //将结点s插入到结点p之后
p->next=s;
}
}
16.单链表中结点的删除

template
T LinkList::Delete(int i){
Node *p; int j;
p=first ; j=0; //工作指针p初始化
while (p && j<i-1) { //查找第i-1个结点
p=p->next;
j++;
}
if (!p || !p->next) throw “位置”; //结点p不存在或结点p的后继结点不存在
else {
Node *q; T x;
q=p->next; x=q->data; //暂存被删结点
p->next=q->next; //摘链
delete q;
return x;
}
}
17.析构函数
template
LinkList:: ~LinkList()
{
Node *q;
while (first)
{
q=first->next;
delete first;
first=q;
}
}
18.循环链表
template
struct Node
{
T data;
Node *next;
};
template
class CycleLinkList{
public:
CycleLinkList( );
CycleLinkList(T a[ ], int n);
CycleLinkList(T a[ ], int n,int i);
~CycleLinkList();
int Length();
T Get(int i);
void Insert(int i, T x);
T Delete(int i);
void PrintList( );
private:
Node *first;
};
19.循环链表空表的构造
template
CycleLinkList:: CycleLinkList( )
{
first=new Node; first->next=first;
}
20.尾插法构造循环链表
template
CycleLinkList:: CycleLinkList(T a[ ], int n) {
first=new Node; //生成头结点
Node *r,*s;
r=first; //尾指针初始化
for (int i=0; i<n; i++) {
s=new Node;
s->data=a[i];
r->next=s;
r=s;
}
r->next=first; //单链表建立完毕，将终端结点的指针域指向头结点
}
21.头插法构造循环链表
template
CycleLinkList:: CycleLinkList(T a[ ], int n,int k)
{
first=new Node; //生成头结点
first->next=first;
Node *s;
for (int i=1; i<n; i++)
{
s=new Node;
s->data=a[i]; //为每个数组元素建立一个结点
s->next=first->next;
first->next=s;
}
}
25.双链表的实现
template
class DoubleLink {
private:
Node *head;
public:
DoubleLink() ；
~DoubleLink();
void Append(T data);
void Display();
void Insert(int locate , T data);
T Get(int locate);
T Delete(int locate);
};
26.双链表空表的构造
template
DoubleLink ::DoubleLink(){
head=new Node;
head->rlink=NULL;
head->llink=NULL;
}
27.双链表头插
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;
}
28.双链表遍历
template
void DoubleLink::Display(){
Node *p;
p=head->rlink;
while§ {
cout<data<<" ";
p=p->rlink;
}
cout<<endl;
return;
}
29.双链表析构
template
DoubleLink::~DoubleLink(){
Node *p,*q;
p=head;
while§
{
q=p->rlink;
delete p;
p=q;

}

}