c语言代码权重

① Huffman编码c语言实现

说明：本程序是依据严蔚敏的数据结构（C语言版）上的代码实现的。
#pragmaonce
#include<stdio.h>
#include<tchar.h>
#include<stdlib.h>
#define MAX 100

typedefstruct{ //节点
int weight;
int parent, lchild, rchild;
}HTNode, *HuffmanTree;

typedefchar **HuffmanCode; //字符串数组，用于存储叶子节点的编码

void SelectMinNode(HuffmanTree &HT, int m, int &i1, int &i2) //找出权值最小的两个节点对应的数组下标
{
HuffmanTree p = HT;
int s1, s2;
s1 = s2 = MAX;
i1 = i2 = 1;
for(int i=1; i<=m; i++)
{
if(!(p+i)->parent)
{
if((p+i)->weight < s1)
{
i2 = i;
s1 = (p+i)->weight ;
}
}
}
for(int i=1; i<=m; i++)
{
if(!(p+i)->parent && i!=i2)
{
if((p+i)->weight < s2)
{
i1 = i;
s2 = (p+i)->weight ;
}
}
}
}
void StrCopy(char *p, char *q, int start) //从字符数组中第start个字符开始复制
{
char *c1, *c2;
c1 = p;
while(q[start] != '\0')
{
*c1 = q[start];
c1++;
start++;
}
*c1 = q[start];//别忘了将‘\n’复制过来
}
void HuffmanCoding(HuffmanTree &HT, HuffmanCode &HC, int *w, int n)
{ //HT赫夫曼树节点数组，HC存储赫夫曼编码，*w 节点权值数组的首地址，n节点个数
int i, i1, i2, m;
HuffmanTree p;
if(n<=1) return;
m = 2 * n -1; //n个叶子节点的赫夫曼树的节点总数为2n-1，可以结合树的度为n-1自己证明。
HT = (HuffmanTree)malloc((m+1)*sizeof(HTNode)); //数组首元素不使用，故多分配一个空间
p = HT + 1;
for(i=1;i<=n;++i,++p,++w) //n个叶子节点初始化
{
p->weight = *w;
p->lchild = 0;
p->rchild = 0;
p->parent = 0;
}
for(;i<=m;++i,++p) //非叶子节点初始化
{
p->weight = 0;
p->lchild = 0;
p->rchild = 0;
p->parent = 0;
}
for(i=n+1;i<=m;++i) //对非叶子节点重新计算
{
SelectMinNode(HT, i-1, i1, i2);
HT[i1].parent = i;
HT[i2].parent = i;
HT[i].lchild = i1;
HT[i].rchild = i2;
HT[i].weight = HT[i1].weight + HT[i2].weight ;
}

///从叶子节点到根节点求赫夫曼编码
char* cd;
int start, c, f;
HC = (HuffmanCode)malloc((n+1)*sizeof(char*));//分配字符指针数组，同样多分配一个
cd = (char*)malloc(n*sizeof(char)); //零时变量，用于存储当前叶子节点的赫夫曼编码
cd[n-1] = '\0';
for(int i=1; i<=n; i++)
{
start = n-1;
for(c=i,f=HT[i].parent; f!=0;c=f,f=HT[f].parent)
{
if(HT[f].lchild == c)
cd[--start] = '0';
else
cd[--start] = '1';
}
HC[i] = (char*)malloc((n-start)*sizeof(char));
StrCopy(HC[i], cd, start); //将存储的编码给HC的第i个数组
}
free(cd);
}
void PrintHuffmanCode(HuffmanTree HT, HuffmanCode HC, int n) //打印各节点的赫夫曼编码
{
HuffmanCode p;
for(int i=1; i<=n; i++)
{
p = HC;
printf("The weight %d HuffmanCode is: ", HT[i]);
while(*p[i]!='\0')
{
printf("%c",*p[i]);
p[i]++;
}
printf("\n");
}
}
void main()
{
int n = 8;
HuffmanTree HT;
HuffmanCode HC;
int a[8] = {5, 29, 7, 8, 14, 23, 3, 11};//信号源的概率分布，即P={p0, p1,…, pK-1}
HuffmanCoding(HT, HC, a, n);
PrintHuffmanCode(HT, HC, n);
system("pause");}

