大数阶乘数据结构算法课程设计.docx

大数阶乘数据结构算法课程设计.docx

《大数阶乘数据结构算法课程设计.docx》由会员分享，可在线阅读，更多相关《大数阶乘数据结构算法课程设计.docx（54页珍藏版）》请在冰豆网上搜索。

大数阶乘数据结构算法课程设计

数据结构与算法

上机课程设计报告

指导老师:

姓

名:

班

级:

学

号:

2010年1月

实习题目一

线性表及其应用

【问题描述】

大数运算——计算n的阶乘（n>=20）。

【基本要求】

（1）数据的表示和存储；

（1.1）累积运算的中间结果和最终的计算结果的数据类型要求是整型——这是问题本

身的要求；

（1.2）试设计合适的存储结构，要求每个元素或节点最多存储数据的3位数值。

（2）数据的操作及其实现：

基于设计的存储结构实现乘法操作，要求从键盘上输入n值，在屏幕上显示最终计算结果。

【实现提示】

（1）设计数据的存储结构：

介于阶乘运算的精确性以及实型数据表示的不精确性，本题不能采用实型表示累积运算的中间结果和最终的计算结果，而只能用整型。

然而由于普通整型和长整型所能表述数的范围受其字长的限制，不能表示大数阶乘的累积结果，故必须设计一个合适的数据结构实现对数据的存储，例如可以让每个元素或节点存储数据的若干位数值。

从问题描述不难看出n值为任意值，故为使程序尽量不受限制，应采用动态存储结构。

（2）数据的操作及其实现：

（2.1）累积运算的特点是当前的计算结果是下次乘法运算的乘数；

（2.2）实现两个数的乘法运算须考虑：

（1）乘数的各位数都要与被乘数进行乘法运算；

（2）乘法过程中的进位问题及其实现；（3）因每个元素或节点最多存储数据的3位数值，故当元素或节点中的数值大于999，需向前一个元素或节点进位。

【实现结构】

（1）采用链式存储结构实现（普通单链表，循环单链表，普通双项链表和双向循环链表中任选一种结构）。

（2）采用动态数组实现。

【实现程序】

#include"stdafx.h"

#include

usingnamespacestd;

template

classChain;

template

classChainNode

friendChain;

private:

Tdata;

ChainNode*link;

};

template

classChain

{

public:

Chain（）{first=0;};

~Chain（）;

boolIsEmpty（）const{returnfirst==0;}intLength（）const;

boolFind（intk,T&x）;

Chain&Insert（intk,constT&x）;

Chain&Change（intk,Tx）;

Chain&Delete（intk,T&x）;

Chain&Search（constT&x）const;intOutPut（）;

private:

ChainNode*first;

};

//析构函数（删除链表的所有节点）template

Chain:

:

~Chain（）

{

ChainNode*next;

while（first）

{next=first->link;deletefirst;first=next;

}

}

//确定链表的长度templateintChain:

:

Length（）const

{

ChainNode*current=first;

intlen=0;

while（current）

len++;

current=current->link;

}

returnlen;

}

//在链表中查找第K个元素templateboolChain:

:

Find（intk,T&x）{

ChainNode*current=first;

intindex=0;while（index

{

current=current->link;

index++;

}

if（current）{x=current->data;returntrue;}returnfalse;

}

//向链表中插入元素

template

Chain&Chain:

:

Insert（intk,constT&x）{

ChainNode*p=first;

for（intindex=1;indexlink;

ChainNode*y=newChainNode;y->data=x;

if（k）{

y->link=p->link;

p->link=y;}

else{

y->link=first;

first=y;

}

return*this;

}

//改变链表第k个元素的值template

Chain&Chain:

:

Change（intk,Tx）

ChainNode*p=first;

for（intindex=0;p&&index

{p=p->link;

}

if（p）

p->data=x;

return*this;

}

//删除链表第k个元素templateChain&Chain:

:

Delete（intk,T&x）{

if（k=0）{first=first->link;}else

ChainNode*p=first;

ChainNode*q=first;

for（intindex=1;index

{

q=q->link;

p=q->link;q-link=p->link;x=P->data;deletep;return*this;

}

}

//搜索第k个元素templateChain&Chain:

:

Search（constT&x）const{

ChainNode*current=first;

intindex=1;

while（current&¤t->data!

=x）

{

current=current->link;index++;

}

if（current）returnindex;return0;

}

//倒序输出链表templateintChain:

:

OutPut（）

ChainNode*current=first;

intindex=0;

intlen=0;

while（current）

{

len++;

current=current->link;

}

int*arry=newint[len];

current=first;

while（current）

{arry[index]=current->data;current=current->link;index++;

}

index=index-1;

cout<

index=index-1;

for（index;index>=0;index--）

{

cout.fill（'0'）;

cout.width（3）;

cout<

}

cout<

return0;

}

intmain（）

