数据结构实验报告--单链表

2016级数据结构实验报告

实验名称：实验一线性表——题目1

学生姓名：李文超

班级： 2015661131

班内序号： 15

学号： 2015522147

日期： 2016年11月13日

1.实验要求

实验目的：

根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。

线性表存储结构（五选一）：

1、带头结点的单链表

2、不带头结点的单链表

3、循环链表

4、双链表

5、静态链表

线性表的基本功能：

1、构造：使用头插法、尾插法两种方法

2、插入：要求建立的链表按照关键字从小到大有序

3、删除

4、查找

5、获取链表长度

6、销毁

7、其他：可自行定义

编写测试main()函数测试线性表的正确性。

2.程序分析

2.1 存储结构

单链表的存储：

（1）链表用一组任意的存储单元来存放线性表的结点。这组存储单元既可以是连续的，也可以是不连续的，甚至零散地分布在内存的某些位置。

（2）链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个元素值的同时，还要存储该元素的直接后继元素的位置信息，这个信息称为指针或链。

结点结构

┌──┬──┐data域---存放结点值的数据域

│data│next│next域---存放结点的直接后继的地址的指针域

└──┴──┘

单链表在内存中的存储示意

地址内存单元

1000H

头指针 1020H

1080H

10C0H

2.2 关键算法分析

1、关键算法：

（1）头插法

自然语言描述：

a:在堆中建立新结点

b:将a[i]写入到新结点的数据域

c:修改新结点的指针域

d:修改头结点的指针域。将新结点加入链表中

伪代码描述

a:Node * s=new Node

b:s->data=a[i]

c:s->next=front->next;

d:front->next=s

（2）尾插法

自然语言描述：

a:在堆中建立新结点：

b:将a[i]写入到新结点的数据域：

c:将新结点加入到链表中

d:修改修改尾指针

伪代码描述

a:Node * s=new Node

b:s->data=a[i]

c:r->next=s;

d:r=s

（3）遍历打印函数

自然语言描述：

a:判断该链表是否为空链表，如果是，报错

b:如果不是空链表，新建立一个temp指针

c:将temp指针指向头结点

d:打印temp指针的data域

e:逐个往后移动temp指针，直到temp指针的指向的指针的next域为空

伪代码描述

a: If front->next==NULL

①Throw ”an empty list ”

②Node* temp=front->next;

b:while(temp->next)

c:cout<data<<"";

d:temp=temp->next;

(4) 获取链表长度函数

自然语言描述：

a:判断该链表是否为空链表，如果是，输出长度0

b:如果不是空链表，新建立一个temp指针，初始化整形数n为0

c:将temp指针指向头结点

d:判断temp指针指向的结点的next域是否为空，如果不是，n加一，否则return n e: 使temp指针逐个后移，重复d操作，直到temp指针指向的结点的next域为0，返回n 伪代码描述

a:if ront->next==NULL

b:Node* temp=front->next;

c:while(temp->next)

d:temp=temp->next;

（5）析构/删除函数

自然语言描述：

a:新建立一个指针，指向头结点

b:判断要释放的结点是否存在，

c:暂时保存要释放的结点

d:移动a中建立的指针

e:释放要释放的指针

伪代码描述

a:Node * p=front

b:while(p)

c:front=p

d:p=p->next

e:delete front

（6）按位查找函数

自然语言描述：

a:初始化工作指针p和计数器j，p指向第一个结点，j=1

b:循环以下操作，直到p为空或者j等于1

①：p指向下一个结点

②：j加1

c:若p为空，说明第i个元素不存在，抛出异常

d:否则，说明p指向的元素就是所查找的元素，返回元素地址

伪代码描述

a:Node * p=front->next;j=1;

b:while(p&&j!=1)

①:p=p->next

②:j++

c:if(!p) throw ”error”

d:return p

（7）按位查找函数

自然语言描述：

a:初始化工作指针p和计数器j，p指向第一个结点，j=1

b:循环以下操作，找到这个元素或者p指向最后一个结点

①：判断p指向的结点是不是要查找的值，如果是，返回j，否则p指向下一个结点，

并且j的值加一

c:如果找到最后一个结点还没有找到要查找的元素，返回查找失败信息

伪代码描述

a:Node * p=front->next;j=1;

b:while(p)

①: if(p->next==x) return j

p=p->next

j++

c:return “error”

（8）插入函数

自然语言描述：

a:在堆中建立新结点

b:将要插入的结点的数据写入到新结点的数据域

c:修改新结点的指针域

d:修改前一个指针的指针域，使其指向新插入的结点的位置

伪代码描述

a:Node * s=new Node ;

