求教：长安铃木小羚羊的车怎么样本人想买辆，市场价格是多少(求数据结构哈夫曼编码译码器)

求教：长安铃木小羚羊的车怎么样本人想买辆，市场价格是多少 ♂

求教：长安铃木小羚羊的车怎么样本人想买辆，市场价格是多少

• 求教：长安铃木小羚羊的车怎么样本人想买辆，市场价格是多少
• 长安铃木车多少钱
• 2008年的低配长安铃木羚羊SC7135A二手车价格
• 我想买个车，长安铃木，羚羊的价格！
• 长安铃木 羚羊裸车 多少钱一辆啊
• 长安铃木新羚羊2009年价格

这样的车是经济试用型的。不知道你买这种车是做什么用，如果是家庭生活自用，我建议你买。这个车型的比重合适，动力也还行。就是刹车制动不怎么好这是这个价位的车普遍拥有的问题。不过老司机可以对付，新手小心驾驶就可以，别开快车。如果你是商用，我建议你买好一点的，做生意讲究门面，当今社会上有许多做生意的人，你看他开了一辆好车，但是也学他连一座楼房都没有，这个是场合必须。
这种车的市场价格在4~8万元不等，根据配置决定。

天语SX4 型号：天语SX4 1.6L手动基本型 价格：9.48万
型号：天语SX4 1.6L手动精英型 价格：10.58万
型号：天语SX4 1.6L自动精英型 价格：11.58万
型号：天语SX4 1.6L手动豪华型 价格：11.58万
型号：天语SX4 1.6L自动豪华型 价格：12.58万
国内 轿车
雨燕 型号：雨燕1.3 手动舒适型 价格：6.28-6.98万
型号：雨燕1.3 手动豪华型 价格：7.18-7.88万
型号：雨燕1.3 手动超豪华型 价格：8.48万
型号：雨燕1.3 自动豪华型 价格：8.23-8.88万
型号：雨燕1.3 自动超豪华型 价格：9.48万
国内 轿车
长安羚羊 型号：羚羊OK款 手动标准型 价格：4.98-5.23万
型号：羚羊OK款 手动天窗版 价格：6.88-7.13万
型号：羚羊OK款 自动天窗版 价格：7.78-8.03万
型号：羚羊OK款 手动实用型 价格：4.98-6.13万
型号：羚羊OK款 手动舒适型 价格：5.88-6.13万
型号：羚羊OK款 手动豪华型 价格：6.48-6.73万
国内 轿车
长安奥拓 型号：奥拓都市贝贝 价格：3.68万
型号：奥拓快乐王子 价格：3.84万
型号：奥拓 标准型 价格：3.28万
请采纳答案，支持我一下。

2008年的低配长安铃木羚羊SC7135A二手车，一般来说该车子车况还有手续方面不存在明显问题情况下大体能够值一万到一万二左右，具体需要看实际车况。

羚羊车在性价比方面还是不错的，省油，维护费用低，就是外形和内饰有点土
羚羊现在有三个配置的车型：
基本型：41800
标准型：45800
舒适型：51800
一共下来多少钱这个我只能告诉你一部分：
交强险：950/年
车船税：420/年，和交强险一起交
购置税：裸车价格*11.7%
牌照：各地收费好像不太一样，去车管所问问，我秦皇岛的，上牌一共花了175块（包括牌照，牌照架和车牌手工费）
其他费用不好说了，要看你是不是上全险和你们那里保险公司各种险的价格
我是7月3号买的标准羊，车价45800，交强险4S送的，其他保险在平安上的，没上玻璃单独破碎，都算上5万多点，然后4S退了3000块钱节能补贴，最后花了不到5万

价 格： 4.28-8.98 万元 外形尺寸（长/宽/高）： 4095/1590/1380mm
排 量： 993-1310 cc 原产地： 亚洲 所属： 羚羊
理论油耗： 4.5-5.3 升/百公里
优 点： 配置多样，技术成熟，适合家用，价格合理
缺 点： 后排空间小，实用性稍逊，高速稳定性待加强
羚羊系列是长安铃木生产的经济型轿车，目前有羚羊03款和OK款两种车型。其中羚羊OK款采用直列四缸16气门电喷发动机MPI/1.3L、三元催化净化装置、电子式前排双安全气囊、四轮制动防抱死系统（ABS）、前部及后尾部安全碰撞吸能区、碰撞吸能式转向柱、三点约束式后座安全带、开门报警蜂鸣器、高位制动灯、前雾灯、后窗除霜器、窗式天线、绿色玻璃、铝合金车轮、中立柱黑色贴膜、消音器口不锈钢装饰筒、后围镀铬立体字标、浅色豪华座椅面料、浅色内饰、一体式T形中控面板、四辐条方向盘、浅色豪华门内饰板面料、行李箱盖装饰件、搁物板喇叭装饰盖、带腰部支撑的可升降式驾驶员座椅、中央门锁、动力转向、四门电动车窗、环保型无氟空调、电动调节后视镜、后排下部空调出风口、VFD大屏幕显示6碟CD、六喇叭、前盘后鼓式制动器、双回路真空助力制动系统、麦弗逊式独立前悬架/多连杆式独立后悬架。两款车都根据配置的不同有普通型，标准型、实用型、舒适型，豪华型五种，为不同需要的人提供合适的选择。

长安铃木新羚羊有标准型,还有舒适型,不知道您问的是哪一款,我有一朋友买的标准型,45800元,一个地方跟一个地方的价格也不是一样的,至于这车的性能以及厂家报价,您可以在http://www.autohome.com.cn/这个网站查找,价格都是每天更新的!希望您能找到满意的车型!

相关tag:价格 铃木小羚羊汽车报价 价格是多少
本站部分资源来源于网络，如果侵犯了您的权益，请联系我们删除1354090129@qq.com

求数据结构哈夫曼编码译码器 ♂

求数据结构哈夫曼编码译码器

• 求数据结构哈夫曼编码译码器
• 哈夫曼编码的原理是什么
• 一道关于求哈夫曼编码的数据结构题，求解答
• 利用 数据结构 实现 哈夫曼编码/译码实现
• 求解，关于数据结构的哈夫曼编码的问题