{

ChainA;

intn,i,j,k;

intl=0;

A.Insert（0,1）;

cout<<"pleaseenteranumber:

"<

cin>>n;

for（i=1;i<=n;i++）

{

intm=A.Length（）;

for（j=0;j

{

A.Find（j,k）;

k=i*k;

A.Change（j,k）;

}

for（j=0;j

{

A.Find（j,k）;

if（k>=1000）

{

if（j

A.Find（j+1,l）;

else

{A.Insert（j+1,0）;l=0;

}

l+=k/1000;

A.Change（j+1,l）;

k=k%1000;

A.Change（j,k）;

}

}

}

cout<<"Length="<

";

A.OutPut（）;

return0;

}

测试数据】

（1）n=20,n!

=2432902008176640000

（2）n=30,n!

=265252859812191058636308480000000

【运行结果】

pleaseenteranumber:

20

Length=7;

阶乘为：

2432902008176640000

实习题目二

算术表达式求值

【问题描述】对一个合法的中缀表达式求值。

假设表达式只包含+、-、*、/四个双目运算符，并且允许有括号出现，运算符本身不具有二义性。

例如：

3.5*（7+2）/（-6）

【基本要求】

（1）正确解释表达式；

（2）符合四则运算规则：

先乘除、后加减

从左到右运算

先括号内，后括号外

（3）输出最后的计算结果

【实现关键】

两个栈的使用

两位数以上、负数、小数点？

【实现方式】

基本：

控制台程序

【实现提示】

（1）使用两个工作栈：

一个栈OPTR存放运算符；stack

另一个栈OPND存放操作数；stack

（2）运算符之间的优先关系

可用二维数组（算符优先顺序如下：

）

+

-

*

/

（

）

#

+

>

>

<

<

<

>

>

-

>

>

<

<

<

>

>

*

>

>

>

>

<

>

>

/

>

>

>

>

<

>

>

（

<

<

<

<

<

=

）

>

>

>

>

>

>

#

<

<

<

<

<

=

【实现代码】

#include"stdafx.h"

#include

usingnamespacestd;

templatevclassT>

classStack

{

public:

Stack（intMaxStackSize=10）;~Stack（）{delete[]stack;}boollsEmpty（）const{returntop==-1;}boolIsFull（）const{returntop==MaxTop;}TTop（）const;

StackvT>&Add（constT&x）;

StackvT>&Delete（T&x）;

private:

inttop;

intMaxTop;

T*stack;

};templateStack:

:

Stack（intMaxStackSixe）{

MaxTop=MaxStackSixe-1;stack=newT[MaxStackSixe];top=-1;

}template

TStack:

:

Top（）const

{

returnstack[top];

}templateStack&Stack:

:

Add（constT&x）{

stack[++top]=x;return*this;

}templateStack&Stack:

:

Delete（T&x）

{x=stack[top--];return*this;

}//此函数用来比较两个符号的优先级

intComp（charleft,charright）

{

chart[9]={'+','-','*',7','%','A','（','）',#};

intsmax[9][9]=/*+*/{1,1,2,2,2,2,2,1,1,

/*-*/1,1,2,2,2,2,2,1,1,

/***/1,1,1,1,1,2,2,1,1,/*/*/1,1,1,1,1,2,2,1,1,

/*%*/1,1,1,1,1,2,2,1,1,

/"*/1,1,1,1,1,1,2,1,1,

/*（*/2,2,2,2,2,2,2,3,0,

/*）*/1,1,1,1,1,1,0,1,1,/*#*/2,2,2,2,2,2,2,0,3};intj,k;

for（inti=0;i<9;i++）

if（left==t[i]）

j=i;

if（right==t[i]）

k=i;

}

switch（smax[j][k]）

{

case1:

return1;

case2:

return-1;

case3:

return0;

default:

cout<<"ERROR!

!

!

"<

}

}

doubleCal（charb,charop,chara）

