天津理工大学实验报告模板

合集下载

天津理工大学数据结构实验报告4

附录（可包括源程序清单或其它说明）#include <stdio.h>#include <string>#define MAX_NAME 10#define MAX_INFO 80typedef char InfoType;typedef char V ertexType[MAX_NAME]; // 字符串类型#define MAX_VERTEX_NUM 20typedef enum{unvisited,visited}VisitIf;typedef struct EBox{VisitIf mark; // 访问标记int ivex,jvex; // 该边依附的两个顶点的位置struct EBox *ilink,*jlink; // 分别指向依附这两个顶点的下一条边InfoType *info; // 该边信息指针}EBox;typedef struct{V ertexType data;EBox *firstedge; // 指向第一条依附该顶点的边}V exBox;typedef struct{V exBox adjmulist[MAX_VERTEX_NUM];int vexnum,edgenum; // 无向图的当前顶点数和边数}AMLGraph;typedef int QElemType;typedef struct QNode{// 单链表的链式存储结构QElemType data; //数据域struct QNode *next; //指针域}QNode,*QueuePtr;typedef struct{QueuePtr front,//队头指针，指针域指向队头元素rear; //队尾指针，指向队尾元素}LinkQueue;// 若G中存在顶点u,则返回该顶点在无向图中位置;否则返回-1int LocateV ex(AMLGraph G,V ertexType u){int i;for(i=0;i<G.vexnum;++i)if(strcmp(u,G.adjmulist[i].data)==0)return i;return -1;}int CreateGraph(AMLGraph *G){ // 采用邻接表存储结构,构造无向图G int i,j,k,l,IncInfo;char s[MAX_INFO];V ertexType va,vb;EBox *p;printf("请输入无向图G的顶点数,边数: ");scanf("%d,%d",&(*G).vexnum,&(*G).edgenum);printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);for(i=0;i<(*G).vexnum;++i){ // 构造顶点向量scanf("%s",(*G).adjmulist[i].data);(*G).adjmulist[i].firstedge=NULL;}printf("请顺序输入每条边的两个端点(以空格作为间隔):\n");for(k=0;k<(*G).edgenum;++k){// 构造表结点链表scanf("%s%s%*c",va,vb); // %*c吃掉回车符i=LocateV ex(*G,va); // 一端j=LocateV ex(*G,vb); // 另一端p=(EBox*)malloc(sizeof(EBox));p->mark=unvisited; // 设初值p->ivex=i;p->jvex=j;p->info=NULL;p->ilink=(*G).adjmulist[i].firstedge; // 插在表头(*G).adjmulist[i].firstedge=p;p->jlink=(*G).adjmulist[j].firstedge; // 插在表头(*G).adjmulist[j].firstedge=p;}return 1;}V ertexType* GetVex(AMLGraph G,int v){ // 返回v的值if(v>=G.vexnum||v<0)exit(0);return &G.adjmulist[v].data;}// 返回v的第一个邻接顶点的序号。

天津理工大学数据结构实验报告1

