数据结构实验报告(合工大)

数据结构实验报告

实验一:栈和队列

实验目的：

掌握栈和队列特点、逻辑结构和存储结构

熟悉对栈和队列的一些基本操作和具体的函数定义。

利用栈和队列的基本操作完成一定功能的程序。

实验任务

1.给出顺序栈的类定义和函数实现，利用栈的基本操作完成十进制数N与其它d进制数的转换。（如N=1357,d=8）

实验原理:将十进制数N转换为八进制时，采用的是“除取余数法”，即每次用8除N所得的余数作为八进制数的当前个位，将相除所得的商的整数部分作为新的N值重复上述计算，直到N为0为止。此时，将前面所得到的各余数反过来连接便得到最后的转换结果。

程序清单

#include

#include

using namespace std;

typedef int DATA_TYPE;

const int MAXLEN=100;

enum error_code

{

success,overflow,underflow

};

class stack

{

public:

stack();

bool empty()const;

error_code get_top(DATA_TYPE &x)const;

error_code push(const DA TA_TYPE x);

error_code pop();

bool full()const;

private:

DA TA_TYPE data[MAXLEN];

int count;

};

stack::stack()

{

count=0;

}

bool stack::empty()const

{

return count==0;

}

error_code stack::get_top(DATA_TYPE &x)const

if(empty())

return underflow;

else

{

x=data[count-1];

return success;

}

}

error_code stack::push(const DA TA_TYPE x)

{

if(full())

return overflow;

else

{

data[count]=x;

count++;

}

}

error_code stack::pop()

{

if(empty())

return underflow;

else

{

count--;

return success;

}

}

bool stack::full()const

{

return count==MAXLEN;

}

void main()

{

stack S;

int N,d;

cout<<"请输入一个十进制数N和所需转换的进制d"<>N>>d;

if(N==0)

{

cout<<"输出转换结果:"<

}

while(N)

S.push(N%d);

N=N/d;

}

cout<<"输出转换结果:"<

while(!S.empty())

{

S.get_top(N);

cout<

S.pop();

}

cout<

}

while(!S.empty())

{

S.get_top(x);

cout<

S.pop();

}

}

测试数据：N=1348 d=8

运行结果：

2.给出顺序队列的类定义和函数实现，并利用队列计算并打印杨辉三角的前n行的内容。(n=8)

实验原理：杨辉三角的规律是每行的第一和最后一个数是1，从第三行开始的其余的数是上一行对应位置的左右两个数之和。因此，可用上一行的数来求出对应位置的下一行内容。为此，需要用队列来保存上一行的内容。每当由上一行的两个数求出下一行的一个数时，其中

的前一个便需要删除，而新求出的数就要入队。程序清单：

#include

#include

using namespace std;

typedef int DATA_TYPE;

const int MAXLEN=100;

enum error_code

{

success,underflow,overflow

};

class queue

{

public:

queue();

bool empty()const;

error_code get_front(DATA_TYPE &x)const;

error_code append(const DA TA_TYPE x);

error_code serve();

bool full()const;

private:

int front,rear;

DA TA_TYPE data[MAXLEN];

};

queue::queue()

{

rear=0;

front=0;

}

bool queue::empty()const

{

return (front%MAXLEN==rear%MAXLEN);

}

error_code queue::get_front(DA TA_TYPE &x)const {

if(empty())

return underflow;

else

{

x=data[front%MAXLEN];

return success;

}

}

error_code queue::append(const DA TA_TYPE x) {

if(full())

return overflow;

else

{

data[rear%MAXLEN]=x;

rear++;

}

}

error_code queue::serve()

{

if(empty())

return underflow;

else

{

front++;

return success;

}

}

bool queue::full()const

{

return((rear+1)%MAXLEN==front);

}

void main()

{

queue Q;

int num1,num2;

int i=0;

cout<<1<

Q.append(1);

num1=0;

num2=1;

for(i=0;i<=7;i++)

{

int j=0;

int k=0;

num1=0;

for(j=0;j<=i;j++)

{

Q.get_front(num2);

Q.serve();

cout<

Q.append(num1+num2);

num1=num2;

}

cout<<1<

Q.append(1);

}

}