b:s-data=p->data

c:s->next=p->next

d:p->next=s

e:p->data=x

（9）删除函数

自然语言描述：

a:从第一个结点开始，查找要删除的位数i 前一个位置i-1的结点 b:设q 指向第i 个元素

c:将q 元素从链表中删除

d:保存q 元素的数据

e:释放q 元素

伪代码描述

a:q=p->next

b:p->next=q->next

c:x=q->data

d:delete q

2、代码详细分析（插入）：

（1）从第一个结点开始，查找节点，使它的数据比x 大，设p 指向该结点：

while (x>p->data) { p=p->next;}

（2）新建一个节点s ，把p 的数据赋给s ： s->data=p->data;

（3）把s 加到p 后面：s->next=p->next; p->next=s;

（4）p 节点的数据用x 替换：p->data=x;

示意图如图所示

3、关键算法的时间复杂度：O （

1)

3. 程序运行结果

1. 流程图：

2、结果截图

3.测试结论：可以正确的对链表进行插入，删除，取长度，输出操作。且插入任意一个元素后，链表的顺序依然是由小到大。

4、给出代码（文末）

4.总结

1、问题

①书中已经给出析构、查找、插入、删除过程代码，遍历以及获取长度代码需要自己写出，刚开始写时一直出现各种基本错误，后来经过不断调试解决了问题。

②编写main函数时，调用插入删除等操作的代码一直编写失败，后自行查找资料后解决

2、收获

这次编程任务完成地较为艰辛，但做完之后大大加深了自己对书中各个知识点的印象和理解。也学会了一些编写算法的小技巧，要有耐心，多看书复习知识。总之，这次实验使我印象深刻。

#include

usingnamespace std;

template

struct Node

{

T data;

struct Node * next;

};

template

class LinkList

{

public:

LinkList() //无参构造

{

front = new Node;

front->next = NULL;

}

LinkList(T a[], int n);//头插法

//LinkList(T a[],int n);//尾插法

void PrintList();//按次序遍历

int GetLength();//获取线性表的长度

Node * Get(int i);//获取第i个位置上的元素结点的地址int Locate(T x);//查找

void Insert(int i, T x);//插入

T Delete(int i);//删除

~LinkList();//销毁

private:

Node * front;

};

template

LinkList::LinkList(T a[], int n)//头插法

{

front = new Node;

front->next = NULL;

for(int i = n - 1; i >= 0; i--)

{

Node * s = new Node;//建立新结点

s->data = a[i];//给新结点数据域赋值

s->next = front->next;//修改新结点的指针域

front->next = s;//修改头指针的指针域

}

}/*

template

LinkList::LinkList(T a[],int n )//尾插法

{

front=new Node;

Node * r = front;

for(int i=0;i

{

Node * s = new Node;

s->data=a[i];

r->next=s;

r=s;

}

r->next=NULL;

}*/

template

void LinkList::PrintList()

{

Node * p = front;

while(p->next != NULL){

p = p->next;

cout << p->data << endl;

}

}

template

int LinkList::GetLength()

{

Node * p = front;

int n = 0;

while(p->next != NULL) { p = p->next; n++; }

return n;

}

template

Node * LinkList::Get(int i)

{

Node * p = front->next;

int j = 1;

while(p&&j != i)

{

p = p->next;

j++;

}

return p;

}

template

void LinkList::Insert(int i, T x)

{

Node * p = front;

if(i != 1)

p = Get(i - 1);

if(p)

{

Node * s = new Node;

s->data = x;

s->next = p->next;

p->next = s;

}

elsethrow"位置错误";

}

template

T LinkList::Delete(int i)

{

Node * p = front;

if(i != 1) p = Get(i - 1);

if(!p && !p->next) throw"位置错误";

Node * q = p->next;

p ->next = q ->next;

T x = q ->data;

delete q;

return x;

}

template

LinkList::~LinkList()

{

Node * p = front;

while(p)

{

p = p->next;

delete front;

front = p;

}

}

int main()

{

constint n = 8;

int a[n] = { 1, 2, 3, 4, 5, 6, 7, 8 };

LinkList list(a, n);

cout<<"线性表的长度为："<< list.GetLength() << endl;

cout << endl;

cout<<"遍历线性表结果为："<

list.PrintList();

cout << endl;

cout<<"插入一个值后的线性表为："<

list.Insert(1, 0);

list.PrintList();

cout<

cout<<"删除一个值后的线性表为："<

list.Delete(1);

list.PrintList();

cout<

cout<<"第个位置上的元素地址是："<

cout << list.Get(2) << endl;

cout<

list.~LinkList();

system("pause");

return 0;

}