{

doubled=（int）b-48;

doublee=（int）a-48;

switch（op）

{

case'+':

returnd+e;//计算+

case'-':

returnd-e;//计算-

case'*':

returnd*e;//计算*

case'/':

//计算/if（e==0）

{

coutvv"被除数为0,有错！

！

！

"<

returnfalse;

}

elsereturnd/e;

default:

return0;

intmain（）

charx;Stackop;

Stackk;

op.Add（'#'）;

coutvv"请输入中缀表达式并以#1吉尾"<

chars[20];

charexpr[20];

cin.getline（s,20）;

cout«"后缀表达式为：

"<

for（intj=0;j

{

if（s[j]>='0'&&s[j]<='9'）

{

cout<

k.Add（s[j]）;

}

else

{

if（s[j]!

='）'）

{

if（Comp（op.Top（）,s[j]）==-1）op.Add（s[j]）;

elseif（Comp（op.Top（）,s[j]）==1）{

cout<

k.Add（op.Top（））;

op.Delete（x）;

op.Add（s[j]）;

}

}

if（s[j]=='）'）

{

while（op.Top（）!

='（'）

{

cout<

k.Add（op.Top（））;

op.Delete（x）;

}

if（op.Top（）=='（'）

op.Delete（x）;

}

if（s[j]=='#'）

{

op.Delete（x）;

while（op.Top（）!

='#'）

{

cout<

}

}

}

}

inti=0;chara;charb;doublen;charm;

while（!

k.IsEmpty（））

{

k.Delete（expr[i]）;

i++;

}

for（i=i-1;i>=0;i--）

{

if（expr[i]>='0'&&expr[i]<='9'）k.Add（expr[i]）;

else

{

k.Delete（a）;

k.Delete（b）;n=Cal（b,expr[i],a）;

m=n+'0';

k.Add（m）;

}

}

cout<<"表达式的值为：

"<

return0;

}

【运行结果】请输入中缀表达式并以#结尾（4+2）/3-4*3

后缀表达式为:

42+3/43*-表达式的值为:

-10

实习题目三

二叉树基本算法的实现

【功能要求】

实现Create方法，要求键盘输入二叉树结点序列，创建一棵二叉树（提示：

前序递归）

实现SwapTree方法，以根结点为参数，交换每个结点的左子树和右子树（提示:

前序递归）

增加InorderTree方法，采用非递归方法实现二叉树的中序遍历你可以选择:

对BinaryTree模板进行功能扩充；自己定义并实现二叉树类要求键盘输入二叉树结点序列结点序列可以是前序，也可以是层次空结点以#表示

【代码实现】

//二叉树01.cpp:

Definestheentrypointfortheconsoleapplication.

//

#include"stdafx.h"

#include

usingnamespacestd;template

classBinaryTreeNode;

template

classBinaryTree

{

public:

BinaryTree（）

{

root=0;

}

BinaryTree（constBinaryTree&Tree）

{

copy（Tree.root,root）;

}

~BinaryTree（）{};

boolIsEmpty（）const

{

return（（root）?

false:

true）;

}

voidCreat（）;

boolRoot（T&x）const;

voidMakeTree（constT&element,BinaryTree&left,BinaryTree&right）;

voidBreakTree（T&element,BinaryTree&left,BinaryTree&right）;

voidPreOrder（void（*Visit）（BinaryTreeNode*u））

{

PreOrder（Visit,root）;

}

voidInOrder（void（*Visit）（BinaryTreeNode*u））

{

InOrder（Visit,root）;

}

voidPostOrder（void（*Visit）（BinaryTreeNode*u））

{

PostOrder（Visit,root）;

}

voidLevelOrder（void（*Visit）（BinaryTreeNode*u））;

voidPreOutput（）

{

PreOrder（Output,root）;

cout<

}

voidInOutput（）

{

InOrder（Output,root）;

cout<

}

voidPostput（）

{

PostOrder（Output,root）;

cout<

}

voidLevelOutPut（）

{

LevelOrder（Output）;

cout<

}

voidDelete（）

{

PostOrder（Free,root）;

root=0;

intHeight（）const

{

returnHeight（root）;

}

intSize（）const

{

returnSize（root）;

}

BinaryTreeNode*iCreat（）;

boolequal（BinaryTree&Tree）

{

returncompare（root,Tree.root）;

}

voidswap（）

{swap（root）;

}

intleave（）

{

returnleave（root）;

}

intnoleave（）

{

returnnoleave（root）;

}

private:

BinaryTreeNode*root;

voidPreOrder（void（*Visit）（BinaryTreeNode*u）,BinaryTreeNode*t）;

voidInOrder（void（*Visit）（BinaryTreeNode*u）,BinaryTreeNode*t）;

voidPostOrder（void（*Visit）（BinaryTreeNode*u）,BinaryTreeNode*t）;staticvoidOutput（BinaryTreeNode*t）

{cout<data<<"";

}

staticvoidFree（BinaryTreeNode*t）

{

deletet;

}

intHeight（BinaryTreeNode*t）const;

intSize（BinaryTreeNode*t）const;

boolcompare（BinaryTreeNode*t1,BinaryTreeNode*t2）;

voidcopy（constBinaryTreeNode*t1,BinaryTreeNode*&t2）;

voidswap（BinaryTreeNode*t）;intleave（BinaryTreeNode*t）;intnoleave（BinaryTreeNode*t）;

};templateclassLinkedQueue;templateclassNode{

friendLinkedQueue;private:

Tdata;

Node*link;

};templateclassLinkedQueue

{public:

LinkedQueue（）

{front=rear=0;

}

~LinkedQueue（）;boolIsEmpty（）const

{

return（（front）?

false:

true）;

}

boolIsFull（）const;

TFirst（）const;

TLast（）const;

LinkedQueue&Add（constT&x）;

LinkedQueue&Delete（T&x）;private:

Node*front;Node