r=(LinkList)malloc(sizeof(LNode));
r=L;
L->data=1;
L->next=NULL;
for(int i=2;i<=n;i++){
p=(LinkList)malloc(sizeof(LNode));
p->data=i;
p->next=NULL;
2. 运用单循环链表结构实现约瑟夫环问题：
设计工作指针p指向当前计数结点，为实现删除结点p的操作，再设计辅助工作结点q指向结点p的后继结点，计数器从1开始计数。其算法的伪代码如下：
2.1工作指针p初始化，计数器count初始化：
p=L；count=1；
2.2输出单循环链表中的每一个元素；
r->next=p;
r=p;
}
r->next=L;
}
void Josephus(LinkList &L,int s,int m){
LinkList p,q;
int count=1,t;
p=L;
for(int i=1;i<s;i++)
p=p->next;
while(p->next!=p){
交换p与q所指结点的值并删除结点q，即删除了结点p所指元素；
计数器变为1；
2.3.2 工作指针p后移，计数器count+1；
2.4输出链表中剩余的最后一个结点，并删除。
3. 在主函数中调用各个函数，完成程序。
结论：
实验中，输入9,1,5，输出5 1 7 4 3 6 9 2 8，
2

天津理工大学理学专业实习总结报告范文模板

实习报告理学专业姓名：巴菲特学号：20170921009 专业：理学班级：理学01班指导老师：巴菲特实习时间：XXXX-XX-XX—XXXX-XX-XX 20XX年XX月XX日目录目录 (2)前言 (3)一、实习目的及任务 (3)1.1实习目的 (3)1.2实习任务要求 (3)二、实习单位（岗位）简介 (4)2.1实习时间 (4)2.2实习单位（岗位）简介 (4)三、实习内容 (5)3.1熟悉工作流程与工作程序 (5)3.2培养工作实践能力和基本人际关系处理能力 (6)3.3强化岗位专业知识的理解与运用能力 (6)四、实习心得体会 (7)4.1人生角色的转变 (7)4.2个人能力的提高 (7)4.3人际关系的拓展 (7)五、实习总结 (8)5.1实践是检验真理的标准 (8)5.2团队，个人成长的催化剂 (8)5.3良好的心态是学习工作中的基石 (9)5.4学无止境，贵在坚持 (9)前言毕业实习是大学教育最后一个极为重要的实践性教学环节。

通过实习，一方面，使自己接触实际，了解社会，增强劳动观点和事业心、责任感；第二方面，使自己在社会实践中接触与本专业相关的实际工作，增强感性认识，培养和锻炼综合运用所学的基础理论、基本技能和专业知识，提高独立分析和解决实际问题的能力，把理论和实践结合起来，提高实践动手能力，为自己毕业后走上工作岗位打下一定的基础；第三方面，通过实习还可以检验学习效果，为进一步提高教育学习质量，培养个人能力积累经验。

一、实习目的及任务1.1实习目的通过实习实践，能系统运用所掌握的经济、管理、法规等知识，在实习单位的生产、经营、管理和商贸等实践活动中，通过不断学习与训练，掌握一定的实践知识与技能，并对生产、经营及人际沟通有一定的切身体验，以期培养独立思考、工作的能力，使自己成为适应社会需要的合格的理学专业人才。

1.2实习任务要求1.2.1 巩固和掌握运用理学基本理论、基本方法和基本技能；1.2.2熟悉所在实习单位的工作流程与工作程序；。

天津理工大学_操作系统_存储器的分配与回收算法实现_实验报告

实验报告学院（系）名称：计算机与通信工程学院【实验过程记录（源程序、测试用例、测试结果及心得体会等）】源程序:MemoryBlock.java://内存块类，包含各种操作public class MemoryBlock {static final int BLOCK_SIZE = 4096;private int baseBlock; //内存块基地址private int blockNum; //大小private boolean inUse; //是否已分配private MemoryBlock prev, next;public MemoryBlock(int blockNum) {this.baseBlock = 0;this.blockNum = blockNum;inUse = false;prev = null;next = null;}public MemoryBlock(int base, int blockNum) {this.baseBlock = base;this.blockNum = blockNum;inUse = false;prev = null;next = null;}public int getBlockNum() {return blockNum;}public void setBlockNum(int blockNum) {this.blockNum = blockNum;}public MemoryBlock getPrev() {return prev;}public void setPrev(MemoryBlock prev) {this.prev = prev;public MemoryBlock getNext() {return next;}public void setNext(MemoryBlock next) {this.next = next;}public boolean inUse() {return inUse;}public void setUse() {inUse = true;}public void free() {inUse = false;}public int getBaseBlock() {return baseBlock;}public void setBaseBlock(int baseBlock) { this.baseBlock = baseBlock;}//分配内存块，如果可分配，则返回剩余内存块public MemoryBlock allocate(int blockNum) { if(this.blockNum - blockNum>0) {int newBase = baseBlock + blockNum;int newBlock = this.blockNum-blockNum;this.blockNum = blockNum;setUse();return new MemoryBlock(newBase, newBlock);}else if(this.blockNum - blockNum ==0) {this.blockNum = 0;}return null;}//判断内存块是否能合并public boolean merge(MemoryBlock memBlock) {if(baseBlock+blockNum==memBlock.getBaseBlock()) {setBlockNum(blockNum+memBlock.blockNum);memBlock.setBaseBlock(0);memBlock.setBlockNum(0);return true;}elsereturn false;}@Overridepublic String toString() {String inUse = null;if(inUse())inUse = "已分配";else inUse = "未分配";return"内存块 [基地址=" + baseBlock + ", 大小=" + blockNum +", " + inUse + "]";}}MemoryTable.java://虚类MemTable，提供内存链表的各种基本方法public abstract class MemoryTable {//MemoryBlock链表表头protected MemoryBlock memList;public MemoryTable(int blockNum) {memList = new MemoryBlock(0, blockNum);}//把newBlock插入到memBlock前面public void insertBefore(MemoryBlock memBlock, MemoryBlock newBlock){if(memBlock.getPrev() != null)memBlock.getPrev().setNext(newBlock);if(memList == memBlock)memList = newBlock;newBlock.setPrev(memBlock.getPrev());newBlock.setNext(memBlock);memBlock.setPrev(newBlock);}//在memBlock后插入newBlockpublic void insert(MemoryBlock memBlock, MemoryBlock newBlock) { if(memBlock.getNext() != null)memBlock.getNext().setPrev(newBlock);newBlock.setNext(memBlock.getNext());memBlock.setNext(newBlock);newBlock.setPrev(memBlock);}//删除块的连接关系，但不释放块public void remove(MemoryBlock memBlock) {if(memBlock == memList)memList = memBlock.getNext();if(memBlock.getNext()!=null)memBlock.getNext().setPrev(memBlock.getPrev());if(memBlock.getPrev()!=null)memBlock.getPrev().setNext(memBlock.getNext());}public void print() {MemoryBlock memBlock = memList;int i=0;while(memBlock != null) {System.out.print(i+" ");System.out.println(memBlock);i++;memBlock = memBlock.getNext();}}//合并邻接的空闲内存public void merge(MemoryBlock newBlock) {MemoryBlock memBlock = memList;while(memBlock != null) {if(!memBlock.inUse()) {if(memBlock.merge(newBlock)) {memBlock.setBlockNum( memBlock.getBlockNum() +newBlock.getBlockNum());remove(newBlock);break;}if(newBlock.merge(memBlock)) {newBlock.setBlockNum( newBlock.getBlockNum() + memBlock.getBlockNum());break;}}memBlock = memBlock.getNext();}}//分配内存（抽象函数）public abstract boolean allocate(int blockNum);//释放内存（抽象函数）public abstract boolean free(int baseBlock);}FirstFit.java:public class FirstFit extends MemoryTable{public FirstFit(int blockNum) {super(blockNum);}@Overridepublic boolean allocate(int blockNum) {MemoryBlock memBlock = memList;while(memBlock!=null) {if(!memBlock.inUse()) {if(memBlock.getBlockNum()>blockNum) {MemoryBlock newBlock = memBlock.allocate(blockNum);insert(memBlock, newBlock);return true;}else if(memBlock.getBlockNum()==blockNum) {memBlock.setUse();}}memBlock = memBlock.getNext();}return false;}//分配内存（类内使用）void freeMemory(MemoryBlock freeBlock) {MemoryBlock prev = freeBlock.getPrev();MemoryBlock next = freeBlock.getNext();freeBlock.free();while(!prev.inUse() && (prev.merge(freeBlock))) {prev.setBlockNum( prev.getBlockNum() +freeBlock.getBlockNum());remove(freeBlock);freeBlock = prev;if(freeBlock.getPrev()!=null)prev = freeBlock.getPrev();else return;}}if(freeBlock.getNext()!=null) {while(!next.inUse() && (freeBlock.merge(next))) {freeBlock.setBlockNum ( next.getBlockNum() +freeBlock.getBlockNum());remove(next);freeBlock = next;if(freeBlock.getNext()!=null)next = freeBlock.getNext();else return;}}}@Overridepublic boolean free(int baseBlock) {MemoryBlock memBlock = memList;while(memBlock != null) {if(memBlock.getBaseBlock() == baseBlock) {freeMemory(memBlock);return true;}memBlock = memBlock.getNext();}return false;}}BestFit.java:public class BestFit extends MemoryTable {private MemoryBlock usedMemory;public BestFit(int blockNum) {super(blockNum);usedMemory = null;}@Overridepublic boolean allocate(int blockNum) {MemoryBlock memBlock = memList;MemoryBlock minBlock = null;for(;memBlock!=null; memBlock = memBlock.getNext()) { if(!memBlock.inUse()&&(memBlock.getBlockNum()>=blockNum)) { minBlock = memBlock;break;}}if(minBlock != null) {remove(minBlock);if(minBlock.getBlockNum()!=blockNum) {MemoryBlock newBlock = minBlock.allocate(blockNum);insertUnused(newBlock);}insertUsed(minBlock);return true;}elsereturn false;}boolean freeMemory(MemoryBlock freeBlock) {if(freeBlock != null) {freeBlock.free();removeUsed(freeBlock);insertUnused(freeBlock);return true;}return false;}@Overridepublic boolean free(int baseBlock) {MemoryBlock memBlock = usedMemory;while(memBlock != null) {if(memBlock.getBaseBlock() == baseBlock) {freeMemory(memBlock);merge(memBlock);return true;}memBlock = memBlock.getNext();return false;}//在已分配链表删除public void removeUsed(MemoryBlock memBlock) {if(memBlock == usedMemory)usedMemory = memBlock.getNext();if(memBlock.getNext()!=null)memBlock.getNext().setPrev(memBlock.getPrev());if(memBlock.getPrev()!=null)memBlock.getPrev().setNext(memBlock.getNext());}//插入未分配链表void insertUnused(MemoryBlock newBlock) {if(memList == null)memList = newBlock;else {MemoryBlock memBlock = memList;MemoryBlock preBlock = null;while(memBlock!=null) {if(newBlock.getBlockNum()<=memBlock.getBlockNum()) { insertBefore(memBlock, newBlock);return;}preBlock = memBlock;memBlock = memBlock.getNext();}insert(preBlock, newBlock);}}//插入已分配链表void insertUsed(MemoryBlock newBlock) {if(usedMemory == null)usedMemory = newBlock;else {MemoryBlock memBlock = usedMemory;while(memBlock.getNext() != null)memBlock = memBlock.getNext();memBlock.setNext(newBlock);newBlock.setPrev(memBlock);}}public void print() {super.print();MemoryBlock memBlock = usedMemory;int i=0;while(memBlock != null) {System.out.print(i+" ");System.out.println(memBlock);i++;memBlock = memBlock.getNext();}}}WorstFit.java:public class WorstFit extends MemoryTable {//已分配链表private MemoryBlock usedMemory;public WorstFit(int blockNum) {super(blockNum);usedMemory = null;}@Overridepublic boolean allocate(int blockNum) {MemoryBlock maxBlock = memList;if(maxBlock.getBlockNum()<blockNum)return false;remove(maxBlock);if(maxBlock.getBlockNum()!=blockNum) {MemoryBlock newBlock = maxBlock.allocate(blockNum);insertUnused(newBlock);}insertUsed(maxBlock);return true;}boolean freeMemory(MemoryBlock freeBlock) {if(freeBlock != null) {freeBlock.free();removeUsed(freeBlock);insertUnused(freeBlock);}return false;}@Overridepublic boolean free(int baseBlock) {//已分配链表MemoryBlock memBlock = usedMemory;while(memBlock != null) {if(memBlock.getBaseBlock() == baseBlock) {freeMemory(memBlock);merge(memBlock);return true;}memBlock = memBlock.getNext();}return false;}public void removeUsed(MemoryBlock memBlock) {if(memBlock == usedMemory)usedMemory = memBlock.getNext();if(memBlock.getNext()!=null)memBlock.getNext().setPrev(memBlock.getPrev());if(memBlock.getPrev()!=null)memBlock.getPrev().setNext(memBlock.getNext());}void insertUnused(MemoryBlock newBlock) {if(memList == null)memList = newBlock;else {MemoryBlock memBlock = memList;MemoryBlock preBlock = null;while(memBlock!=null) {if(newBlock.getBlockNum()>=memBlock.getBlockNum()) { insertBefore(memBlock, newBlock);return;}preBlock = memBlock;memBlock = memBlock.getNext();}insert(preBlock, newBlock);}}void insertUsed(MemoryBlock newBlock) {if(usedMemory == null)usedMemory = newBlock;else {MemoryBlock memBlock = usedMemory;while(memBlock.getNext() != null)memBlock = memBlock.getNext();memBlock.setNext(newBlock);newBlock.setPrev(memBlock);}}public void print() {super.print();MemoryBlock memBlock = usedMemory;int i=0;while(memBlock != null) {System.out.print(i+" ");System.out.println(memBlock);i++;memBlock = memBlock.getNext();}}}测试用例:Main.java:public class Main {public static void main(String[] args) {testFirstFit();System.out.println();testBestFit();System.out.println();testWorstFit();}public static void testFirstFit() {MemoryTable mem = new FirstFit(1024);System.out.println("测试首次适应法:");mem.allocate(512);mem.allocate(256);mem.allocate(128);mem.print();mem.free(512);mem.free(768);mem.print();}public static void testBestFit() {MemoryTable mem = new BestFit(1024);System.out.println("测试最佳适应法:");mem.allocate(1);mem.allocate(2);mem.allocate(3);mem.print();mem.free(0);mem.free(1);mem.print();}public static void testWorstFit() {MemoryTable mem = new WorstFit(1024);System.out.println("测试最坏适应法:");mem.allocate(1);mem.allocate(2);mem.allocate(3);mem.print();mem.free(0);mem.free(3);mem.print();}}测试结果:测试首次适应法:分配 512 内存分配 256 内存分配 128 内存内存单元:0 内存块 [基地址=0, 大小=512, 已分配]1 内存块 [基地址=512, 大小=256, 已分配]2 内存块 [基地址=768, 大小=128, 已分配]3 内存块 [基地址=896, 大小=128, 未分配]释放 512 处内存释放 768 处内存内存单元:0 内存块 [基地址=0, 大小=512, 已分配]1 内存块 [基地址=512, 大小=512, 未分配]测试最佳适应法:分配 1 内存分配 2 内存分配 3 内存内存单元:0 内存块 [基地址=6, 大小=1018, 未分配]0 内存块 [基地址=0, 大小=1, 已分配]1 内存块 [基地址=1, 大小=2, 已分配]2 内存块 [基地址=3, 大小=3, 已分配]释放 0 处内存释放 1 处内存内存单元:0 内存块 [基地址=0, 大小=3, 未分配]1 内存块 [基地址=6, 大小=1018, 未分配]0 内存块 [基地址=3, 大小=3, 已分配]测试最坏适应法:分配 1 内存分配 2 内存分配 3 内存内存单元:0 内存块 [基地址=6, 大小=1018, 未分配]0 内存块 [基地址=0, 大小=1, 已分配]1 内存块 [基地址=1, 大小=2, 已分配]2 内存块 [基地址=3, 大小=3, 已分配]释放 0 处内存释放 3 处内存内存单元:0 内存块 [基地址=3, 大小=1021, 未分配]1 内存块 [基地址=0, 大小=1, 未分配]0 内存块 [基地址=1, 大小=2, 已分配]心得体会:1.使用类来进行一些方法的重用2.释放内存时，根据不同的分配方法进行相邻的内存合并3.链表应根据具体情况优化从而简化代码。

天津理工大学编译原理实验2语法分析

天津理工大学编译原理实验2语法分析实验报告学院(系)名称:计算机与通信工程学院姓名学号专业班级实验项目实验二:语法分析课程名称编译原理课程代码2016年4月21日第1、2节实验时间 2016年4月26日第3、4节实验地点计算机软件实验室7-220 2016年4月28日第1、2节批改意见成绩教师签字: 实验内容:可选择LL1分析法、算符优先分析法、LR分析法之一，实现如下表达式文法的语法分析器:(1)E?E+T | E-T | T(2)T?T*F | T/F | F(3)F?P^F | P(4)P?(E) | i实验目的:1(掌握语法分析的基本概念和基本方法;2(正确理解LL1分析法、算符优先分析法、LR分析法的设计与使用方法。

实验要求:1(按要求设计实现能识别上述文法所表示语言的语法分析器，并要求输出全部分析过程;2(要求详细描述所选分析方法针对上述文法的分析表构造过程;3(完成对所设计语法分析器的功能测试，并给出测试数据和实验结果;4(为增加程序可读性，请在程序中进行适当注释说明;5(整理上机步骤，总结经验和体会;6(认真完成并按时提交实验报告。

第1页共13页【实验过程记录(源程序、测试用例、测试结果及心得体会等)】使用的是LL(1)分析法，其分析表的构造方法和构造过程如下: 实验源代码: #include<iostream>#include<cstring>#define size 1024using namespace std;int getLength(char str[size]) {int i=0;while(str[i]!='\0')i++;return i;}int getstringLength(string str) {int i=0;while(str[i]!='\0')i++;return i;}char gettop(char stack[size],int top) {if(stack[top]!='\0')return stack[top];elsereturn '#';}void popstack(char *stack,int *pointer){int p=*pointer;cout<<"\tPopup "<<stack[p]<<" out!";stack[p]='\0';(*pointer)--;}void pushstack(char *stack,int *pointer,string str) {int i=0;int length=getstringLength(str);cout<<" push "<<str<<" in stack reversed order."; for(i=length-1;i>=0;i--){(*pointer)++;第2页共13页stack[(*pointer)]=str[i];}}int getcol(char top) {switch(top){case '+':return 0;case '-':return 1;case '*':return 2;case '/':return 3;case '^':return 4;case ')':return 5;case '#':return 6;case '(':return 7;case 'i':return 8;default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return -1;}}void show(char str[size],int index){int length=getLength(str);if(index!=-1)cout<<"\t";for(int i=index+1;i<length;i++)cout<<str[i]; }int main(){char str[size];//接受字符串的数组char stack[size];//进行比对的栈int pointer=-1;//指向栈顶的指针int length=0;//记录字符串长度int index=0;//记录输入字符串第3页共13页char top;int i,j;//i表示行，j表示列string production;bool match=false;string table[7][9]={ // + - * / ^ ) # ( i/* E */ "error", "error", "error", "error", "error", "error", "error", "TX", "TX",/* X */ "+TX", "-TX", "error", "error", "error", "empty", "empty", "error", "error",/* T */ "error","error","error","error","error","error","error","FY","FY", /* Y */"empty","empty","*FY","/FY","error","empty","empty","error","error", /* F */ "error","error","error","error","error","error","error","PZ","PZ", /* Z */"empty","empty","empty","empty","^F","empty","empty","error","error", /* P */ "error","error","error","error","error","error","error","(E)","i"};cout<<"Please input character string: ";cin>>str;length=getLength(str);str[length]='#';str[length+1]='\0';// cout<<length<<endl;// cout<<table[0][0]; //已验证可以实现cout<<"符号栈\t当前符号\t输入串\t\t\t\t说明"<<endl;pointer++;stack[pointer]='#';pointer++;stack[pointer]='E';//初始化栈，使栈底是 #Ewhile(str[index]!='\0'){top=gettop(stack,pointer);switch(top){case 'E':i=0;//第1行j=getcol(str[index]);production=table[i][j];if(production=="error"){cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}else if(production=="empty"){cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);第4页共13页}else //说明可以进行分解非终结符{cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);pushstack(stack,&pointer,production);}break;case 'X':i=1;//第2行j=getcol(str[index]);production=table[i][j];if(production=="error"){cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}else if(production=="empty"){cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);}else //说明可以进行分解非终结符{cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);pushstack(stack,&pointer,production); }break;case 'T':i=2;//第3行j=getcol(str[index]);production=table[i][j];if(production=="error"){cout<<"Error! This character string is not this grammer`s sentence."<<endl;第5页共13页return 0;}else if(production=="empty"){cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);}else //说明可以进行分解非终结符{cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);pushstack(stack,&pointer,production);}break;case 'Y':i=3;//第4行j=getcol(str[index]);production=table[i][j];if(production=="error"){cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}else if(production=="empty"){cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);}else //说明可以进行分解非终结符{cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);pushstack(stack,&pointer,production);第6页共13页}break;case 'F':i=4;//第5行j=getcol(str[index]);production=table[i][j];if(production=="error"){cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}else if(production=="empty"){cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);}else //说明可以进行分解非终结符{cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);pushstack(stack,&pointer,production);}break;case 'Z':i=5;//第6行j=getcol(str[index]);production=table[i][j];if(production=="error"){cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}else if(production=="empty"){cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);第7页共13页}else //说明可以进行分解非终结符{cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);pushstack(stack,&pointer,production);}break;case 'P':i=6;//第7行j=getcol(str[index]);production=table[i][j];if(production=="error"){cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}else if(production=="empty"){cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);}else //说明可以进行分解非终结符{cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);popstack(stack,&pointer);pushstack(stack,&pointer,production); }break;case '+':switch(str[index]){case '+':cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";第8页共13页show(str,index);cout<<"\tMatch + ! ";//" Popup + and next char in."<<endl;popstack(stack,&pointer);match=true;break;default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}break;case '-':switch(str[index]){case '-':cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);cout<<"\tMatch - ! ";//Popup - and next char in."<<endl;popstack(stack,&pointer);match=true;break;default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}break;case '*':switch(str[index]){case '*':cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);cout<<"\tMatch * ! ";//Popup * and next char in."<<endl;popstack(stack,&pointer);match=true;break;default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}break;case '/':第9页共13页switch(str[index]){case '/':cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);cout<<"\tMatch / ! ";//Popup / and next char in."<<endl;popstack(stack,&pointer);match=true;break;default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}break;case '(':switch(str[index]){case '(':cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);cout<<"\tMatch ( ! ";//Popup ( and next char in."<<endl;popstack(stack,&pointer);match=true;break;default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}break;case ')':switch(str[index]){case ')':cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);cout<<"\tMatch ) ! ";//Popup ) and next char in."<<endl;popstack(stack,&pointer);match=true;break;第10页共13页default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}break;case '^':switch(str[index]){case '^':cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);cout<<"\tMatch ^ ! ";//Popup ^ and next char in."<<endl;popstack(stack,&pointer);match=true;break;default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}break;case 'i':switch(str[index]){case 'i':cout<<"\n";show(stack,-1);cout<<"\t"<<str[index]<<"\t";show(str,index);cout<<"\tMatch i ! ";//Popup i and next char in."<<endl;popstack(stack,&pointer);match=true;break;default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}break;case '#':switch(str[index]){case '#':cout<<"\n";show(stack,-1);第11页共13页cout<<"\t"<<str[index]<<"\t";show(str,index);cout<<"\tMatch # ! 分析成功～";//Popup # and next char in."<<endl;return 0;default:cout<<"Error! This character string is not this grammer`s sentence."<<endl;return 0;}break;}if(match){index++;match=false;}}return 0;}实验代码测试结果:下面图片是以给定文法画出的一个语法树。

天津理工大学数据结构实验报告3

实验（三）实验名称二叉树的遍历软件环境 Windows98/2000, VC++6.0或turbo C硬件环境PⅡ以上微型计算机实验目的　理解二叉树的逻辑特点，掌握二叉链表存储结构，掌握二茬树遍历算法的递归与非递归实现实验内容（应包括实验题目、实验要求、实验任务等）二叉树的遍历利用二叉链表作为存储结构建立一棵二叉树，每个结点中存放一种水果名(例如apple、orange、banana等，并要求从键盘输入)，结点数不少于5个。

要求分别以先序、中序和后序进行遍历，输出遍历结果。

并编写一递归算法，交换该二叉树中所有结点的左、右孩子。

实验过程与实验结果（可包括实验实施的步骤、算法描述、流程、结论等）实验步骤及算法描述和流程：1. 创建二叉链表的结点存储结构及数据的输入输出函数因为每个结点所存储的数据类型为字符串，却无法使用字符串和String等数据类型，所以使用单链表作为结点所存储的数据类型。

1.1 数据的输入函数indata( )当输入的字符不为'0'时，以尾插法将数据插入单链表。

1.2 数据的输出函数直接输出单链表。

2. 生成二叉链表利用先序遍历生成二叉链表：2.1 用单链表s记录输入的数据2.2 若单链表s为空，则二叉链表结点为空，否则根节点=s，利用递归调用分别生成根节点的左子树和右子树2.3 返回二叉链表3. 先序遍历、中序遍历、后序遍历二叉链表3.1 先序遍历：访问根节点，左子树，右子树的顺序3.2 中序遍历：访问左子树，根节点，右子树的顺序3.3 后序遍历：访问左子树，右子树，根节点的顺序利用递归调用分别用以上三种顺序遍历二叉链表。

4. 交换二叉链表的左右孩子当二叉链表的结点左孩子或者右孩子都不为空时，利用递归调用，分别交换左子树很右孩子的左右孩子，最后将根节点的左右孩子指针交换。

5. 主函数5.1 调用生成二叉链表的函数，从键盘输入二叉链表的各个结点5.2 分别调用先序遍历、中序遍历、后序遍历二叉链表函数，输出所有结点5.3 交换二叉链表的左右孩子5.4 重复5.2结论：输入各个结点：apple、pear、orange、banana、peach、grape、watermelon 先序遍历输入与输入一致中序遍历输出：orange、pear、banana、apple、grape、peach、watermelon 后序遍历输出：orange、banana、pear、grape、watermelon、peach、apple 交换二叉树的左右孩子后先序遍历输出：apple、peach、watermelon、grape、pear、banana、orange编程中出现的问题：输入的二叉链表左右子树必须对称，如果不对称，交换二叉树的左右子树后，程序出错，不知道出错在哪，没有调试成功。

天津理工大学数据结构实验报告5

计算机科学与工程系计算机科学与工程系附录（可包括源程序清单或其它说明）#include<iostream>#include <stdio.h>using namespace std;typedef struct BiTNode{ //二叉链表节点存储结构int data;struct BiTNode *lchild;struct BiTNode *rchild; //左右孩子指针}BiTNode,*BiTree;void insert(BiTree &T,int k){ //二叉排序树的递归算法if(T==NULL){T=(BiTree)malloc(sizeof(BiTNode));T->data=k;T->lchild=T->rchild=NULL;}else if(k<T->data) insert(T->lchild,k);else if(k>T->data) insert(T->rchild,k);}void createBST(BiTree &T,int n){ //二叉排序树的建立T=NULL;int k;for(int i=1;i<=n;i++){cin>>k; //输入关键字insert(T,k);}}void InOrder(BiTree root){ //中序遍历二叉树排序树if(root==NULL) return;int t=root->data,k=1;InOrder(root->lchild);cout<<root->data<<" ";if(root->data<t) //判断是否为有序序列cout<<"不";InOrder(root->rchild);}void main(){BiTree T;int n;cout<<"请输入一组整数的长度n=";cin>>n;cout<<"请输入"<<n<<"个整数"<<endl;createBST(T,n);InOrder(T);cout<<"是递增有序序列！"<<endl;}运行结果：计算机科学与工程系天津理工大学计算机科学与工程系实验报告2011 至2012 学年第二学期课程名称数据结构学号学生姓名胡硕瑶年级2010专业网络工程教学班号 2 实验地点7-219 7-215实验时间2012 年 5 月日第 3 节至第 4 节主讲教师董玉涛辅导教师。

实验分析报告模板--信息安全综合实验

实验报告模板--信息安全综合实验————————————————————————————————作者：————————————————————————————————日期：2信息安全综合实验实验报告专业: 信息安全班级:信息安全2班小组成员：韩非寒（20102033）指导教师：唐召东、赵春蕾职称：讲师天津理工大学计算机与通信工程学院2014年5 月天津设计日期 2014 年 5月11 日至 2014年5月25日小组成员在本次设计中承担的任务成绩指导教师签字：年月日目录前言 (2)实验一网络通信安全 (3)▪1.1 实验概述3▪1.2 实验原理3▪1.3 实验结果以及分析16▪1.4实验小结201前言为了提高学生的动手能力，培养同学们的学习兴趣，同时对所学知识进行全面的复习，特在第7学期开设本课程。

《信息安全专业综合实践》是信息安全专业的集中性实践环节课程。

本课程的任务是训练学生综合利用所学理论知识和实践技能解决实际问题，提高学生独立钻研及团队合作能力，为适应今后的工作打下扎实的基础。

通过该课程实践，使学生能够利用密码学知识实现通信系统的机密性、完整性；能够评估系统的安全性，能够利用弱点攻破远程系统，能够有效地防御远程攻击；对Web服务、Email 服务能够熟练地管理和配置，增强系统的安全性；能够综合利用认证、授权、访问控制设计一个安全、高效的信息系统。

23实验一网络通信安全▪ 1.1 实验概述本实验应用DES ，RSA ，MD5等加密算法，以及Socket 套接字实现一个简单的加密解密的聊天工具CryptTalk 。

本实验的程序在jdk1.6与Eclipse 开发环境下编写，基本实现了消息加密的聊天工具的功能。

通信的步骤基本如下：首先，服务器端随机产生一对RSA 密钥，将公钥发送给客户端，客户端将自己的对称密钥用公钥加密发送给服务器端，服务器端接收到加密后的密钥后，用自己的私钥解密得到对称密钥。

计算机网络实验三：协议分析

天津理工大学实验报告学院（系）名称：计算机与通信工程学院6.列举出你所抓到数据包的种类（协议名称）。

列表写出客户端、网关、web服务器的IP地址和MAC地址。

HTTP客户端和服务器段的端口号。

答：数据包的种类TCP、UDP、DNS、DHCP、ARP、OSPF、LLDP、SSL、TLS、NBNS、BROWSER=等。

客户端网关Web服务器IP地址101.4.60.122 202.113.78.31 202.113.78.39MAC地址58:6a:b1:5d:be:33 44:37:e6:04:08:9f 44:37:e6:04:09:c5HTTP客户端的端口号：80，服务器端口号：2518。

7.将TCP、IP、ARP、DNS、HTTP和Ethernet的首部字段的名字和值按照协议的格式（参见附录2）分别记录下来。

（任意打开一个消息）答：IP：版本：4 首部长度：20bytes 区分服务：0x00 总长度：40 标识:0x41c6 标志:0x02 片偏移:0生存时间:51 协议:TCP（6）首部校验和:0x4bfb源地址:101.4.60.122目的地址:202.113.78.31可选字段: 填充TCP:源端口：80 目的端口：2518序号：1确认号：716数据偏移保留URG0 ACK1PSHRSISYNFIN窗口：16128检验和0xf2e5 紧急指针: 无效选项:空填充：空ARP:以太网目的地址：HonHaiPr_04:08:9f (44:37:e6:04:08:9f) 以太网源地址：HonHaiPr_04:09:c5(44:37:e6:04:09:c5)帧类型：ARP(0x0806)DNS:标识：0xa632 标志：0x8180问题数：1 资源记录数：3授权资源记录数：0 额外资源记录数：0 查询问题：:type A,class IN回答：:type CNAME,class IN,cname :type A,class IN, addr 101.4.60.122:type A,class IN, addr 101.4.60.121额外授权：0记录信息：0HTTP:版本：1.1 空格状态码:200 空格原因短语：OK回车符换行符首部：nginx ：阈值：0.6.39回车符换行符实体：Date:Sat, 09 May 2015 07:58:02 GMT \r\nEthernet:目的地址：(58:6a:b1:5d:be:33 ) 源地址：(44:37:e6:04:08:9f)类型：IP 数据：769bytes FCS：0x08008.在wireshark界面上，设置抓包后的过滤条件为只显示IP地址包括web服务器地址的包（筛选格式类似“ip.addr eq 202.113.78.39”）。

天津理工大学计算机网络实验三

实验报告
学院（系）名称：计算机与通信工程学院
姓名学号专业
班级实验名称实验三：路由器配置
课程名称计算机网络课程代码
实验时间实验地点7#219批改意见成绩
教师签字：
1.实验目的
理解路由器工作原理和配置方法，掌握路由器的接线方法，登录方式，静态路由和动态路由的配置。

2.实验环境
Windows
3.实验要求
进行网络地址规划，配置路由器；检查路由器配置。

掌握路由协议的种类和特点。

掌握静态路由、默认路由的配置方法。

掌握查看路由条目的方法。

并验证路由的作用。

4.实验过程记录（源程序、测试用例、测试结果及心得体会等）
（1）静态路由：
配置路由器 1 和各个端口 ip：
验证：
（2）Rip 路由配置路由器 1：
验证：
（3）Ospf 路由验证：
心得体会：
通过此次实验，我不仅学会了配置静态、动态路由的方法，还掌握了查看路由条目的方法、验证路由的作用，收获颇多。

【本文档内容可以自由复制内容或自由编辑修改内容期待
你的好评和关注，我们将会做得更好】。

约瑟夫环问题实验报告

}
//报数为m的人出列
while(n--)
{
for(int s=m-1; s--; r=p, p = p->link);
cout << "The output is: " << p->data << endl;
r->link = p->link;
LinkList d = new LNode;
if(!d)
二、实验问题描述
设编号为1，2，···，n的n个人围坐一圈，约定编号为k（1≤k≤n）的人从1开始报数，数到m的那个人出列，他的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
3、实验步骤
1、实验问题分析
①由于当某个人退出圆圈后，报数的工作要从下一个人开始继续，剩下的人仍要是围成一个圆圈，可以使用循环表；由于退出圆圈的工作对应着表中结点的删除操作，对于这种删除操作频繁的情况，应该选用效率较高的链表结构；为了程序指针每一次都指向一个具体的代表一个人的结点而不需要进行判断，链表不带表头结点。所以，对于所有人围成的圆圈所对对应的数据结构采用一个不带头结点的循环链表来描述。设头指针为p，并根据具体情况移动
可以采用数据类型定义： Typedef struct node {
int number;
struct node *next; }Lnode,*Linklist;
②为了记录退出的人的先后顺序，采用一个顺序表进行存储，程序结束后再输入依次退出的人的编号顺序。由于只记录各个结点的number值就可以，所以定义一个整型一维数组。如“int quite[N];”N为一个根据实际问题定义的一个足够大的整数。

方向图函数

均匀线阵的方向图函数计算机与通信工程学院信号与信息处理徐弘扬智能天线通过调节各阵元信号的加权幅度和相位来改变阵列的方向图形状，即只适应或以预制方式控制波束幅度、指向和零点位置，使波束总是指向期望方向，而零点指向干扰方向，实现波束随用户走。

阵列的方向图定义为阵列输出的绝对值与来波方向之间的关系。

而静态方向图是指不考虑信号及其来向，由阵列的输出直接相加得到的。

本实验主要研究阵列的静态方向图。

实验原理：由方向图乘积定理：),(),(),(Φ⨯Φ=ΦθθθS F F e 其中F 为方向图因子，e F 为单元因子，S 为阵因子。

由于单元因子值表示构成阵列天线每个单元的辐射特性，仅取决于单元的形式及取向，与阵的组织方式无关，即e F 与S 是相互独立的。

可对e F 和S 单独进行研究，此处进行S 的讨论时可假想为各向同性单元（e F =1）组成的阵列的方向图函数。

均匀线阵的阵因子为：)2/sin()2/sin()(0u Nu I u S =归一化阵因子为:)2/sin()2/sin()()(0u N Mu N I u S u s ==方向图函数：)2/sin()2/sin()(ββθN N G =，其中θλπβsin 2d =对于静态方向图主瓣的零点，由0)(20=θG 可以得到零点波束宽度0BW 为)arcsin(20NdBW λ=对于静态方向图主瓣的半功率点，由5.0)(20=θG 可以得到半功率点波束宽度5.0BW 为 rad DBW λ89.05.0≈试验分析：一．方向图函数clear; close all ; N=8;sita=-pi/2:0.01:pi/2;d=1; %天线间距 lamda=2; %波长 b=(2*pi*d*sin(sita))./lamda; %空间频率 G=abs(sin(N*b/2)./(N*sin(b/2))); %静态方向图 plot(sita,G);grid;title('静态方向图')结果图静态方向图二．讨论N值对波束的影响clear;close all;N=8;N1=5;N2=16;sita=-pi/2:0.01:pi/2;d=1; %天线间距lamda=2; %波长b=(2*pi*d*sin(sita))./lamda; %空间频率G=abs(sin(N*b/2)./(N*sin(b/2))); %静态方向图G1=abs(sin(N1*b/2)./(N1*sin(b/2)));G2=abs(sin(N2*b/2)./(N2*sin(b/2)));plot(sita,G);grid;title('静态方向图')hold onplot(sita,G1,'r:')hold onplot(sita,G2,'g--')hold offlegend('N=8','N=5','N=16');结果图：静态方向图由图中的结果可以看出，当N值越大（即阵元数越多）方向图主瓣宽度越窄，零点波束宽度和3DB波束宽度也越窄，主副瓣的衰减程度也越大，即天线数越多阵列天线的波束指向性越好。

天津理工大学Java实验四实验报告

天津理工大学计算机科学与工程学院实验报告2017 至2018 学年第一学期课程名称Java语言程序设计学号学生姓名年级专业计算机科学与技术教学班号实验地点7-220实验时间2017年12月4日第5节至第6节主讲教师董玉涛辅导教师董玉涛实验（四）实验名称打印机管理器模拟软件环境Windows 8.1，Java SE 9，JDK 8，Eclipse硬件环境PC机实验目的1.掌握线程创建的方法；2.掌握线程的基本控制方法；3.掌握线程间的同步控制方法；4.掌握Java多线程操作。

实验内容（应包括实验题目、实验要求、实验任务等）本实验要求你使用wait/notify和其他线程控制方法创建一个打印机管理器（printer manager）。

要求你创建几个并发线程产生打印作业，一个打印管理器线程处理这些作业。

下面是一个可能的输出结果：C: Print manager is starting up.C: Waiting on a job to print.P: Adding job 'Fred#1' to the queueC: Starting job 'Fred#1'P: Adding job 'Elizabeth#1' to the queueP: Adding job 'Simon#1' to the queueC: Completed job 'Fred#1'C: Starting job 'Elizabeth#1'P: Adding job 'Fred#2' to the queueP: Adding job 'Simon#2' to the queueC: Completed job 'Elizabeth#1'C: Starting job 'Simon#1'P: Adding job 'Fred#3' to the queueC: Completed job 'Simon#1'C: Starting job 'Fred#2'P: Adding job 'Elizabeth#2' to the queueP: Adding job 'Simon#3' to the queueC: Completed job 'Fred#2'C: Starting job 'Simon#2'C: Completed job 'Simon#2'C: Starting job 'Fred#3'P: Adding job 'Fred#4' to the queue C: Completed job 'Fred#3'C: Starting job 'Elizabeth#2'P: Adding job 'Fred#5' to the queue C: Completed job 'Elizabeth#2'C: Starting job 'Simon#3'P: Adding job 'Elizabeth#3' to the queue C: Completed job 'Simon#3'C: Starting job 'Fred#4'C: Completed job 'Fred#4'C: Starting job 'Fred#5'C: Completed job 'Fred#5'C: Starting job 'Elizabeth#3'C: Completed job 'Elizabeth#3'C: Waiting on a job to print.C: Print manager is halted.实验过程与实验结果（可包括实验实施的步骤、算法描述、流程、结论等）一、实验步骤与算法描述1、定义PrintJob类（1）基于上述UML类图定义PrintJob类，代表一个打印作业。

天津理工大学数据结构实验报告1

实验报告CreateLinklist(): 从键盘输入数据，创建单链表ContLinklist()：将前面建立的两个单链表首尾相连OutputLinklist()：输出显示单链表3）分析算法时间复杂度三、实验过程与实验结果1．一元稀疏多项式简单的计算器➢数据结构定义typedef struct PolyNode{float coef;int exp;struct PolyNode *next;}PolyNode;typedef PolyNode *Polynomial;➢算法设计思路简介用带头节点的单链表分别表示两个多项式L和p，同时新建一个链表N把两个多项式相加后的结果存放在N表中。

所有链表均按指数从小到大顺序排列。

链表N中的节点N1另外生成，把运算后的结果赋给N1，用尾部插入法将N1插入到链表N中，每次要将新节点N1插入到链表N尾部，因此给链表N声明一个尾指针N0始终指向链表N的尾节点。

操作完成，按要求输出。

➢算法描述：初始时，指针L1指向L链表的头节点，P1指向p链表的头结点，从头开始扫描两个相加多项式链表的表头节点，循环操作，直到其中一个单链表中的节点全部搜索结束为止。

比较指针L1和P1指向的指数，共有三种情况：（1）L1->exp==P1->exp；则两个多项式的系数相加减，得到的新和多项式节点插入到链表N中。

L1、P1指针后移；（2）L1->exp<P1->exp；则将该L1所指节点赋给N1插入到链表N中。

L1、P1指针后移；（3）L1->exp>P1->exp；则将该P1所指节点赋给N1插入到链表N中。

L1、P1指针后移。

➢算法的实现和测试结果：输入:L1: 5 3 6 5 6 7 0 0; L2: 2 3 3 5 4 7 0 0;输出：L1: 5x^3+6x^5+6x^7；L2: 2x^3+3x^5+4x^7；L1+L2: 7x^3+9x^5+10x^7；L1-L2: 3x^3+3x^5+2x^7➢算法时间复杂度分析该程序中建立单链表过程采用了单链表的后插入操作，其时间复杂度T(n)=O(1)；当两个多项式相加减的时候，设L, p多项式分别有m、n项，其算法时间复杂度T(n)=O(m+n)。

计算机网络实验四：路由器的配置

20.0.4.0/24 OSPF 10 3124 20.0.2.2 S2/0
127.0.0.0/8 Direct 0 0 127.0.0.1 InLoop0
127.0.0.1/32 Direct 0 0 127.0.0.1 InLoop0
接口信息：
[r1]display ip int b
*down: administratively down
(s): spoofing
Interface Physical Protocol IP Address Description
#
interface Serial2/0
link-protocol ppp
ip address 20.0.2.1 255.255.255.0
#
配置 OSPF:
#
ospf 1
area 0.0.0.0
network 0.0.0.0 255.255.255.255
#
路由表：
[r1]display ip routing-table
S1/0 down down unassigned Serial1/0...
S2/0 up up 20.0.2.1 Serial2/0...
测试连通性：
C:\Documents and Settings\stud>ping 20.0.5.2
Pinging 20.0.5.2 with 32 bytes of data:
（6）实验步骤：
1.设计并连接网络。
2.连接主机与路由器。
3.配置各个接口。
4.最后配置路由表。
配置RIP：
#
rip 1
version 2
network 0.0.0.0

天津理工大学Java实验四实验报告

天津理⼯⼤学Java实验四实验报告天津理⼯⼤学计算机科学与⼯程学院实验报告2017 ⾄2018 学年第⼀学期附录（源程序清单）// FullQueueException类package Ex;public class FullQueueException extends IndexOutOfBoundsException { private static final long serialVersionUID = 1L;String ERROR_INFO;FullQueueException(String s){this.ERROR_INFO = new String(s);}public String toString(){return "FullQueueException" + ERROR_INFO;}}// EmptyQueueException类String ERROR_INFO; EmptyQueueException(String s){this.ERROR_INFO = new String(s);}public String toString(){return "EmptyQueueException" + ERROR_INFO; }}// CircleQueue类import java.util.Arrays;public class CircleQueue{private int DEFAULT_SIZE = 5;private int capacity;private Object[] elementData;private int front = 0;private int rear = 0;public CircleQueue(){capacity = DEFAULT_SIZE;elementData = new Object[capacity];}public CircleQueue(T element){this();elementData[0] = element;rear++;}public CircleQueue(T element, int initSize){this.capacity = initSize;elementData = new Object[capacity];rear++;}public int size(){if (isEmpty()){return 0;}return rear > front ? rear - front : capacity - (front - rear);}public void addBack(T element) throws FullQueueException { if (rear == front && elementData[front] != null){throw new FullQueueException("队列已满的异常");}elementData[rear++] = element;rear = rear == capacity ? 0 : rear;}public T removeFront() throws EmptyQueueException{if (isEmpty()){throw new EmptyQueueException("空队列异常");T oldValue = (T) elementData[front];elementData[front++] = null;front = front == capacity ? 0 : front;return oldValue;}public T element() throws EmptyQueueException{if (isEmpty()) {throw new EmptyQueueException("空队列异常");}public boolean isEmpty(){// rear==front且rear处的元素为nullreturn rear == front && elementData[rear] == null; }public void clear(){Arrays.fill(elementData, null);front = 0;rear = 0;}}// PrintJob类public class PrintJob{private String jobName;private int pages;public PrintJob(String sjN, int spg){this.jobName = new String(sjN);this.pages = spg;}public String getName(){return this.jobName;}public int getPages(){return this.pages;}}import java.util.Queue;private int sizeOfJobs;private int numberOfJobs;private int delayBetweenJobs;private String producerName;private Thread PrintThread = null;public Producer(int ss, int sn, int sd, String spn, Thread t) {this.sizeOfJobs = ss;this.numberOfJobs = sn;this.delayBetweenJobs = sd;this.producerName = new String(spn);this.PrintThread = t;}public void run() {for (int i = 0; i < this.numberOfJobs; i++) {PrintJob pj = new PrintJob(this.producerName + " #" + i, this.sizeOfJobs); try {Printer.getInstance().addJob(pj);Thread.sleep(this.delayBetweenJobs);} catch (InterruptedException e) {e.printStackTrace();} catch (FullQueueException e) {System.out.println("⽆法添加打印任务启动Printer" + e);}}}}//Printer类public class Printer implements Runnable{static private CircleQueue printQueue = new CircleQueue();static private boolean stateIsRunning = true;private static final Printer PRNTR_ONL Y = new Printer();static private boolean whileend = false;public static Printer getInstance() {return PRNTR_ONL Y;}public synchronized void halt(){if (Printer.stateIsRunning) {System.out.println("C: Print manager is halted.");Printer.stateIsRunning = false;}}public void addJob(PrintJob job) throws FullQueueException, InterruptedException { synchronized (printQueue){try{this.printQueue.addBack(job);}catch (FullQueueException e){try{printQueue.notify();printQueue.wait();}catch (InterruptedException e1){e1.printStackTrace();}}}System.out.println("[1]P: Adding job " + job.getName() + " to the queue");}private PrintJob getJob() throws EmptyQueueException {PrintJob p = null;while (p == null && stateIsRunning) {try {p = this.printQueue.element();Printer.printQueue.removeFront();} catch (EmptyQueueException e) {try {printQueue.notifyAll();printQueue.wait(500);} catch (InterruptedException e1) {e1.printStackTrace();}System.out.println("C: Waiting on a job to print." + stateIsRunning);}}return p;}}public void run() {System.out.println("C: Print manager is starting up.");while (stateIsRunning) {PrintJob pjob = null;try {pjob = this.getJob();System.out.println("[2]C:Starting job " + pjob.getName()); Thread.sleep(500 * pjob.getPages());System.out.println("[3]C:Completed job " + pjob.getName());} catch (EmptyQueueException e) {break;} catch (InterruptedException e) {e.printStackTrace();}}}//TestPrinter类public class TestPrinter{public static void main(String[] args) {Printer PRNT_P = Printer.getInstance();Thread THRD_P = new Thread(PRNT_P);THRD_P.setPriority(10);Producer pd1 = new Producer(5, 2, 5, "A", THRD_P); Producer pd2 = new Producer(5, 2, 5, "B", THRD_P); Producer pd3 = new Producer(5, 3, 5, "C", THRD_P); Thread thrd_A = new Thread(pd1);Thread thrd_B = new Thread(pd2);Thread thrd_C = new Thread(pd3);thrd_A.start();thrd_B.start();thrd_C.start();THRD_P.start();try {thrd_A.join();thrd_B.join();thrd_C.join();计算机科学与⼯程系}catch (InterruptedException e1){e1.printStackTrace();}try{Thread.sleep(10000);}catch (InterruptedException e){e.printStackTrace();PRNT_P.halt(); }}。

[VIP专享]天津理工大学计算机项目管理实验报告

学院（系）名称：计算机与通信工程1.2设置成本信息—标准费率、加班费率、每次使用成本、生效日期的作用双击项目中的空格弹出对话框：在资源名称中输入“工时管理”，将缩写设置为“GSGL”，类型设置为“工时”2.材料资源的建立2.1设置材料标签和工时管理建立操作类似，建立一个“材料管理“的资源类型，将其类型设置为”材2.2设置材料资源成本信息在对话框中点击“成本“标签，弹出对话框设置相应的成本信息二：掌握资源的分配1.为任务分配资源的方法在“视图”菜单上，单击“甘特图”；在“任务名称”域中，选择要为其分配资源的任务；单击“分配资源”；在“资源名称”域中，单击要分配的资源的名称；在“请求/要求”列中，单击“请求”或“要求”指定是否需要将此资源分配给该任务；此资源设置用于“资源置换向导”；如果您请求了该资源，向导将仅在该资源未过度分配的条件下分配资源。

分配单个全职工时资源：确保所选资源的“单位”域显示为 100%，单击“分配”。

分配单个兼职工时资源：在“单位”域中，键入一个小于 100 的百分比。

该数值代表您希望该资源在该任务中花费的工作时间的百分比。

例如，如果资源将工作时间的一半用在此任务中，应键入“50%”，单击“分配”。

分配一组多个工时资源：在“单位”域中，键入一个大于 100 的百分比。

此值代表此资源组投入工作的程度。

例如，如果资源为操作人员，人数为三名，并且您要将他们全部指定为全职，应键入“300%”。

单击“分配”。

指定材料资源的消耗率：在“单位”域中，键入一个小数，表示用于该工作分配的材料数量，然后输入材料标签。

例如，若要用 20 码长的木材，可键入“20”。

如果所使用的材料数量取决于任务工期，可以通过添加斜线 (/) 以及工期代码或缩写输入使用率。

例如：如果每周要20 码长的木材，则输入“20/周”或“20/w”。

单击“分配”。

六：“报表”功能的使用在菜单中选择“视图“，选中下拉菜单中“报表”可以对“成本”进行相应的分析。

天津理工大学实验报告模板

天津理工大学数据结构实验报告4

天津理工大学数据结构实验报告1

天津理工大学理学专业实习总结报告范文模板

天津理工大学_操作系统_存储器的分配与回收算法实现_实验报告

天津理工大学编译原理实验2语法分析

天津理工大学数据结构实验报告3

天津理工大学数据结构实验报告5

实验分析报告模板--信息安全综合实验

计算机网络实验三：协议分析

天津理工大学计算机网络实验三

约瑟夫环问题实验报告

方向图函数

天津理工大学Java实验四实验报告

天津理工大学数据结构实验报告1

计算机网络实验四：路由器的配置

天津理工大学Java实验四实验报告

[VIP专享]天津理工大学计算机项目管理实验报告

最新天津理工大学机械专业生产实习报告