数据结构实习题目文档格式.docx
《数据结构实习题目文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构实习题目文档格式.docx（51页珍藏版）》请在冰豆网上搜索。
⏹intSearch（constT&
//查找元素x
⏹Chain<
&
Delete（intk,T&
x）;
//删除第k个元素
Insert（intk,constT&
//在第k个元素之后插入x
⏹voidOutput（ostream&
out）const;
//单链表的输出
Fac（longn）;
⏹//求大数阶乘
*first;
//指向第一个节点
⏹
⏹Chain<
:
~Chain（）
⏹{//删除所有的节点
*next;
⏹while（first）
⏹{
⏹next=first->
link;
⏹deletefirst;
⏹first=next;
⏹}
⏹}
⏹boolChain<
Find（intk,T&
x）const
⏹{//查找第k个元素，并赋值给x
⏹if（k<
1）returnfalse;
*current=first;
⏹intindex=1;
⏹while（index<
k&
current）
⏹current=current->
⏹index++;
⏹if（current）
⏹x=current->
data;
⏹returntrue;
⏹returnfalse;
⏹intChain<
Search（constT&
⏹{//查找元素x，返回该元素的下标
⏹while（current&
current->
data!
=x）
⏹if（current）returnindex;
⏹return0;
Chain<
Delete（intk,T&
x）
⏹{//删除第k个元素，并赋值给x，返回改变后的链表
*p=first;
⏹if（k==1）
⏹first=first->
⏹else
*q=first;
⏹for（intindex=1;
index<
k-1&
q;
index++）
⏹q=q->
⏹p=q->
⏹q->
link=p->
⏹}
⏹x=p->
⏹deletep;
⏹return*this;
Length（）const//返回链表的长度
⏹{
⏹intlen=0;
⏹while（current）
⏹len++;
⏹returnlen;
Insert（intk,constT&
x）//在第k个元素之后插入x，返回插入后的链表
p;
index++）
⏹p=p->
*y=newChainNode<
⏹y->
data=x;
⏹if（k）
⏹p->
link=y;
⏹else
link=first;
⏹first=y;
⏹voidChain<
Output（ostream&
out）const//输出链表元素
*current;
⏹inti=0,j=Length（）;
⏹for（current=first;
current;
current=current->
link）
⏹i++;
⏹if（i==j&
j>
=1）
⏹{
⏹if（current->
⏹out<
<
setw（3）<
setfill（'
0'
）<
data<
"
⏹else
⏹out<
⏹i=1;
⏹j--;
⏹current=first;
⏹}
⏹out<
first->
data<
"
//重载运算符<
⏹ostream&
operator<
（ostream&
out,constChain<
⏹{x.Output（out）;
returnout;
}
Fac（longn）//初始化
⏹
⏹inti=0;
⏹longj=n;
⏹while（j>
999）
⏹Insert（i,j%1000）;
⏹j=j/1000;
⏹Insert（i,j）;
//通过插入来建立链表（0,20）
⏹//计算
⏹longm=0,k=0;
⏹for（;
n>
2;
n--）
⏹for（current=first;
current;
link）//?
⏹{
⏹m=k;
⏹k=（current->
data*（n-1）+k）/1000;
//向前进位
⏹current->
data=（current->
data*（n-1）+m）%1000;
⏹if（!
current->
link&
k>
0）//?
⏹while（k>
⏹{
⏹Insert（Length（）,k%1000）;
⏹k=k/1000;
⏹}
⏹Insert（Length（）,k）;
//链表长度加一
⏹k=0;
⏹break;
⏹}
⏹intmain（）
⏹longn;
⏹charch;
⏹do
⏹cout<
请输入需要阶乘的数字n:
⏹cin>
>
n;
⏹Chain<
long>
a;
⏹a.Fac（n）;
n<
的阶乘为:
endl;
a;
是否进行计算:
ch;
⏹}while（ch=='
Y'
）;
2:
题目：
表达式求值
v要求：
实现关键
▪栈的使用
▪两位数以上、负数、小数点？
v实现方式
▪控制台程序
▪MFC对话框
#include"
#include<
usingnamespacestd;
#include<
assert.h>
cstdlib>
math.h>
template<
classStack
{
public:
Stack（intsz=50）;
~Stack（）
{
delete[]elements;
}
voidPush（constT&
x）;
//压入栈
boolPop（T&
//弹出栈
TGetTop（void）const;
//取栈顶元素
boolIsEmpty（）const
return（top==-1）?
true:
false;
boolIsFull（）//判断栈是否满
return（top==MaxSize-1）?
intGetSize（）const//?
returntop+1;
voidMakeEmpty（）
top=-1;
private:
T*elements;
inttop;
intMaxSize;
voidoverflowProcess（）;
//栈溢出处理
};
Stack<
Stack（intsz）
top=-1;
MaxSize=sz;
elements=newT[MaxSize];
//创建栈的数组空间
assert（elements!
=NULL）;
//判断动态内存是否分配成功是否
voidStack<
Push（constT&
x）
if（IsFull（）==true）
{
overflowProcess（）;
}
top++;
elements[top]=x;
boolStack<
Pop（T&
if（IsEmpty（）==true）
returnfalse;
x=elements[top--];
returntrue;
TStack<
GetTop（void）const//返回栈顶元素
cerr<
栈为空!
exit
（1）;
}
returnelements[top];
overflowProcess（）//溢出处理
T*newArray=newT[2*MaxSize];
//扩充栈的空间
for（inti=0;
i<
=top;
i++）
MaxSize=2*MaxSize;
newArray[i]=elements[i];
delete[]elements;
//释放原来旧的空间
classCalculater//计算的声明
public:
Calculater（）{}
voidRun（）;
//执行表达式计算
voidClear（）;
//清空处理
private:
Stack<
double>
s;
//声明double型的栈对象
voidAddOperand（doublevalue）;
//把数值压入栈中
boolGetOperand（double&
left,double&
right）;
//判断取操作数操作是否成功
voidDoOperator（charch）;
//进行操作
voidCalculater:
AddOperand（doublevalue）
s.Push（value）;
boolCalculater:
GetOperand（double&
right）
if（s.IsEmpty（）==true）{
缺少右操作数"
s.Pop（right）;
缺少左操作数"
s.Pop（left）;
Clear（）
s.MakeEmpty（）;
DoOperator（charch）{
doubleleft,right,value;
boolresult;
result=GetOperand（left,right）;
if（result==true）
switch（ch）
case'
+'
value=left+right;
s.Push（value）;
break;
-'
value=left-right;
*'
value=left*right;
/'
if（right==0.0）
{
cerr<
Divideby0!
Clear（）;
}
else
value=left/right;
s.Push（value）;
cout<
="
s.GetTop（）<
else
Clear（）;
Run（）
charch;
doublenewOperand;
while（cin>
ch,ch!
='
#'
）
switch（ch）
case'
case'
//是操作数，执行计算
DoOperator（ch）;
default:
//其实也是一种case，只不过就是指“除了指定的几个case以外的其他情况”，不是操作符
cin.putback（ch）;
//字符放回输入流
cin>
newOperand;
//重新读取操作数，一个操作数的第一个字符
AddOperand（newOperand）;
//将操作数放入栈中
intmain（）
Calculatercall;
cout<
输入计算表达式:
call.Run（）;
return0;
3.题目:
v题目：
二叉树基本算法的实现
v功能要求：
v键盘输入二叉树结点序列，创建一棵二叉树
v实现S方法，以根结点为参数，交换每个结点的左子树和右子树（提示：
前序递归）
v实现Find方法，查找值为key的结点，并输出该结点的所有祖先结点
v你可以选择：
v对BinaryTree模板进行功能扩充；
v自己定义并实现二叉树类
v要求键盘输入二叉树结点序列
v结点序列可以是前序，也可以是层次
v空结点以#表示
//binarytree.h
#ifndefBINARYTREE_H
#defineBINARYTREE_H
iostream.h>
classBinaryTreeNode//二叉树结点
//friendBinaryTree<
BinaryTreeNode（）{LeftChild=RightChild=0;
BinaryTreeNode（constT&
e）
data=e;
LeftChild=RightChild=0;
e,BinaryTreeNode*l,BinaryTreeNode*r）
LeftChild=l;
RightChild=r;
Tdata;
BinaryTreeNode<
*LeftChild,*RightChild;
classBinaryTree
friendBinaryTreeNode<
BinaryTree（）
root=0;
~BinaryTree（）{}
boolIsEmpty（）const
return（（root）?
false:
true）;
voidCreat（）;
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））//层次遍历
PreOrder（Output,root）;
voidInOutput（）//中序输出
InOrder（Output,root）;
voidPostput（）//后序输出
PostOrder（Output,root）;
voidLevelOutPut（）//层次输出
LevelOrder（Output）;
intHeight（）const//计算树的高度
returnHeight（root）;
intSize（）const//计算树的大小
returnSize（root）;
*iCreat（）;
voidswap（）//交换左右节点
s）;
intleave（）//计算叶子节点个数
returnleave（root）;
intnoleave（）////计算非叶子节点个数
returnnoleave（root）;
*root;
voidPreOrder（void（*Visit）（BinaryTreeNode<
*u）,BinaryTreeNode<
*t）;
voidInOrder（void（*Visit）（BinaryTreeNode<
voidPostOrder（void（*Visit）（BinaryTreeNode<
//voidLevelOrder（void（*Visit）（BinaryTreeNode<
staticvoidOutput（BinaryTreeNode<
*t）//输出树的所有节点
t->
intHe
升级会员 