运行结果：

3.给出链栈的类定义和函数实现，并设计程序完成如下功能：读入一个有限大小的整数n，并读入n个数，然后按照与输入次序相反的次序输出各元素的值。

实验原理：依次将栈中的元素出栈，因为栈的一个特点就是先进后出，。这样，当将原栈为空时，输出与输入次序相反，从而实现了本题的要求。

程序清单：

#include

#include

using namespace std;

typedef int DATA_TYPE;

typedef struct LNode

{

DA TA_TYPE data;

LNode *next;

}LNode;

enum error_code

{

range_error,success,underflow

class linkstack

{

public:

linkstack();

~linkstack();

bool empty()const;

error_code push(const DA TA_TYPE x);

error_code get_top(DATA_TYPE &x)const;

error_code pop();

private:

LNode *top;

int count;

DA TA_TYPE data;

};

linkstack::linkstack()

{

top=NULL;

count=0;

}

bool linkstack::empty()const

{

return (count==0);

}

error_code linkstack::push(const DATA_TYPE x) {

LNode *s=new LNode;

s->data=x;

s->next=top;

top=s;

count++;

return success;

}

error_code linkstack::get_top(DA TA_TYPE &x)const {

if(empty())

return underflow;

else

{

x=top->data;

return success;

}

}

error_code linkstack::pop()

if(empty())

return underflow;

else

{

LNode *u=new LNode;

u=top;

top=top->next;

delete u;

count--;

return success;

}

}

linkstack::~linkstack()

{

while(!empty())

{

pop();

}

}

void main()

{

linkstack L;

int n;

cout<<"请任意输入一个整数n:"<>n;

for(int i=1;i<=n;i++)

{

L.push(i);

}

while(!L.empty())

{

L.get_top(i);

cout<

L.pop();

}

}

测试数据：n=9 i=1

运行结果：

实验二:单链表

实验目的：

理解线性表的链式存储结构。

熟练掌握动态链表结构及有关算法的设计。

根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关算法。

实验任务：

在一个递增有序的链表L中插入一个值为x的元素，并保持其递增有序特性。

1.实验数据：链表元素为（10,20,30,40,50,60,70,80,90,100）,x分别为25，85，110和8。

实验原理:给出了要插入的条件，但没有给定插入位置。因此，需要搜索满足这一条件的插入位置的前驱结点而不是序号。

程序清单:

#include

#include

using namespace std;

typedef struct snode

{

int data;

struct snode *next;

}node;

enum error_code{arrange_error,success};

class list

{

public:

list();

void create2();

int length() const;

error_code get_element(const int i,int &x) const;

error_code insert(const int &x);

error_code delete_element(const int i);

node *locate(const int x) const;

node *get_head(){return head;}

void print();

private:

int count;

node *head;

};

list::list()

{

head=new node; head->next=NULL;

count=0;

}

void list::create2()

{

int x; node *p=head;

node *s; cout<<"输入一个值：";

cin>>x;

while(x!=-1)

{

s=new node; s->data=x;

s->next=NULL; p->next=s;

p=s; cout<<"输入一个值：";

cin>>x;

}

}

int list::length() const

{

return count;

}