② c语言加权平均

#include <stdio.h>

using namespace std;

int main()
{

int a[11];

int b = 0;

for (int i = 0; i < 11; i++)

{

scanf_s("%d", &a[i]);//输入间打空格键，如下图

//a[i] = getchar();注：getchar()不行，它读取的是输入的字符，即你输入10，结果它读取为1和0.

b += a[i];

}

float c = 0;

c = (float)b / 11; //c为答案

printf("%f ", c);

return 0;

}

③ 求c语言算加权平均分的代码

//经过调试，可以运行
#include"stdio.h"
#include "ctype.h"
#define NAME_LEN 999
#define MAX_PRO 999
int num_parts = 0;
float total_hours = 0,ave_marks = 0;
struct
{
char pro_name[NAME_LEN+1];
float cre_hour;
float marks;
}project[MAX_PRO];
void sum_credit_hour(void);
void GPA(void);
void print(void);
int read_line(char str[], int);
int main()
{
char code;
printf("This program is edited by siyuan lu.\n"
"if you want to make your life more convinent,please ask him to get more.\n\n");
for(;;)
{
printf("操作码：\ni 写入科目及学分\ng 显示平均学分\np 显示已输入的数据\nq 退出程序");
printf("\n请输入操作码： ");
scanf(" %c", &code);

//冗余语句
/*************************
while (getchar() != '\n')
;
*************************/
switch ((int)code)
{
case 105: sum_credit_hour();break;
case 103: GPA();break;
case 112: print();break;
case 113: goto L;break;
default : printf("非法的输入码！");
}
printf("\n");
}
L: ;
return 0;
}
/*这个函数的功能是写入科目名称及学分数并计算已输入的总学分数 这个函数使用了结构体变量*/
void sum_credit_hour(void)
{
int i;
char j;
printf("请输入学科名称：");
read_line(project[num_parts].pro_name, NAME_LEN);
printf("请输入学科学分数：");
scanf("%f", &project[num_parts].cre_hour);
printf("请输入您的成绩：");
scanf("%f", &project[num_parts].marks);
total_hours += project[num_parts].cre_hour;
num_parts++;
}

