大数阶乘数据结构算法课程设计副本.docx
《大数阶乘数据结构算法课程设计副本.docx》由会员分享，可在线阅读，更多相关《大数阶乘数据结构算法课程设计副本.docx（31页珍藏版）》请在冰豆网上搜索。
大数阶乘数据结构算法课程设计副本
实习题目一
线性表及其应用
【问题描述】
大数运算——计算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;
}
}
/**********************确定链表的长度*****************************/
template
intChain:
:
Length（）const
{
ChainNode*current=first;
intlen=0;
while（current）
{
len++;
current=current->link;
}
returnlen;
}
/*********************在链表中查找第K个元素*************************/
template
boolChain:
:
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;indexp=p->link;
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个元素***********************/
template
Chain&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个元素***************************/
template
Chain&Chain:
:
Search（constT&x）const
{
ChainNode*current=first;
intindex=1;
while（current&¤t->data!
=x）
{
current=current->link;
index++;
}
if（current）returnindex;
return0;
}
/***********************倒序输出链表************************/
template
intChain:
:
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（jA.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="<cout<<"阶乘为：
";
A.OutPut（）;
return0;
}
【测试数据】
（1）n＝20，n！
＝2432902008176640000
（2）n＝30，n！
＝265252859812191058636308480000000
【运行结果】
实习题目二
算术表达式求值
【基本要求】
（1）正确解释表达式；
（2）符合四则运算规则：
先乘除、后加减
从左到右运算
先括号内，后括号外
（3）输出最后的计算结果
【实现关键】
两个栈的使用
两位数以上、负数、小数点？
【实现方式】
基本：
控制台程序
【实现提示】
（1）使用两个工作栈：
一个栈：
存放运算符.另一个栈：
存放操作数
（2）运算符之间的优先关系
可用二维数组（算符优先顺序如下：
）
【实现代码】
#include"stdafx.h"
#include
usingnamespacestd;
template
classStack
{
public:
Stack（intMaxStackSize=10）;
~Stack（）{delete[]stack;}
boolIsEmpty（）const{returntop==-1;}
boolIsFull（）const{returntop==MaxTop;}
TTop（）const;
Stack&Add（constT&x）;
Stack&Delete（T&x）;
private:
inttop;
intMaxTop;
T*stack;
};
template
Stack:
:
Stack（intMaxStackSixe）
{
MaxTop=MaxStackSixe-1;
stack=newT[MaxStackSixe];
top=-1;
}
template
TStack:
:
Top（）const
{
returnstack[top];
}
template
Stack&Stack:
:
Add（constT&x）
{
stack[++top]=x;
return*this;
}
template
Stack&Stack:
:
Delete（T&x）
{
x=stack[top--];
return*this;
}
//此函数用来比较两个符号的优先级
intComp（charleft,charright）
{
chart[9]={'+','-','*','/','%','^','（','）','#'};
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!
!
!
"<return2;
}
}
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）
{
cout<<"被除数为0，有错！
！
！
"<returnfalse;
}
elsereturnd/e;
default:
return0;
}
}
intmain（）
{
charx;
Stackop;
Stackk;
op.Add（'#'）;
cout<<"请输入中缀表达式并以#结尾"<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<k.Add（op.Top（））;
op.Delete（x）;
}
}
}
}
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<<"表达式的值为：
"<cout<<（double）k.Top（）-48<return0;
}
【运行结果】
-
实习题目三
二叉树基本算法的实现
【功能要求】
实现Create方法，要求键盘输入二叉树结点序列，创建一棵二叉树（提示：
前序递归）
实现SwapTree方法，以根结点为参数，交换每个结点的左子树和右子树（提示：
前序递归）
增加InorderTree方法，采用非递归方法实现二叉树的中序遍历
你可以选择：
对BinaryTree模板进行功能扩充；
自己定义并实现二叉树类
要求键盘输入二叉树结点序列
结点序列可以是前序，也可以是层次
空结点以#表示
【代码实现】
#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（BinaryTr
升级会员 