#ifndef Huffman_Tree_h
#define Huffman_Tree_h
#endif
#include 《stdio.h》
typedef struct {
unsigned int weight;
unsigned int parent,lchild,rchild;
}HTNode, * HuffmanTree; //存储赫夫曼树的结点类型
typedef char * * HuffmanCode; //用于存储字符集中各个字符相应的赫夫曼编码
void strcpy(char *S1,char *S2){ //将字符串S2复制到S1
int i = 0;
while( S2 != ’0’ ){
S1;
i++;
}
S1 = ’0’;
}
void Select(HuffmanTree HT,int t,int &s1,int &s2){ //在HT中找出权值最小的两个S1和S2
int i = 1;
s1 = s2 = 0;
HT.weight = 65535;
while( i 《= t ){ //遍历查找权值最小的结点S1
if( HT.weight )
s1 = i;
i++;
}
i = 1;
while( i 《= t ){ //遍历查找除S1外权值最小的结点S2
if( i != s1 && HT.weight )
s2 = i;
i++;
}
}
int HuffmanCoding( HuffmanTree &HT,HuffmanCode &HC,int *w,int n){ //根据各个字符的权值构造赫夫曼树HT，将对应的赫夫曼编码存储在HC中
int s1,s2,m,i,start;
unsigned int c,f;
HTNode * p;
char *cd;
if( n 《= 1 ) return 0;
m = 2 * n - 1; //赫夫曼树的总结点树为m
HT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode)); //申请存储赫夫曼树的空间
for(p = HT + 1, i = 1; i 《= n; ++i, ++p, ++w){ //将各个叶子结点的weight赋以相应的权值，parent,lchild,rchild均赋为0
p-》weight = *(w+1);
p-》parent = p-》lchild = p-》rchild = 0;
}
for( ; i 《= m; ++i, ++p ){ //将各个非叶子结点的weight,parent,lchild,rchild均赋为0
p-》weight = p-》parent = p-》lchild = p-》rchild = 0;
}
for( i = n + 1; i 《= m; ++i ){ //构造赫夫曼树，给各个非叶子结点赋值
Select(HT, i - 1, s1, s2);
HT.parent = i;
HT.rchild = s2;
HT.weight;
}
HC = (HuffmanCode)malloc((n + 1) * sizeof(char *)); //申请空间，用于存储指向存储各个字符相应赫夫曼编码的字符数组的指针
cd = (char *)malloc(n * sizeof(char)); //申请用于求赫夫曼编码
cd = ’0’; //编码结束符
for( i = 1; i 《= n; ++i){ //逐个字符求赫夫曼编码
start = n -1; //编码在数组cd中的最前位置
for(c = i,f = HT.parent) //从叶子到根逆向求编码
if(HT.lchild == c)
cd = ’0’;
else
cd = ’1’;
HC = (char *)malloc((n - start)*sizeof(char)); //为第i个字符编码分配空间
strcpy(HC
}
free(cd); //释放空间
return 1;
}
以上为第一部分
#include 《stdio.h》
#include 《stdlib.h》
#include “Huffman_Tree.h“
#define Yes 1 //当程序已经调用过初始化赫夫曼树的InitHuff_T()函数，或已从htfTree文件读取过，则将Init_Mode置为Yes，否则为No
#define No 0
void InitHuff_T( HuffmanTree &HT, HuffmanCode &HC, char ch,int &n ){ //初始化赫夫曼数，要求用户输入字符和相应权值
int i = 1,w,tem,j;
char a;
FILE *save;
printf(“请输入编码字符集的大小n:“);
scanf(“%d“,&n); //获取用户输入的字符集个数
while( i 《= n ){ //获取用户输入的字符和相应权值，分别存储在ch数组中
printf(“请输入第%d个字符和该字符的权值w:“,i);
fflush(stdin);
scanf(“%c%d“,&ch);
i++;
}
ch = ’0’;
HuffmanCoding(HT,HC,w,n); //根据用户的输入，生成赫夫曼数及各个字符相应的赫夫曼编码，分别存在HT树和HC中
if(( save = fopen(“htfTree“,“w“)) == NULL ){ //打开用于存储赫夫曼树的文件
printf(“Open file fail...... “);
exit(0);
}
tem = n; //接下来的14行是将字符集大小转换成字符形式写入到文件中
j = 0;
while( tem != 0 ){
tem = tem / 10;
j++;
}
tem = n;
a = ’0’;
while( tem != 0 ){
a = (char)(tem % 10 + 48);
tem = tem / 10;
j--;
}
fputs(a,save);
printf(“%d “,n); //向屏幕输出字符集大小n
fputc(’ ’,save);
for( i = 1; i 《= n; i++ ){ //分别向文件和屏幕输出各个字符和相应的赫夫曼编码
fputc(ch);
fputc(’ ’,save);
fputs(HC);
fputc(’ ’,save);
}
for(i = 1; i 《= 2 * n - 1; i++ ){ //将赫夫曼树各个结点的parent,lchild,rchild分别写入到文件中
tem = HT.parent; //将i结点的parent转换成字符并写入到文件中
if(tem == 0){
fputc(tem + 48,save);
fputc(’ ’,save);
}
else{
j = 0;
while( tem != 0 ){
tem = tem / 10;
j++;
}
tem = HT.parent;
a = ’0’;
while( tem != 0 ){
a = (char)(tem % 10 + 48);
tem = tem / 10;
j--;
}
fputs(a,save);
fputc(’ ’,save);
}
tem = HT.lchild; //将i结点的lchild转换成字符并写入到文件中
if(tem == 0){
fputc(tem + 48,save);
fputc(’ ’,save);
}
else{
j = 0;
while( tem != 0 ){
tem = tem / 10;
j++;
}
tem = HT.lchild;
a = ’0’;
while( tem != 0 ){
a = (char)(tem % 10 + 48);
tem = tem / 10;
j--;
}
fputs(a,save);
fputc(’ ’,save);
}
tem = HT.rchild; //将i结点的rchild转换成字符并写入到文件中
if(tem == 0){
fputc(tem + 48,save);
fputc(’ ’,save);
}
else{
j = 0;
while( tem != 0 ){
tem = tem / 10;
j++;
}
tem = HT.rchild;
a = ’0’;
while( tem != 0 ){
a = (char)(tem % 10 + 48);
tem = tem / 10;
j--;
}
fputs(a,save);
fputc(’ ’,save);
}
}
fclose(save);
}
void Encoding(HuffmanTree &HT, HuffmanCode &HC, char ch){ //根据赫夫曼编码将用户指定的文件中的字符编成相应的编码,并将所得编码存储到用户指定文件
FILE *ToBeTran,*CodeFile;
char ToBeTran_Name; //存储用户指定文件的文件名
int i;
char c;
printf(“请输入所要进行编码的文件的文件名:“);
scanf(“%s“,ToBeTran_Name); //获得所要进行编码的文件的文件名
if(( ToBeTran = fopen(ToBeTran_Name,“r“)) == NULL ){ //打开文件
printf(“Open file fail...... “);
exit(0);
}
printf(“请输入编码后编码表示的信息所存储到的文件的文件名:“);
scanf(“%s“,CodeFile_Name); //获得编码后编码表示的信息所存储到的文件的文件名
if(( CodeFile = fopen(CodeFile_Name,“w“)) == NULL ){ //打开文件
printf(“Open file fail...... “);
exit(0);
}
c = fgetc(ToBeTran); //从文件读取一个字符
while( c != EOF ){ //对文件中的各个字符进行编码，直至文件结尾
i = 1;
while( c != ch数组中查找从文件读取的字符
i++;
if(ch数组中，c无法被识别，程序出错，退出
printf(“字符%c无法识别，程序将退出。 “,c);
exit(0);
}
fputs(HC,CodeFile); //若找到，则将c相应的赫夫曼编码写入到文件中
printf(“%s“,HC); //将c相应的赫夫曼编码输出到屏幕
c = fgetc(ToBeTran); //读入文件中的下一个字符
}
printf(“ “);
fclose(ToBeTran);
fclose(CodeFile);
}
void Decoding(HuffmanTree HT, char ch , int n){ //对指定的存储由赫夫曼编码表示的信息的文件进行译码，翻译成相应的字符表示，并存储到指定文件
int p,i = 1;
char code,c;
char CodeFile_Name; //存储用户指定文件的文件名
p = 2 * n - 1;
FILE *CodeFile,*TextFile;
printf(“请输入所要译的文件名:“);
scanf(“%s“,CodeFile_Name); //获得所要译的文件的文件名
if(( CodeFile = fopen(“CodeFile“,“r“)) == NULL ){ //打开文件
printf(“Open file fail...... “);
exit(0);
}
printf(“请输入译后的字符存储到的文件的文件名:“);
scanf(“%s“,TextFile_Name); //获得译后的字符存储到的文件的文件名
if(( TextFile = fopen(TextFile_Name,“w“)) == NULL ){ //打开文件
printf(“Open file fail...... “);
exit(0);
}
c = fgetc(CodeFile);
while( c != EOF ){
code = c;
i++;
c = fgetc(CodeFile);
}
code数组中
i = 1;
while ( code中的赫夫曼编码进行译码
if ( code == ’0’ )
p=HT.lchild; //进入左分支
else
p = HT.rchild; //进入右分支
if (!HT.rchild){ //进入叶子结点
fputc(ch, TextFile); //将相应的字符写入到文件中
printf(“%c“,ch); //将相应的字符输出到屏幕
p = 2 * n - 1; //重新从树根出发进行译码
}
i++;
}
printf(“ “);
}
void ReadHuff_T( HuffmanTree &HT, HuffmanCode &HC, char ch, int &n){ //从文件读取赫夫曼树
FILE *htfTree;
char c,ch1;
int i,j,t;
if(( htfTree = fopen(“htfTree“,“r“)) == NULL ){ //打开存有赫夫曼树信息的文件
printf(“Open file fail...... “);
exit(0);
}
fgets(c,10,htfTree); //获取赫夫曼树叶子结点个数的字符串表示形式
i = 0; //以下6行将字符串形式转换成整数形式
while( c != ’ ’ )
i++;
n = 0;
for( j = 0; j 《 i; j++ )
n = 10 * n + c - ’0’; //求出叶子结点数n
HC = (HuffmanCode)malloc((n + 1) * sizeof(char *)); //申请HC空间
HT = (HuffmanTree)malloc((2 * n) * sizeof(HTNode)); //申请赫夫曼树存储空间
i = 1;
while( i 《= n ){
ch = fgetc(htfTree); //读取字符集中的一个字符
HC = (char *)malloc((10)*sizeof(char)); //申请用于存储读取到的字符集中的字符的赫夫曼编码的空间
fgetc(htfTree); //将‘ ’输出
ch1 = fgetc(htfTree); //读取赫夫曼编码，存储在相应的HC数组里
int j = 0;
while( ch1 != ’ ’ ){
HC = ch1;
j++;
ch1 = fgetc(htfTree);
}
HC = ’0’;
i++;
}
ch = ’0’;
i = 0;
while( i 《 2 * n - 1 ){ //读取赫夫曼树的各个结点的parent,lchild,rchild.并赋值到赫夫曼树HT中
ch1 = fgetc(htfTree); //读取parent的字符串形式,存储在c.parent
j = 0;
while( ch1 != ’ ’ ){
c = ch1;
j++;
ch1 = fgetc(htfTree);
}
HT.parent = 0;
for( t = 0; t 《 j; t++ )
HT - ’0’;
ch1 = fgetc(htfTree); //读取lchild的字符串形式，并将其转换成整数形式，赋给HT.lchild
j = 0;
while( ch1 != ’ ’ ){
c = ch1;
j++;
ch1 = fgetc(htfTree);
}
HT.lchild = 0;
for( t = 0; t 《 j; t++ )
HT - ’0’;
ch1 = fgetc(htfTree); //读取rchild的字符串形式，并将其转换成整数形式，赋给HT.rchild
j = 0;
while( ch1 != ’ ’ ){
c = ch1;
j++;
ch1 = fgetc(htfTree);
}
HT.rchild = 0;
for( t = 0; t 《 j; t++ )
HT - ’0’;
i++;
}
}
int main(){
HuffmanTree HT;
HuffmanCode HC;
char ch; //用于存储字符集
int n,Init_Mode = No; //n为字符集的大小，Init_Mode = No 表示内存中没有赫夫曼树的信息
char mode; //让用户选择不同的操作
printf(“请输入你要选择的功能 “);
printf(“ I -- 初始化 E -- 编码 “);
printf(“ D -- 译码 Q -- 退出程序 “);
scanf(“%c“,&mode); //获得用户选择的操作
while( mode != ’Q’ && mode != ’q’ ){ //当用户输入不为Q或q时，执行相应操作
switch(mode){
case ’I’ :
InitHuff_T(HT,HC,ch,n);
Init_Mode = Yes;
break;
case ’i’ :
InitHuff_T(HT,HC,ch,n);
Init_Mode = Yes;
break;
case ’E’ :
if( No == Init_Mode )
ReadHuff_T(HT,HC,ch,n);
Encoding(HT,HC,ch);
Init_Mode = Yes;
break;
case ’e’ :
if( No == Init_Mode )
ReadHuff_T(HT,HC,ch,n);
Encoding(HT,HC,ch);
Init_Mode = Yes;
break;
case ’D’ :
if( No == Init_Mode )
ReadHuff_T(HT,HC,ch,n);
Decoding(HT,ch,n);
Init_Mode = Yes;
break;
case ’d’ :
if( No == Init_Mode )
ReadHuff_T(HT,HC,ch,n);
Decoding(HT,ch,n);
Init_Mode = Yes;
default :
printf(“您的输入有错，请重新选择. “);
}
printf(“请输入你要选择的功能 “);
printf(“ I -- 初始化 E -- 编码 “);
printf(“ D -- 译码 Q -- 退出程序 “);
fflush(stdin);
scanf(“%c“,&mode); //让用户继续选择相应的操作，直至用户选择退出
}
return 0;
}
第二部分
1。进vc++6.0
2。新建一个新工程 选择Win32 Console application
一个空工程 确认
3。新建一个c++源文件 命名为Huffman_Tree.h 记住 命名很重要 然后将第一部分烤贝 粘贴 一定得是这个名字 然后编译保存
4。在新建一个c++源文件命名为 赫夫曼.cpp 然后将第二部分拷贝 粘贴 编译保存 然后就大功告成了 可以执行了
需要注意的是 编译后生成的可执行文件保存在 你新建工程是的那个默认文件夹里 当然你也可以在新建工程是选择你想要保存可执行文件的文件夹 方便查找

霍夫曼（Huffman）编码属于码词长度可变的编码类，是霍夫曼在1952年提出的一种编码方法，即从下到上的编码方法。同其他码词长度可变的编码一样，可区别的不同码词的生成是基于不同符号出现的不同概率。

赫夫曼码的码字（各符号的代码）是异前置码字，即任一码字不会是另一码字的前面部分，这使各码字可以连在一起传送，中间不需另加隔离符号，只要传送时不出错，收端仍可分离各个码字，不致混淆。

赫夫曼编码的具体方法：先按出现的概率大小排队，把两个最小的概率相加，作为新的概率 和剩余的概率重新排队，再把最小的两个概率相加，再重新排队，直到最后变成1。每次相 加时都将“0”和“1”赋与相加的两个概率，读出时由该符号开始一直走到最后的“1”， 将路线上所遇到的“0”和“1”按最低位到最高位的顺序排好。

哈夫曼编码是上个世纪五十年代由哈夫曼教授研制开发的,它借助了数据结构当中的树型结构,在哈夫曼算法的支持下构造出一棵最优二叉树,我们把这类树命名为哈夫曼树.因此,准确地说,哈夫曼编码是在哈夫曼树的基础之上构造出来的一种编码形式,它的本身有着非常广泛的应用。

哈夫曼编码首先要构造哈夫曼树，其构造规则是从概率这个序列中选择两个最小结点的值构造一颗树，新的树根的权值为两个子树的概率权值和。
如题中，首先选择0.02 和 0.03构造一颗树，将权值之和放回序列中，为：
0.07 0.19 0.10 0.32 0.21 0.06 0.05
继续上述过程只剩下一颗树为止。
最终哈夫曼树为：
1
/
0.40 0.60
/ /
b0.19 g0.21 0.28 e0.32
/
0.11 0.17
/ /
0.05 h0.06 a0.07 d0.10
/
f(0.02) c(0.03)
哈夫曼编码是从根结点开始，找叶子结点，也就是相关字符，默认往左为0，往右为1
所以b的编码是00，g:01 e:11 h:1001 a:1010 d:1011 f:10000c:10001

//D:2010 代码haffmanhaffmanNode_statement.h
#define MAXVALUE 1000//定义最大权值
#define MAXBIT 100//定义哈夫曼树中叶子结点个数
typedef struct
{
char data;//字符值
int num;//某个值的字符出现的次数
}TotalNode;
//统计结点，包括字符种类和出现次数
typedef struct
{
TotalNode tot;//统计结点数组
int num;//统计数组中含有的字符个数
}Total;
//统计结构体，包括统计数组和字符种类数
typedef struct
{
char mes;//字符数组
int num;//总字符数
}Message;
//信息结构体，包括字符数组和总字符数
typedef struct{
int locked;//密码数组
int num;//密码总数
}Locking;
//哈夫曼编码后的密文信息
typedef struct
{
char data;//字符
int weight;//权值
int parent;//双亲结点在数组HuffNode中的序号
int lchild;//左孩子结点在数组HuffNode中的序号
int rchild;//右孩子结点在数组HuffNode中的序号
}HNodetype;
//哈夫曼树结点类型，包括左右孩子，权值和信息
typedef struct
{
int bit;
int start;
}HCodetype;
//哈夫曼编码结构体，包括编码数组和起始位
void reading_file(Message *message);//从文件中读取信息
int writing_file(Message *message);//将信息写进文件
void total_message(Message *message,Total *total);//统计信息中各字符的次数
void HaffmanTree(Total *total,HNodetype HuffNode);//构建哈夫曼树
void HaffmanCode(HNodetype HuffNode,Total *total);//建立哈夫曼编码
void writing_HCode(HNodetype HuffNode,Total *total);//将编码规则写进文件
void lock(Message *message,HNodetype HuffNode,Total *total,Locking *locking);//给文件信息加密编码
void writing_lock(Locking *locking);//将已编码信息写进文件
void first_function(HNodetype HuffNode,Total *total,Message *message);
void display(Total *total,HNodetype HuffNode);
void writing_translate(Locking *locking,HCodetype HuffCode,Total *total);//将已编码信息翻译过来并写进文
//D:2010 代码haffmanhaffmanfunction_mian.cpp
#include“Node_statement.h“
#include《iostream》
#include《fstream》
#include “cstdlib“
using namespace std;
int main()
{
int i,j,choice,mark=0;//mark标记文件信息是否读入到内存中
HNodetype HuffNode;//保存哈夫曼树中各结点信息
HCodetype HuffCode;
Locking *locking;
Total *total;
Message *message;
locking=new Locking;
locking-》num=0;
total=new Total;
total-》num=0;
message=new Message;
message-》num=0;
//初始化变量
printf(“┏ ┓ “);
printf(“┣ haffman_code system ┫ “);
printf(“┗ ┛ “);
printf(“ “);
choice=0;
while(choice!=7 )
{

printf(“＃〓§〓〓〓〓〓§〓〓〓〓§〓〓〓〓§〓＃ “);
printf(“ 0:go “);
printf(“※********** 1：从文件读取信息**********************※ “);
printf(“ *********** 2：显示编码规则 ********************* “);
printf(“ ********** 3：将原文件信息写进文件 ************ “);
printf(“ ********* 4：将编码规则写进文件 ************ “);
printf(“ ********** 5：将编码后的信息写进文件 ********** “);
printf(“ *********** 6：将译码后的信息写进文件 ********* “);
printf(“※***********7：退出 *****************************※ “);
printf(“＃〓§〓〓〓〓〓§〓〓〓〓§〓〓〓〓§〓＃ “);
printf(“ please input the choice “);
cin》》choice;
switch(choice)
{
case 1:
reading_file(message);//从文件中读取信息
mark=1;
break;
case 2://显示编码规则
if(mark==0)cout《《“请先从文件中读取信息!“《《endl;
else
{
first_function(HuffNode,HuffCode,total,message);
cout《《“编码规则为“《《endl;
for(i=0;i《total-》num;i++)//显示编码规则
{
cout《《total-》tot.data《《“ “;
for(j=HuffCode.start+1;j《total-》num;j++)
cout《《HuffCode;
cout《《endl;
}
}
break;
case 3://将原文件信息写进文件a_test1.txt
if(mark==0)cout《《“请先从文件中读取信息!“《《endl;
else
writing_file(message);//将信息写进文件
break;
case 4://将编码规则写进文件
if(mark==0)cout《《“请先从文件中读取信息!“《《endl;
else
{
first_function(HuffNode,HuffCode,total,message);
writing_HCode(HuffNode,HuffCode,total);//将编码规则写进文件
}
break;
case 5://将编码后的信息写进文件
if(mark==0)cout《《“请先从文件中读取信息!“《《endl;
else
{
first_function(HuffNode,HuffCode,total,message);
writing_lock(locking);//将已编码信息写进文件
}
break;
case 6://将译码后的信息写进文件
if(mark==0)cout《《“请先从文件中读取信息!“《《endl;
else
{
first_function(HuffNode,HuffCode,total,message);
writing_translate(locking,HuffCode,HuffNode,total);//将已编码信息翻译过来并写进文件
}
break;
}
}
/**
打印haffman树
**/
display(total,HuffNode);
system(“PAUSE“);
return 0;
}
void display(Total *total,HNodetype HuffNode)
{
int i,j;
for(i=0;i《2*total-》num-1;i++)
{
printf(“data weight lchild rchild parent “);
printf(“ %c %d %d %d %d “,HuffNode.parent);
}

}
void reading_file(Message *message)
/**
绝对路径下读取a_test.txt file
message 中的num记录suoyou字符总数 ，放在nes【】中
equal to the buffer
**/
{
int i=0;
char ch;
ifstream infile(“a_test.txt“,ios::in | ios::out);
if(!infile)//打开失败则结束
{
cout《《“打开a_test.txt文件失败“《《endl;
exit(1);
}
else
cout《《“读取文件成功“《《endl;
while(infile.get(ch) && ch!=’#’)//读取字符直到遇到#
{
message-》mes=ch;
i++;
}
message-》num=i;//记录总字符数
infile.close();//关闭文件
}
int writing_file(Message *message)
/**
把从数组message 的信息write to disk，a_test1.txt to save
**/
{ /*
int i;
ifstream outfile(“a_test1.txt“,ios::in ); //打开文件
if( !outfile )//打开失败则结束
{
cout《《“打开a_test1.txt文件失败“《《endl;
return -1;
}
for(i=0;i《message-》num;i++)//写文件
outfile.put(message-》mes);
cout《《“信息写进文件成功“《《endl;
outfile.close();//关闭文件
return 0;*/
int i;
FILE *fp1=NULL;
if((fp1 = fopen(“a_test1.txt“,“at“))==NULL)
{
printf(“can’t open the file “);
exit(0);
}
for(i=0;i《message-》num;i++)
fprintf(fp1,“%d “,message-》mes);
printf(“文件写入成功! “);
i=fclose(fp1);
if(i==0)
printf(“文件关闭成功! “);
else
printf(“文件关闭失败! “);
}
void total_message(Message *message,Total *total)
/**
统计message中不同字符 的个数，和相同字符重复的次数，重复字符用mark标记，
total.tot 放不同字符，TotalNode 类型（char，num）
total.num 统计不同字符个数
使total这块内存空间有数据，
**/
{
int i,j,mark;
for(i=0;i《message-》num;i++)//遍历message中的所有字符信息
{
if(message-》mes!=’ ’)//字符不为空格时
{
mark=0;
for(j=0;j《total-》num;j++)//在total中搜索当前字符
if(total-》tot)//搜索到，则此字符次数加1，mark标志为1
{
total-》tot.num++;
mark=1;
break;
}
if(mark==0)//未搜索到，新建字符种类，保存进total中，字符类加1
{
total-》tot;
total-》tot.num=1;
total-》num++;
}
}
}
}
void HaffmanTree(Total *total,HNodetype HuffNode)
/**create the haffman tree
不同字符个数为叶子节点个数对应书上的n，
相同字符的个数为其权值weight；
get HuffNode to store the tree
**/
{
int i,j,min1,min2,x1,x2;
for(i=0;i《2*(total-》num)-1;i++)//初始化哈夫曼树并存入叶子结点权值和信息
{
if(i《=total-》num-1)
HuffNode.data;
HuffNode.num;
HuffNode.parent=-1;
HuffNode.lchild=-1;
HuffNode.rchild=-1;
}
for(i=0;i《total-》num-1;i++)
{
min1=min2=MAXVALUE;
x1=x2=0;
for(j=0;j《total-》num+i;j++)//选取最小x1和次小x2的两权值
{
if(HuffNode.weight《min1)
{
min2=min1;
x2=x1;
min1=HuffNode.weight;
x1=j;
}
else
if(HuffNode.weight《min2)
{
min2=HuffNode.weight;
x2=j;
}
}
HuffNode.parent=total-》num+i;//修改亲人结点位置
HuffNode.parent=total-》num+i;
HuffNode.weight;
HuffNode.lchild=x1;//左孩子比右孩子权值小
HuffNode.rchild=x2;
}
}
void HaffmanCode(HNodetype HuffNode,Total *total)
/***
haffman to code (0,10,110,)
得到每个不同字符（叶子）的编码，
存贮在数组HuffCode【】中,bit store the char,start store the loction
**/
{

int i,j,c,p;
HCodetype cd;
for(i=0;i《total-》num;i++)//建立叶子结点个数的编码
{
cd.start=total-》num-1;//起始位初始化
p=HuffNode.parent;
c=i;
while(p!=-1)//从叶结点向上爬直到到达根结点
{
if(HuffNode.lchild==c)//左分支则为0
cd.bit=0;
else
cd.bit=1;//右分支则为1
cd.start--;//起始位向前移动
c=p;
p=HuffNode.parent;
}
for(j=cd.start+1;j《total-》num;j++)//保存求出的每个叶结点编码和起始位
HuffCode;
HuffCode.start=cd.start;

}
}
void writing_HCode(HNodetype HuffNode,Total *total)
/**
HuffNodeto input the leaf
HuffCodeto input the code
all is to the a_test2.txt ,save the code
**/
{
/*打开HCode文件，失败则结束。将信息写进文件*/
int i,j;
FILE *fp2=NULL;
if((fp2 = fopen(“a_test2.txt“,“at“))==NULL)
{
printf(“can’t open the file “);
exit(0);
}
for(i=0;i《total-》num;i++)
{fprintf(fp2,“%d “,HuffNode.data);
printf(“ “);
for(j=HuffCode.start+1;j《total-》num;j++)
fprintf(fp2,“%d “,HuffCode);
}
printf(“编码规则写进文件成功! “);
i=fclose(fp2);
if(i==0)
printf(“文件关闭成功! “);
else
printf(“文件关闭失败! “);
}
void lock(Message *message,HNodetype HuffNode,Total *total,Locking *locking)
/***
对messag操作，对所有字符加密，
结果存贮在数组locked中，locking 记录已经加密后的密文
**/
{
int i,j,m;
for(i=0;i《message-》num;i++)//把相同的不同的字符全部 遍历
{
if(message-》mes==’ ’)//碰到空格则以-1形式保存进locked数组中
{
locking-》locked=-1;
locking-》num++;
}
else
for(j=0;j《total-》num;j++)//从total中找到对应的字符
{
if(HuffNode)
//找到在HuffNode 中对应字符，找到下标j
// 在HuffCode

for(m=HuffCode.start+1;m《total-》num;m++)///////// !
{
locking-》locked;//加密
locking-》num++;
}
}
}
}
void writing_lock(Locking *locking)
/*
将密文写到a_test3.txt
*/
{
int i;
FILE *fp3=NULL;
if((fp3= fopen(“a_test3.txt“,“at“))==NULL)
{
printf(“can’t open the file “);
exit(0);
}
for(i=0;i《locking-》num;i++)
{
if(locking-》locked==-1)
printf(“ “);
else
fprintf(fp3,“%d “,locking-》locked);
}
printf(“已编码信息写进文件成功! “);
i=fclose(fp3);
if(i==0)
printf(“文件关闭成功! “);
else
printf(“文件关闭失败! “);
}
void writing_translate(Locking *locking,HCodetype HuffCode,Total *total)
/**
密文翻译成明文，然后存到文件 a_test4.txt
**/
{
int i,j,mark,min,max;
FILE *fp4=NULL;
if((fp4 = fopen(“a_test4.txt“,“at“))==NULL)
{
printf(“can’t open the file “);
exit(0);
}

for(i=0;i《total-》num;i++)//start数组初始化
{
start.start+1;//。。。。
}
for(i=0;i《total-》num;i++)//mark数组初始化
{
mark=1;
}
min=0;
for(max=0;max《locking-》num;max++)//写文件
{
if(locking-》locked==-1)//碰到空格信息则直接输出空格
{
printf(“ “);//把空格写到文件
min++;
}
else
{
for(i=min;i《=max;i++)//查找从min开始到max的编码对应的信息
{
for(j=0;j《total-》num;j++)
{
if(start == total-》num+1)
mark=0; //对应编码比所给编码短则不在比较
if(mark)
start++;
else
mark=0;
}
}
for(i=0;i《total-》num;i++)//找到对应信息，则写进文件
{
if(mark==total-》num)
{
fprintf(fp4,“%d “,HuffNode.data);//写到文件outfile
break;
}
}
if(i!=total-》num)
min=max+1;
for(i=0;i《total-》num;i++)//start数组初始化
{
start.start+1;
}
for(i=0;i《total-》num;i++)//mark数组初始化
{
mark=1;
}
}
}
printf(“文件写入成功! “);
i=fclose(fp4);
if(i==0)
printf(“文件关闭成功! “);
else
printf(“文件关闭失败! “);
}
void first_function(HNodetype HuffNode,Total *total,Message *message)
{
total_message(message,total);//统计信息中各字符的出现次数
HaffmanTree(total,HuffNode);//构建哈夫曼树
HaffmanCode(HuffNode,HuffCode,total);//建立哈夫曼编码

}

方案一应该指的就是下面那个图了.
下面那个图是一棵二进制的哈夫曼树,其中因为是二进制编码,所以使用的是01的边.
那么对于每一个叶子节点来说,从根节点到叶子节点走过的边就是这个数字的编码.
那么举一个例子,比如频数=2的也就是最左端的那个叶节点,根到它走了5个0,它的编号就是“00000“;在比如说10这个叶子节点,根节点到他走了“0011“,它的编号也就是0011.
那么根据上面几个例子,那么叶子到根的距离,也就是边的条数,就是这个叶子所代表的编码长度.
比如193221到根的距离都是2,7610到根的距离都是4,23到根的距离都是5.
也就是上面那个WPL的系数的意思.
表示单个编码长度*使用频率=总的编码长度.
而方案二表示的传统编码,就是上面表格中的那个等长编码:“000““001“...
它们的长度都是3,所以就是*3
然后为什么哈夫曼编码正确而且最优呢?
哈夫曼编码由于构成了一棵树,而且是叶子节点作为编码的代表,所以没有任何一个编码是另一个编码的前缀,所以哈夫曼编码是一个具有正确性的编码.
然后哈夫曼树的构造是根据贪心的思想,每次选出两个最小的点合成一个新的点所构成的.就满足了最优性.
构造的过程应该书上会有写.我就不再赘述了.

相关tag:哈夫曼编码运用了哪种数据结构
本站部分资源来源于网络，如果侵犯了您的权益，请联系我们删除1354090129@qq.com

求文档： 三星复印机scx-4521f的ID复印功能怎么设置 ♂

求文档: 三星复印机scx-4521f的ID复印功能怎么设置

• 三星打印机scx-4521f，如何使用
• 三星复印机scx一4521f怎么复印
• scx-4521f打印机怎么用
• 三星s4c x-4521f复印怎么用
• 三星打印机4521FH怎么用
• 求文档: 三星复印机scx-4521f的ID复印功能怎么设置

如果需要详细的使用说明，可以进入官网下载用户手册进行学习参考：
1、可进入三星官网
2、在右上角位置点击放大镜图标
3、输入需要查询的型号
4、选择查询的型号
5、进入界面后点击服务支持
6、点击用户手册下载进行参考

设备：三星复印机scx一4521f

1、首先把要打印的文件正面朝上，放到最上面的ADF上。确定纸盒是否中装好纸。

2、然后点击操作面板上的以下按钮。

3、然后在数字这边，直接输入自己想要复印的份数。

4、输入复制份数之后，再点击复印按钮，就可以连续复印。

5、如果只是复印一份的话，就可以直接点一下复印图标，直到复印完成就可以了。

尊敬的三星用户您好：
打印功能操作方法如下：
1.将电脑和打印机用数据线连接好，打印机处于开机状态，然后把软件CD插入CD-ROM驱动器（登陆三星网站www.samsung.com.cn下载驱动。
下载路径：进入网站后，在右上角搜索框中输入产品型号，然后搜索，选择【服务支持】里面的软件或驱动下载即可。）。
2.光盘插入后，电脑会弹出安装界面，根据安装向导，按照提示一步一步进行选择即可。
3.最后安装完成后，可以打印测试页验证机器打印是否成功。
欢迎您评价我们的服务： http://support.samsung.com.cn/survey/

把需要复印的文件放在扫描镜上，有字的朝下。然后面板有个按键叫做 复印！ 绿色的好像，按一下就可以了

如何快速地将证件两面复印到纸张同一面上。方法其实很简单，只要 展开 三星SCX-4521FH，ID复印功能则解决了长时间以来一直困扰大家的问题——如何快速地将证件两面复印到纸张同一面上。方法其实很简单，只要将卡的正反面复印到内存中，再打印输出就可以了，无需操心对齐问题，还省去了将纸张送回打印机的麻烦步骤。这项三星独有的ID复印技术，据统计平均可以节省大约38%的时间，极大地提高了复印效率。SCX-4521FH机身上特别设置有方便实用的手柄。进行传真将更加方便快捷，无需外线连接电话，同时有效避免了垃圾传真的骚扰。SCX-4521FH可以通过电平降低硒鼓对墨粉的吸附力，使硒鼓所吸进的墨粉量变小，控制每个打印点的尺寸从而达到节省墨粉的效果。这样，不仅可以减少耗材的花费，还提升了打印机的输出效率。可谓是一举两得

　　三星复印机scx-4521f的ID复印即身份证复印方法：
　　身份证复印可将身份证件（如驾驶执照）的两面复印到一张纸上。 使用此功能复印时，机器将在纸张的上半部复印证件的其中一面，在下半部复印另一面，而不会缩小原件尺寸。 如果装入的证件大于可复印区域，有些部分可能无法复印。只有当文档被放到文档扫描玻璃板上时，才可以使用这一特殊复印功能。如果在 ADF 中检测到文档，则无法使用身份证复印功能。
　　1、将要复印的身份证件放到文档扫描玻璃板上，合上盖板。
　　2、按菜单按钮，直到显示屏的顶行显示“复印功能”。
　　3、按滚动按钮（或 ），直到底行显示“身份证复印”。
　　4、按确认进行选择。
　　5、如果需要，请使用控制面板按钮自定义复印设置，包括份数、明暗度和原稿类型等。
　　6、按开始开始复印。机器开始扫描第一面。
　　7、当“设置背面”出现在底行时，打开文档盖板并翻转证件。关闭盖板。 注意：如果按停止/清除按钮，或约 30 秒内没有按任何按钮，机器 会取消复印作业，返回待机模式。
　　8、再次按开始按钮。

相关tag:三星4521复印机使用视频
本站部分资源来源于网络，如果侵犯了您的权益，请联系我们删除1354090129@qq.com

求新世纪大学英语 综合教程4课后习题答案 ♂

求新世纪大学英语 综合教程4课后习题答案

• 求新世纪大学英语 综合教程4课后习题答案
• 全新版大学英语综合教程(4)课后答案
• 创新大学英语综合教程第三册第二版 傅勇林主编 1-8课后习题答案
• 跪求大学英语综合教程第4册 课后练习答案 (何兆熊主编)
• 大学体验英语综合教程4课后习题答案
• 大学英语综合教程4（上海外语教育出版社的）的课文翻译及课后习题答案
• 新世纪大学英语第二版综合教程4第5单元课后答案及课文翻译

大学学习资料免费下载网 有
在 公共课程－大学英语 板块
标题：
全新版大学英语第四册综合教程练习答案及课文译文
下载不用积分

全新版大学英语综合教程4课后答案完全整理版

链接：https://pan.baidu.com/s/1ST74X0O8uUjs8qWO5GrbkA

?提取码:vyrb

如果资源不正确，或者版本不正确，欢迎追问

第一题：

第二题：

第三题：

第四题：

第五题：

这部分内容主要考察的是动词时态的知识点：

用来表示之前已发生或完成的动作或状态，其结果的确和现在有联系。动作或状态发生在过去　但它的影响现在还存在；也可表示持续到现在的动作或状态。其构成：have (has) +过去分词。

过去时表示过去某时发生的动作或单纯叙述过去的事情，强调动作；现在完成时为过去发生的，强调过去的事情对现在的影响，强调的是影响。过去时常与具体的时间状语连用，而现在完成时通常与模糊的时间状语连用，或无时间状语。

在till(until)引出的时间状语从句中，谓语动词的时态问题较为复杂。till(until)-从句的谓语动词往往用一般时态来表示。

在过去不同时间发生的两个动作中，发生在先，用过去完成时；发生在后，用一般过去时。表示意向的动词，如hope,wish,expect,think,intend,mean,suppose等，用过去完成时表示“原本…，未能…“

你可以在百度文库上搜，就打大学英语综合教程第4册课后答案，立刻就出来，超快超详细的

未完整版。
Unit 1
无名英雄：职业父亲意味着什么？

在我们的孪生女儿出生后的第一次“约会”时，我和丈夫一起去看了一部名为《玩具故事》的电影。我们很喜欢这部片子，但随后我丈夫问道：“父亲在哪儿呢？”起初我还认为因为一个小小的失误而批评一部很吸引人的家庭影片似乎是太偏狭了。可后来越想越觉得这一疏忽太严重了。父亲不仅没有出现，他甚至没有被提到—— 尽管家中有婴儿，说明他不可能离开太长时间。影片给人的感觉是，父亲出现与否似乎是个极次要的细节，甚至不需要做任何解释。
新闻媒体倾向于把父亲的边缘化，这只是一个例子，它反映了在美国发生的巨大的社会变化。大卫?布兰肯霍恩在《无父之国》一书中将这种倾向称之为“无需父亲”观念。 职业母亲（我想这应是与无职业母亲相对而言的）奋斗的故事从媒体上无尽无休地轰击着我们。与此同时，媒体上绝大多数有关父亲的故事又集中表现暴力的丈夫或没出息的父亲。看起来似乎父亲惟一值得人们提及的时候是因为他们做家务太少而受到指责的时候（我怀疑这一说法的可靠性，因为“家务”的定义中很少包括打扫屋顶的雨水沟、给汽车换机油或其它一些典型地由男人们做的事），或者是在他们去世的时候。当布兰肯霍恩先生就“顾家的好男人”一词的词义对父亲们进行调查时，许多父亲都回答这一词语只有在葬礼上听到。
这种“无需父亲”综合症的一个例外是家庭全职父亲所受到的媒体的赞扬。我并非暗指这些家庭全职父亲作出的承诺不值得人们的支持，我只是想指出在实际生效的双重标准：家庭全职父亲受到人们的赞扬，而家庭全职母亲和养家活口的父亲，所得到文化上的认同却很少，甚至完全得不到。
我们用来讨论父亲角色（即没出息的父亲）的话语本身就显示出人们对大多数男人默默无闻而自豪地履行对家庭承担的责任缺乏赏识。我们几乎从来没听到“职业父亲”这一说法，在人们呼吁应该考虑给予工作者在工作地点上更大的灵活性时，很少有人认为这种呼吁不但适用于女子，同样也适应于男子。我们这个社会表现出似乎家庭职责对父亲来说并不象对母亲那么重要 —— 似乎事业上的满足就是男人生活的全部。
更让人感到侮辱的是最近媒体的这种倾向，即把家庭主妇看成是一种“地位的象征” —— 就像一辆名贵的汽车，只有据说少数男人才享受得起这种奢侈与豪华。这暗示家里有家庭主妇的男人比那些妻子在外工作的男人日子过得更舒适，因为他们拥有全职管家这种“奢侈品”。然而，实际上作为家庭惟一挣钱者的男人要承受很多压力。当他们的那份工作是家庭收入的惟一来源的时候，失业，或者甚至只不过是受到失业的威胁，对他们来说显然构成更大的困难。同样，家庭惟一的工资收入者在想辞去不太满意的工作时，其灵活程度也要小一些，因为这种工作变换会使他们失去收入。此外，为了给家庭挣更多的钱，许多丈夫超时工作或兼做第二职业。对于这些男人来说，正是这份工作所支撑的家庭，使得他们值得付出努力。很多男人相信母亲呆在家里对小孩十分重要，这种信念使得他们乐意地担起家里惟一挣钱人的担子。
目前，研究者们普遍认为家庭中没有父亲会对小孩 —— 因此对整个社会 —— 带来严重的问题。然而，我们这个社会并没有把“普通”父亲作为正面角色为未来的父亲树立榜样，相反地，却常常持放弃态度，认为传统的父道从最好的方面说是已经过时，从最坏的方面讲就是危险的反动。这使得许多男人对他们作为父亲的角色的价值提出疑问。 作为一个社会，我们需要认识到对于孩子来说，父亲是与母亲同等重要的，不仅仅在经济支持上，而且在感情依靠、教育和纪律训导方面都是如此。我们仅仅意识到没有父亲是一个问题是不够的，也不能只是站在坟墓旁边哀悼“顾家好男人”的去世，随后又找一个人来替代他（请问一问已失去父亲的人，这是否可能）。我们必须承认我们是如何贬低了父道的价值，我们必须努力向男人们显示，他们在孩子们的生活中是多么不可缺少，多么重要。 那些每天都在努力去爱和支撑他们的家庭，力求做一个顾家好男人的父亲，那些无名英雄，需要我们的承认，他们所付出的一切需要我们的感谢，因为他们值得我们的认同和感激
Passage A
Ex.5 1. obligation 2. applauded 3. fulfilled 4. mirror 5. flexibility
6. devalue 7. striving 8. entailed 9. supposedly 10. Consequently
Ex6. 1. refer to as 2. at best 3. by the same token 4. at large 5. help up …as
Ex.8 Translate the following sentences into English.
1. With his promotion, he has taken on greater responsibilities.
2. He felt he did not have to make such a commitment to John any more.
3. Mary likes to go shopping in her spare time, as opposed to Lucy, who prefers to stay at home reading.
4. At best he’s ambitious, at worst a power-seeker without conscience or qualifications.
5. We have striven to the full to convince him, but we have made no headway.

是全新版大学英语吗？
大学学习资料免费下载网 有 “全新版大学英语综合教程练习答案及课文译文 ”
首页“各版本教材课后答案与习题详解”－“大英”有得下载
或在“公共课程”－“大学英语”版块也可以看到“全新版大学英语综合教程练习答案及课文译文 ”
参考资料：大学学习资料免费下载网（哲学、法学、文学、理学、工学、农学、医学、管理学等考研资料、等级考试、课后答案等资料全集）

根据首字母及汉语提示完成单词.
1.Summer is a h season.
答案：hot
2.Li Lei’s eyes aren’t very good, he wears g every day. .
答案:glassed
3.Are there any f near here , I’m hungry.
答案:food
4.Cats like eating (mouse) .
答案：mice
根据所给句子和汉语提示写出恰当的单词，每空一词。
1.Don’t go near the (蛇).Because they are dangerous.
答案：snakes
2.He was (幸运的) to pass the math exam .
答案：lucky
3.Look at the information (下面).
答案：below
4.My drink tastes sweet, but (她的) doesn’t.

相关tag:创新大学英语综合教程四课后答案
标签：in   文件   编码   字符