/*这个函数的功能是计算并显示加权平均分 这个函数使用了结构体变量*/
void GPA(void)
{
int i,total_marks = 0;
for(i = 0;i < num_parts; i++)
{
total_marks += project[i].marks * project[i].cre_hour;
}
ave_marks = total_marks / (int)total_hours;
printf("您的加权平均分为：%.2f
", ave_marks);
}

/*这个函数的功能是显示已输入的数据 这个函数使用了结构体变量*/
void print(void)
{
int i;
printf("学科 学分数 " "成绩\n");
for(i = 0;i < num_parts; i++)
printf("%-10s %-16f%8f\n", project[i].pro_name, project[i].cre_hour,project[i].marks);
}
int read_line(char str[], int n)
{
int ch, i = 0;
while (isspace(ch = getchar()))
;
while (ch != '\n' && ch != EOF)
{
if (i < n)
str[i++] = ch;
ch = getchar();
}
str[i] = '\0';
return i;
}

自己多练练，求这种代码容易被鄙视。。

④ C语言代码中的“#”、“()”等代表什么

我可能应该知道你意思了呢，
是不是你认为#define，#include之类的预处理命令后面没有分号？！
原因是他们不是C语句，
C语言的标准说的是一个完整的C语句必须用分号结束，
“预处理命令不是C语言语句”这是标准C的规定的，记住就行
相信楼上说的比较清楚了，我不多唠叨了，现在你明白了吧，呵呵。。。

⑤ C语言指针的问题 能帮我分析下以下的代码吗，看不太明白

#include <stdio.h>
int main(void)
{
char *p,s[6]; //定义6个长度的字符数组和一个指向字符的指针
int n; //定义整形变量n
n=0; //给n赋初值0
p=s; //一维数组名代表数组第一个元素的地址，即p存着s[0]的地址
printf("输入你要转换的八进制数：\n"); //输入提示
gets(p); //输入字符串，在最后一个字符后面会自动加'\0'
while(*(p)!='\0') //对指针p解引用，并判断是否为'\0',即判断字符串是否已经结束
{
n=n*8+*p-'0'; //*p就是p所指向的字符，*p-'0'就是p所指向的字符的ASCII减去0的ASCII，就是这个字符所代表的真实数字
p++; //指针后移，由于指针指向一维数组，即代表指针指向下一个元素
}
printf("转换的十进制是：\n%d\n",n); //输出结果
return 0;
}

⑥ 用C语言计算加权分数

本人（无界）用C-Free亲手编写的，亲测可运行

#include<stdio.h>

structstu{				//用结构体数组储存学生的成绩和学分
	floatscore;			//成绩
	floatcredit;			//学分
}Stu[100];

intmain()
{
	unsignedintx=1,y=0;
	//y用于结构体数组Stu，同时用于循环计算该学生成绩
	doublesxcsum=0,csum=0,sum;
	//sxcsum记录所有成绩乘以学分之和
	//csum学分之和
	//sum加权成绩
	printf("提示：输入完后按回车键结束，输入负数代表学生成绩输入完成
");
	while(1)	//循环用户输入成绩，直到用户输入完成后结束
	{
		printf("请输入第%d门课程的成绩:",x);
		scanf("%f",&Stu[y].score);		
		getchar();				//吸收回车键字符
		if(Stu[y].score<0)break;		//输入负数结束循环，结束学生输入成绩操作
		printf("请输入第%d门课程的学分:",x++);
		scanf("%f",&Stu[y++].credit);
		getchar();
		if(Stu[y-1].credit<0)break;
	}
	printf("---输入成绩结束---
");
	for(x=0;x<y;x++)//循环计算成绩，直到算完所有课程，y变量储存共有多少门课程
	{
		sxcsum+=Stu[x].score*Stu[x].credit;	
		csum+=Stu[x].credit;
	}
	sum=sxcsum/csum;
	printf("该学生的加权成绩为：%g
",sum);
	return(0);
}

---“无界”回答---

⑦ 用C语言编写以下算法： 一个5个节点的有向图，有向线段上有权重即T[i][j]，它表示节点i对节点j的信任度。

写C程序，随机给出n*n的邻接矩阵，并打印输出邻接矩阵，以及有向图的边的个数，每个顶点的度，并判断该图中是否存在Euler回路： （1）如果为n阶，则随机产生一个n*n的邻接矩阵； （2）输出邻接矩阵，边的个数，每个顶点的度以及图中是否存在Euler回路。 这个题目涉及到了两个主要的知识点，一个是数据结构中的有向图的邻接矩阵的创建，还有就是离散数学中的Euler回路的判定定理。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#define n 5 //定义矩阵的阶数n
typedef int ver;
typedef int edg; //定义有向图的顶点和边值为整形
typedef struct{
ver v[n]; //顶点
edg e[n][n]; //边权
}graph; //定义邻接矩阵的数据结构

void printgraph (graph G) //打印输出邻接矩阵
{
int i,j;
printf("顶点");
for(i=0;i<n;i++)
printf("%3d",i);
printf("\n");
for(i=0;i<n;i++)
{
printf("%4d",i);
for(j=0;j<n;j++)
printf("%3d",G.e[i][j]);
printf("\n");
}
}

void countD (graph G) //判断有向图的顶点的度，并判断Euler回路
{
int i,j,l;
int e=0,count=0;
int k; //计数器赋0
int c[n],d[n];
for (i=0;i<n;i++){
c[i]=0;
for (j=0;j<n;j++){
if (G.e[i][j]!=0)
c[i]=c[i]+1;
}
printf("顶点 %d 的出度为: %d \n",i,c[i]); //有向图的任意顶点i的出度为邻接矩阵中第i行不为0的数的个数
}
printf("\n");
for (j=0;j<n;j++){
d[j]=0;
for (i=0;i<n;i++){
if (G.e[i][j]!=0)
d[j]=d[j]+1;
}
printf("顶点 %d 的入度为: %d \n",j,d[j]); //有向图的任意顶点j的入度为邻接矩阵中第j列不为0的数的个数
}
for (l=0;l<n;l++){
if (c[l]==d[l])
count++;
else {
if (c[l]-d[l]==1)
e++;
else{
if (d[l]-c[l]==1)
e++;
}
}
}
k=0;
if (count==n) //判断Euler回路： 1：所有顶点的出度等于入度；
//2：有且仅有两个点度数为奇数，且一个出度比入度大一
k=1; //另一个入度比出度大一，其他的顶点出度等于入度

else {
if (e==2 && count==n-2)

k=1;
}

if (k==1)
printf("有向图中存在Euler回路\n");
else
printf("有向图中不存在Euler回路\n");

}

void main() //主函数
{
int i,j,temp;

graph G;

srand(time (NULL)); //随机种子

for (i=0;i<n;i++){
for (j=0;j<n;j++)
G.e[i][j]=0;
}
for (i=0;i<n;i++)
G.v[i]=0;

for (i=0;i<n;i++){
for (j=0;j<n;j++){
do
{
temp = rand()%n; //随机建造邻接矩阵
if (G.v[i]<n)
{
G.e[i][j] = temp;
G.v[i]++;
break;
}
}
while (1);
}
}
printf("生成的有向图邻接矩阵为: \n");
printgraph(G);
countD (G); //调用子函数
printf("有向图的边数为：%d\n",n*(n-1)/2);

}
另外,团IDC网上有许多产品团购,便宜有口碑

⑧ C语言 关于权重的 问题

唉，你这错误也太多了吧。

/****考生在以下空白处写入执行语句******/
for(i=0;i<n;i++)
{
a[i]=(i+1)*((int)s[i]);
printf("%d
",a[i]);
}

/****考生在以上空白处写入执行语句******/

⑨ c语言 要为产生的随机数加上权重 如在6-18内产生100个随机数，6-9出现频率为25%，10-14为50%，15-18为25%

这样改吧：

#include<stdlib.h>

#include<stdio.h>

#include<time.h>

voidmain()

{

inti,j;

srand((unsigned)time(NULL));

for(i=0;i<100;i++)

{

j=rand()%100;

if(j<25) //6到10的25%

{

j=rand()%10;

while(j<6)

j=rand()%10;

}

elseif(j<75) //11到14的50%

{

j=rand()%15;

while(j<10)

j=rand()%15;

}

else //15到18的25%

{

j=rand()%19;

while(j<15)

j=rand()%19;

}

printf("%d ",j);

}

}

⑩ 创建一个哈夫曼树并且进行编码权重如下w={5，29，7 8，14，13 ，3 ，11}写出c语言代码

#include"stdafx.h"
#include"hfm.h"
#include<string.h>
#include<malloc.h>//malloc()等
#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<limits.h>
#include<iostream>
#defineTRUE1
#defineFALSE1
#defineOK1
#defineERROR1
#defineINFEASIBLE-1

typedefintStatus;
typedefintBoolean；
/************************************************************************/
/*最优二叉树简称：哈夫曼树*/
/************************************************************************/
//哈夫曼树结构
;typedefstruct{
unsignedintweight;//权重
unsignedintparent,lchild,rchild;//树的双亲节点，和左右孩子

}HTNode,*HuffmanTree;

typedefchar**HuffmanCode;


//返回i个节点中权值最小的树的根节点的序号，供select()调用
intMin(HuffmanTreeT,inti){
intj,flag;
unsignedintk=UINT_MAX;//%d-->UINT_MAX=-1,%u--->非常大的数
for(j=1;j<=i;j++)
if(T[j].weight<k&&T[j].parent==0)
k=T[j].weight,flag=j;//
T[flag].parent=1;//将parent标志为1避免二次查找

returnflag;//返回
}

voidSelect(HuffmanTreeT,inti,int&s1,int&s2){
//在i个节点中选取2个权值最小的树的根节点序号，s1为序号较小的那个
intj;
s1=Min(T,i);
s2=Min(T,i);
if(s1>s2){
j=s1;
s1=s2;
s2=j;
}
}

//HuffmanCode代表的树解码二进制值
voidHuffmanCoding(HuffmanTree&HT,HuffmanCode&HC,int*w,intn){
//w存放n个字符的权值(均>0),构造哈夫曼树HT,并求出n个字符的哈夫曼编码HC
intm,i,s1,s2,start;
unsignedc,f;
char*cd;
//分配存储空间
HuffmanTreep;
if(n<=1)
return;
//n个字符(叶子节点)有2n-1个树节点，所以树节点m
m=2*n-1;
HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0号元素未用
//这一步是给哈夫曼树的叶子节点初始化
for(p=HT+1,i=1;i<=n;++i,++p,++w)
{
(*p).weight=*w;
(*p).lchild=0;
(*p).rchild=0;
(*p).parent=0;
}
//这一步是给哈夫曼树的非叶子节点初始化
for(;i<=m;++i,++p){
(*p).parent=0;
}
/************************************************************************/
/*做完准备工作后，开始建立哈夫曼树
/************************************************************************/
for(i=n+1;i<=m;i++)
{
//在HT[1~i-1]中选择parent=0且weigh最小的节点，其序号分别为s1,s2
Select(HT,i-1,s1,s2);//传引用
HT[s1].parent=HT[s2].parent=i;
HT[i].lchild=s1;
HT[i].rchild=s2;
HT[i].weight=HT[s1].weight+HT[s2].weight;
}
/************************************************************************/
/*从叶子到根逆求每个叶子节点的哈夫曼编码*/
/************************************************************************/
//分配n个字符编码的头指针向量，（[0]不用）
HC=(HuffmanCode)malloc((n+1)*sizeof(char*));
cd=(char*)malloc(n*sizeof(char));//分配求编码的工作空间
cd[n-1]='';//结束符
for(i=1;i<=n;i++)//每个节点的遍历
{
start=n-1;
for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent){//每个节点到根节点的遍历
//从叶子节点到根节点的逆序编码
if(HT[f].lchild==c)
cd[--start]='0';
else
cd[--start]='1';
}
HC[i]=(char*)malloc((n-start)*sizeof(char));//生成一个块内存存储字符
//为第i个字符编码分配空间
strcpy(HC[i],&cd[start]);//从cd赋值字符串到cd
}
free(cd);//释放资源
}

//函数声明
intMin(HuffmanTreeT,inti);//求i个节点中的最小权重的序列号，并返回
voidSelect(HuffmanTreeT,inti,int&s1,int&s2);//从两个最小权重中选取最小的(左边)给s1，右边的给s2
voidHuffmanCoding(HuffmanTree&HT,HuffmanCode&HC,int*w,intn);//哈夫曼编码与解码

intmain(){

HuffmanTreeHT;
HuffmanCodeHC;

int*w,n,i;
printf("请输入权值的个数(>1):");
scanf_s("%d",&n);

w=(int*)malloc(n*sizeof(int));
printf("请依次输入%d个权值(整形):
",n);

for(i=0;i<=n-1;i++)
{
scanf_s("%d",w+i);
}
HuffmanCoding(HT,HC,w,n);

for(i=1;i<=n;i++)
{
puts(HC[i]);
}
return0;
}