error_code list::get_element(const int i,int &x) const {

int j=1; node *p=head->next;

while(p!=NULL&&j!=i)

{

p=p->next; j++;

}

if(p==NULL)

return arrange_error;

x=p->data;

return success;

node *list::locate(const int x) const

{

node *p=head->next;

while(p!=NULL)

{

if(p->data==x)

return p;

p=p->next;

}

return NULL;

}

error_code list::insert(const int &x)

{

node *s; node *q=head; node *p=head->next;

while(p!=NULL&&p->data

{

q=p; p=p->next;

}

if(p==NULL)

{

s=new node; s->data=x;

s->next=NULL; q->next=s; count++;

}

else{

s=new node; s->data=x; s->next=q->next;

q->next=s; count++;

}

return success;

}

error_code list::delete_element(const int i)

{

node *u; node *p=head; int j=0;

while(j!=i-1&&p!=NULL)

{

p=p->next; j++;

}

if(i<1||i>count)

return arrange_error;

u=p->next; p->next=u->next;

delete u; count--;

return success;

}

void list::print()

node *p=head->next;

while(p!=NULL)

{

cout<data<<" ";

p=p->next;

}

cout<

}

void main()

{

list l;

int x;

cout<<"创建一个链表(输入‘-1’结束)："<

l.create2();

cout<<"输入要插入的数（输入‘-1’结束）:"<

cout<<"输入一个数:";

cin>>x;

while(x!=-1)

{

l.insert(x);

cout<<"输入一个数:";

cin>>x;

}

l.print();

}

测试数据:链表元素为（10,20,30,40,50,60,70,80,90,100）,x分别为25，85，110和8。运行结果：

2.将单链表Ｌ中的奇数项和偶数项结点分解开，并分别连成一个带头结点的单链表，然后再将这两个新链表同时输出在屏幕上，并保留原链表的显示结果，以便对照求解结果。

实验原理：依据题目的要求，需要再创建两个新链表来存储分离后的奇偶项，而奇偶项可以根据数字来控制，把他们取出来并重新连起来。

程序清单：

#include

#include

using namespace std;

typedef struct snode

{

int data;

struct snode *next;

}node;

enum error_code{arrange_error,success};

class list

{

public:

list();

void create2();

int length() const;

error_code get_element(const int i,int &x) const;

error_code insert(const int &x);

error_code delete_element(const int i);

node *locate(const int x) const;

node *get_head(){return head;}

divide(list &B,list &C);

void print();

private:

int count;

node *head;

};

list::list()

{

head=new node; head->next=NULL;

count=0;

}

void list::create2()

{

int x; node *p=head;

node *s; cout<<"输入一个值：";

cin>>x;

while(x!=-1)

{

s=new node; s->data=x;

s->next=NULL; p->next=s;

p=s; cout<<"输入一个值：";

cin>>x;

}

}

int list::length() const

{

return count;

}

error_code list::get_element(const int i,int &x) const {

int j=1; node *p=head->next;

while(p!=NULL&&j!=i)

{

p=p->next; j++;

}

if(p==NULL)

return arrange_error;

x=p->data;

return success;

}

node *list::locate(const int x) const

{

node *p=head->next;

while(p!=NULL)

{

if(p->data==x)

return p;

p=p->next;

}

return NULL;

}

void list::divide(list &B,list &C)

{

node *u; node *pa=head->next;

node *pb=B.get_head(); node *pc=C.get_head();

for(int i=0;pa!=NULL;i++,pa=pa->next)

{

u=new node; u->data=pa->data;

if(i%2==0)

{

pb->next=u; pb=pb->next;

}

else

{

pc->next=u; pc=pc->next;

}

pb->next=NULL; pc->next=NULL;

}

}

error_code list::insert(const int &x)

{

node *s; node *q=head; node *p=head->next;

while(p!=NULL&&p->data

{

q=p; p=p->next;

}

if(p==NULL)

{

s=new node; s->data=x;

s->next=NULL; q->next=s; count++;

}

else{

s=new node; s->data=x; s->next=q->next;

q->next=s; count++;

}

return success;

}

error_code list::delete_element(const int i)

{

node *u; node *p=head; int j=0;

while(j!=i-1&&p!=NULL)

{

p=p->next; j++;

}

if(i<1||i>count)

return arrange_error;

u=p->next; p->next=u->next;

delete u; count--;

return success;

}

void list::print()

{

node *p=head->next;

while(p!=NULL)

{

cout<data<<" ";

p=p->next;

}

cout<

}

void main()

{

list A,B,C; int x,y,z;

A.create_R(); A.divide(B,C);

cout<<"原表："; A.output();

cout<<"奇数表："; B.output();

cout<<"偶数表："; C.output();

}

测试数据：第一组数据：链表元素为（1,2,3,4,5,6,7,8,9,10,20,30,40,50,60）

第二组数据：链表元素为（10,20,30,40,50,60,70,80,90,100）运行结果：

3.求两个递增有序链表L1和L2中的公共元素，并以同样方式连接成链表L3。

实验原理：设置两个指针怕，pa,pb分别依次指示A,B表中的元素，其初始值分别为A.head->next和B.head->next。在pa,pb均非空时，根据其值的大小关系可能有如下三种情况。

(1).pa->data==pb->data:搜索到公共元素，应在C表表尾插入一个结点，其值为pa->data，然后继续A表中下一个元素的搜索，即pa=pa->next,同时pb也往后移。

(2). pa->data>pb->data:表明A表中这一元素可能在B表当前元素的后面,因此要往B 表的后面搜索,故而执行pb=pb->next,然后继续搜索。

(3). pa->datadata:表明A中这一元素在B中不存在，因而执行pa=pa->next以继续对A表中下一个元素的判断。

反复执行上述比较，直到pa,pb至少有一个为空为止。此时，剩余的非空部分没有所需要的公共元素，因而搜索结束。

程序清单：

#include

#include

using namespace std;

typedef struct snode

{

int data;

struct snode *next;

}node;

enum error_code{arrange_error,success};

class list

{

public:

list();

void create2();

int length() const;

error_code get_element(const int i,int &x) const;

error_code insert(const int &x);

error_code delete_element(const int i);

node *locate(const int x) const;

node *get_head(){return head;}

void list::gongyou(list &L1,list &L2)

void print();

private:

int count;

node *head;

};

list::list()

{

head=new node; head->next=NULL;

count=0;

}

void list::create2()

{

int x; node *p=head;

node *s; cout<<"输入一个值：";

cin>>x;

while(x!=-1)

{

s=new node; s->data=x;

s->next=NULL; p->next=s;

p=s; cout<<"输入一个值：";

cin>>x;

}

}

int list::length() const

{

return count;

}

error_code list::get_element(const int i,int &x) const {

int j=1; node *p=head->next;

while(p!=NULL&&j!=i)

{

p=p->next; j++;

}

if(p==NULL)

return arrange_error;

x=p->data;

return success;

}

void list::gongyou(list &L1,list &L2)

{

node *p1=L1.head->next; node *p2=L2.head->next;

node *p3=head; node *u;

while(p1!=NULL&&p2!=NULL)

{

if(p1->data==p2->data)

{

u=new node; u->data=p1->data; p3->next=u;

p1=p1->next; p2=p2->next; p3=p3->next;

}

else{

if(p1->datadata)

p1=p1->next;

else

p2=p2->next;

}

}

p3->next=NULL;

}

node *list::locate(const int x) const

{

node *p=head->next;

while(p!=NULL)

{

if(p->data==x)

return p;

p=p->next;

}

return NULL;

}

void list::divide(list &B,list &C)

{

node *u; node *pa=head->next;

node *pb=B.get_head(); node *pc=C.get_head();

for(int i=0;pa!=NULL;i++,pa=pa->next)

{

u=new node; u->data=pa->data;

if(i%2==0)

{

pb->next=u; pb=pb->next;

}

else

{

pc->next=u; pc=pc->next;

}

pb->next=NULL; pc->next=NULL;

}

}

error_code list::insert(const int &x)

{

node *s; node *q=head; node *p=head->next;

while(p!=NULL&&p->data

{

q=p; p=p->next;

}

if(p==NULL)

{

s=new node; s->data=x;

s->next=NULL; q->next=s; count++;

}

else{

s=new node; s->data=x; s->next=q->next;

q->next=s; count++;

}

return success;

}

error_code list::delete_element(const int i)

{

node *u; node *p=head; int j=0;

while(j!=i-1&&p!=NULL)

{

p=p->next; j++;

}

if(i<1||i>count)

return arrange_error;

u=p->next; p->next=u->next;

delete u; count--;

return success;

}

void list::print()

{

node *p=head->next;

while(p!=NULL)

{

cout<data<<" ";

p=p->next;

}

cout<

}