运动会分数统计
创新互联建站专注于郓城企业网站建设,自适应网站建设,商城网站制作。郓城网站建设公司,为郓城等地区提供建站服务。全流程按需定制开发，专业设计，全程项目跟踪，创新互联建站专业和态度为您提供的服务
一、 任务
参加运动会有n个学校，学校编号为1……n。比赛分成m个项目，项目编号为1……m。项目取前五名积分；积分分别为：7、5、3、2、1；（m=20,n=20）
功能要求：
1).可以输入各个项目的前五名的学校编号；
2)．能统计各学校总分；
3)．可以按学校编号输出、学校总分排序输出，输出内容包括学校编号，总分和名次。
规定：输入数据形式和范围：20以内的整数（如果做得更好可以输入学校的名称，运动项目的名称）；各学校分数为整形。
界面要求：有合理的提示，根据提示，可以完成相关的功能要求。
二、 存储分析
由于学校个数、项目个数是确定的，并不会随时需要增加或减少，所以采用顺序存储结构较好，并且能随机存取。即采用数组作为存储结构。
学校个数为数组长度，每个数组元素必须包含如下信息：学校编号，项目1成绩，项目2成绩，……，项目m成绩，总分，名次。（方便完成功能1，2，4和3部分）
由于功能3要求能按学校总分排序输出，宜另外按总分顺序存储学校的总分信息。
综合前面分析，需要两个数组，数组1按学校编号顺序存放学校编号，项目1成绩，项目2成绩，……，项目m成绩，总分，名次。数组2按学校总分存放学校编号，总分，名次。
三、 程序结构安排
1、 输入各个项目的前五名的学校编号，填写数组1；
2、 计算数组1的学校总分；
3、 对数组1按总分排序，结果存放在数组2。填写数组2的名次。
4、 将数组2的名次信息填回数组1。
四、 输出
1、 按学校编号输出：即输出数组1相关信息；
2、 按学校总分排序：即输出数组2相关信息；
3、 按学校编号查询学校各个项目的情况：即输出数组1相应学校信息。
五、 举例
有10个学校，5个项目。
数组1：
数组下标 学校编号 项目1 项目2 项目3 项目4 项目5 总分 名次
0 1 7 3 2 12 3
1 2 1 7 2 10 4
2 3 5 3 8 6
3 4 5 1 7 3 16 1
4 5 1 1 7
5 6 2 7 9 5
6 7 5 2 5 1 13 2
7 8 3 2 5 10 4
8 9 1 1 7
9 10 3 7 10 4
数组2：
数组下标 学校编号 总分 名次
0 4 16 1
1 7 13 2
2 1 12 3
3 2 10 4
4 8 10 4
5 10 10 4
6 6 9 5
7 3 8 6
8 5 1 7
9 9 1 7
我忘记发了
作者：recluse 发表时间：2008-10-10 16:01:00
第2楼
哈夫曼树的建立
一、功能
输入组成二叉树的各个叶子值和权值，建立最优二叉树，并输出最优二叉树的数组存储形式。
二、什么是最优二叉数
n个带权叶子组成的所有二叉数中，带权路径长度最小的二叉树。（带权路径长度=所有叶子结点权值乘以其到根结点路径长度之和）
三、建立最优二叉数
简述：每次选择权值最小的两个叶子合并成一个新的叶子结点，新叶子结点权值为这两个叶子结点权值之和。
四、程序分析
由于叶子结点个数n已知，根据二叉树性质得知，整棵二叉树结点总数为（2n-1）个，故可建立长度为（2n-1）的数组。
数组每个元素为二叉树的一个结点，由5个域组成，所以应采用结构体类型，包括结点值，权值，左孩子，右孩子，双亲。
Struct tree1
{char lerves;
int weight;
int rch;
int lch;
int parent;
}tree[9];
五、例子及程序流程
1、 输入叶子个数及初始化。
如叶子结点个数为5，数组长度就为9。
2、 输入各个叶子的值、权值，并对数组初步赋值。
如各个叶子值分别为A、B、C、D、E，各个权值分别为18，12，10，7，11。此部分信息由键盘一边输入，一边对数组初步赋值，结果如下：
数组下标 叶子值 权值 左孩子 右孩子 双亲
0 A 18 0 0 0
1 B 12 0 0 0
2 C 10 0 0 0
3 D 7 0 0 0
4 E 11 0 0 0
5
6
7
8
3、 计算二叉树其余结点信息。
由于5个叶子结点，要合并4次。每次从还无双亲（无双亲代表还未合并过）的叶子结点中选择权值最小的两个叶子结点进行合并，新结点下标为这两个叶子的双亲，新结点的权值为这两个叶子权值之和，左孩子为最小结点下标，右孩子为次小结点下标，叶子值不需要，双亲为0。
如下为合并一次后的结果，如此循环4次即可：
数组下标 叶子值 权值 左孩子 右孩子 双亲
0 A 18 0 0 0
1 B 12 0 0 0
2 C 10 0 0 5
3 D 7 0 0 5
4 E 11 0 0 0
5 17 3 2 0
6
7
8
4、 输出二叉树（即输出数组）。
将二叉树按上表以表格形式在屏幕上输出即可。
作者：recluse 发表时间：2008-10-14 12:20:00
第3楼
#includestdio.h
#includestring.h
struct{
int sport[5];
int zf;
int mc;
}student1[10];
struct{
int snum;
int zf;
int mc;
}student2[10];
void main()
{
int point[5],i,j,temp,bj=1,temp1;
int k=0;
printf("input the sport point:\n");
for(i=0;i5;i++){
printf("point%d:",i+1);
scanf("%d",point[i]); }
for(i=0;i5;i++)
{
for(j=0;j5;j++){
printf("Input Sport %d 's School Number ( Point is %d ) :\t",i+1,point[j]);
scanf("%d",k);
student1[k-1].sport[i]=point[j];
}
}
for(i=0;i10;i++)
{
for(j=0;j5;j++)
student1[i].zf=student1[i].sport[j]+student1[i].zf;
student2[i].zf=student1[i].zf;
student2[i].snum=i+1;
}
for(i=0;i9;i++)
{
k=1;
for(j=0;j9-i;j++)
if (student2[j+1].zfstudent2[j].zf) {
temp=student2[j].zf;
temp1=student2[j].snum;
student2[j].zf=student2[j+1].zf;
student2[j].snum=student2[j+1].snum;
student2[j+1].zf=temp;
student2[j+1].snum=temp1;
k=0;
}
if(k) break;
}
for(i=0;i10;i++)
{
if(student2[i+1].zf==student2[i].zf) student2[i].mc=bj;
else student2[i].mc=bj++;
}
for(i=0;i10;i++)
{
for(j=0;j10;j++)
if(student2[i].snum==j+1) student1[j].mc=student2[i].mc;
}
printf("\t\t\t\tFORM 1\n\n");
printf("School Number:\tSport1:\tSport2:\tSport3:\tSport4:\tSport5:\tSum:\tResult:\n");
for(i=0;i10;i++) {
printf(" %d\t ",i+1);
for(j=0;j5;j++)
printf("%d\t ",student1[i].sport[j]);
printf("%d\t %d\n",student1[i].zf,student1[i].mc);
printf("\n\n");
}
printf("Press Any Butter\n\n");
getch();
printf("\t\t\tFORM 2\n\n");
printf("School Number:\tSum:\tResult:\n");
for(i=0;i10;i++)
{
printf("\t%d\t %d\t %d\n",student2[i].snum,student2[i].zf,student2[i].mc);
}
printf("\n\nPress Any Butter\n\n");
getch();
printf("\n\n");
while(1)
{
printf("Input You Want To Find The School Number(1-10):\t");
scanf("%d",k) ;
printf("\n\n");
for(i=0;i10;i++){
if(k==i+1){
printf("School Number:\tSport1:\tSport2:\tSport3:\tSport4:\tSport5:\tSum:\tResult:\n");
printf(" %d\t ",k);
for(j=0;j5;j++)
printf("%d\t ",student1[i].sport[j]);
printf("%d\t %d\n\n",student1[i].zf,student1[i].mc); }
}
}
}
写给你了，请发JAVA版块
package other;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* 定义了一种接口，要进行编码的最小单元类必需实现些接口
*
*/
interface CombinableT extends ComparableT {
T combinate(T a, T b);
}
/**
*
* the huffman tree Class 哈夫曼树，包括当前节点数据信息，左节点，右节点信息。
*/
class HuffmanTreeT extends CombinableT implements
ComparableHuffmanTreeT {
/** the root of huffman tree */
private T root;
/** the left node of huffman tree */
private HuffmanTreeT left;
/** the right node of huffman tree */
private HuffmanTreeT right;
/** 哈夫曼编码字符串，如:0000110 */
private String huffmanCodeString = "";
/** 是否对最终生成的哈夫曼进行过编码操作 */
private static boolean isSettedHuffmanCoderString = false;
public T getRoot() {
return root;
}
public void setRoot(T root) {
this.root = root;
}
public HuffmanTreeT getLeft() {
return left;
}
public void setLeft(HuffmanTreeT left) {
this.left = left;
}
public HuffmanTreeT getRight() {
return right;
}
public void setRight(HuffmanTreeT right) {
this.right = right;
}
/**
*
* 重写此方法用于递归合并节点后进行排序操作
*
*/
public int compareTo(HuffmanTreeT o) {
return o.getRoot().compareTo(this.getRoot());
}
public String toString() {
return "the root:" + this.getRoot() + "\r\nthe left:" + this.getLeft()
+ "\r\nthe right:" + this.getRight();
}
/**
*
* 对最终生成的树进行哈夫曼编码，使每个叶子节点生成01的路径编码
*
*/
private void setHuffmanCoderString() {
HuffmanTreeT left = this.getLeft();
// 如果有左节点则在路径中追加"0"
if (left != null) {
left.huffmanCodeString = this.huffmanCodeString + "0";
left.setHuffmanCoderString();// 递归编码
}
HuffmanTreeT right = this.getRight();
// 如果有右节点则在路径中追加"1"
if (right != null) {
right.huffmanCodeString = this.huffmanCodeString + "1";
right.setHuffmanCoderString();// 递归编码
}
}
public void printHuffmanCoderString() {
// 打印最终生成树的哈夫曼编码前要进行编码操作，
// 且此操作只执行一次，所以用全局标识变量判断
if (!HuffmanTree.isSettedHuffmanCoderString) {
this.setHuffmanCoderString();
HuffmanTree.isSettedHuffmanCoderString = true;// 标识已执行过编码
}
// 如果是叶子节点（即要编码的单元），则打印出编码信息，如果是非叶子结点（中间临时生成的节点），则不打印
if (this.left == null this.right == null)
System.out.println("the " + this.getRoot() + " huffmanCoder:"
+ this.huffmanCodeString);
if (this.left != null)
this.left.printHuffmanCoderString();// 递归打印
if (this.right != null)
this.right.printHuffmanCoderString();// 递归打印
}
}
/**
*
* 用类用于生成一个哈夫曼树
*/
class HuffmanTreeFactoryT extends CombinableT {
/** 初始时一个list列表当作要编码的单元类的容器 */
private ListHuffmanTreeT HuffmanTreeCollection;
/**
*
* @param unitClasses
* 待编码的单元类集合
*
*/
public HuffmanTreeFactory(ListT unitClasses) {
if (unitClasses == null || unitClasses.size() == 0)
throw new IllegalArgumentException(
"the unit classes collection can't be empty");
HuffmanTreeCollection = new LinkedListHuffmanTreeT();
// 初始化哈夫曼集合容器
for (T unitClass : unitClasses) {
HuffmanTreeT huffmanTree = new HuffmanTreeT();
huffmanTree.setRoot(unitClass);
huffmanTree.setLeft(null);
huffmanTree.setLeft(null);
HuffmanTreeCollection.add(huffmanTree);
}
Collections.sort(HuffmanTreeCollection);
}
/**
* 将待编码的哈夫曼集合处理成只含有一个元素的集合，则这最后一个元素 即为最终生成的哈夫曼树
*/
private void generateHuffmanTree() {
while (true) {
if (HuffmanTreeCollection == null
|| HuffmanTreeCollection.size() = 1)
break;
// 处理之前一定要重新排序，这是哈夫曼编码的关键原理
Collections.sort(HuffmanTreeCollection);
HuffmanTreeT huffmanTreeOne = HuffmanTreeCollection.remove(0);
HuffmanTreeT huffmanTreeTwo = HuffmanTreeCollection.remove(0);
HuffmanTreeT huffmanTreeNew = new HuffmanTreeT();
// 将集合中前面两个元素合并成一个元素插到集合中去
// 并将第一个元素和第二个元素分别作为新元素的左，右节点
huffmanTreeNew.setRoot(huffmanTreeOne.getRoot().combinate(
huffmanTreeOne.getRoot(), huffmanTreeTwo.getRoot()));
huffmanTreeNew.setLeft(huffmanTreeOne);
huffmanTreeNew.setRight(huffmanTreeTwo);
HuffmanTreeCollection.add(huffmanTreeNew);
}
}
/**
*
*
*
* @return 生成最终的哈夫曼树
*
*/
public HuffmanTreeT getHuffmanTree() {
generateHuffmanTree();
return this.HuffmanTreeCollection.get(0);
}
}
/**
* 自定义一个用于测试的单元类
*/
class UnitClass implements Serializable, CombinableUnitClass {
/** 出现概率数据 */
private int rate;
public UnitClass(int rate) {
this.rate = rate;
}
public int getRate() {
return rate;
}
public void setRate(int rate) {
this.rate = rate;
}
/**
* implements thid compartTo() in order to sort the
*
* collection stored from unitclass
*/
public int compareTo(UnitClass o) {
return o.getRate() this.rate ? 1 : o.getRate() this.rate ? -1 : 0;
}
public String toString() {
return "the rate is:" + rate;
}
/**
*
* 重写此方法用于哈夫曼编码时可以合并两个分支点信息
*
*/
public UnitClass combinate(UnitClass a, UnitClass b) {
if (a == null || b == null)
return null;
return new UnitClass(a.getRate() + b.getRate());
}
}
public class Test {
public static int counter(String s, char c) {
int count = 0;
for (int i = 0; i s.length(); i++) {
if (s.charAt(i) == c) {
count++;
}
}
return count;
}
public static void main(String[] args) {
String str = "你好呵呵123abbeab啊";
ListUnitClass l = new ArrayListUnitClass();
for (int i = 0; i str.length(); i++) {
char c = str.charAt(i);
System.out.println(c + "出现了" + counter(str, c) + "次");
l.add(new UnitClass(c));
}
HuffmanTreeFactoryUnitClass factory = new HuffmanTreeFactoryUnitClass(
l);
factory.getHuffmanTree().printHuffmanCoderString();
}
}
可以参考一下以下的代码:
/*
* 求哈夫曼树
*/
public class BinaryTree {
TreeNode[] node;
public BinaryTree(int[] w) {
int n = w.length;
node = new TreeNode[n];
node = initTree(node,n,w);
display(node,n);
node = createTree(node,n,w);
display2(node,n);
}
private void display2(TreeNode[] node2, int n) {
System.out.println("====================================================");
System.out.println("index\tweight\tleft\tright\tparent");
for(int i=0;in;i++)
{
System.out.println(i+"\t"+node2[i].getWeight()+"\t"+node2[i].left+"\t"+node2[i].right+"\t"+node2[i].parent.getWeight());
}
for(int i=n;i2*n-2;i++)
{
System.out.println(i+"\t"+node2[i].getWeight()+"\t"+node2[i].left.getWeight()+"\t"+node2[i].right.getWeight()+"\t"+node2[i].parent.getWeight());
}
System.out.println(2*n-2+"\t"+node2[2*n-2].getWeight()+"\t"+node2[2*n-2].left.getWeight()+"\t"+node2[2*n-2].right.getWeight()+"\t"+node2[2*n-2].parent);
}
private void display(TreeNode[] node2, int n) {
System.out.println("====================================================");
System.out.println("index\tweight\tleft\tright\tparent");
for(int i=0;i2*n-1;i++)
{
System.out.println(i+"\t"+node2[i].getWeight()+"\t"+node2[i].left+"\t"+node2[i].right+"\t"+node2[i].parent);
}
}
private TreeNode[] initTree(TreeNode[] a,int n,int[] weight) {
a=new TreeNode[2*n-1];
for(int i=0;i2*n-1;i++)
{
if(in)
a[i]=new TreeNode(weight[i]);
else
a[i]=new TreeNode(0);
}
return a;
}
private TreeNode[] createTree(TreeNode[] a, int n, int[] w) {
for(int i=n;i2*n-1;i++)
{
int min=65566,cmin=65566;
int x=0,cx=0;
for(int j=0;ji;j++)
{
if(a[j].parent==nulla[j].getWeight()min)
{
cmin=min;
cx=x;
min=a[j].getWeight();
x=j;
}
else if(a[j].parent==nulla[j].getWeight()cmin)
{
cmin=a[j].getWeight();
cx=j;
}
}
a[i].setWeight(min+cmin);
a[i].left=new TreeNode(x);
a[i].right=new TreeNode(cx);
a[x].parent=new TreeNode(i);
a[cx].parent=a[x].parent;
}
return a;
}
public static void main(String[] args) {
int[] w = new int[]{1,2,3,4,5,6,7,8,9};
new BinaryTree(w);
}
}
class TreeNode {
private int weight;
TreeNode left;
TreeNode right;
TreeNode parent;
public TreeNode(int weight) {
this.weight = weight;
this.left = null;
this.right = null;
this.parent = null;
}
public int getWeight() {
return this.weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
}
我记得有一本书，叫java算法设计，找一下看看会不会对你有帮助...
只要自己再加个类Tree就可以了。
代码如下：
public class Tree {
double lChild, rChild, parent;
public Tree (double lChild, double rChild, double parent) {
this.lChild = lChild;
this.rChild = rChild;
this.parent = parent;
}
public double getLchild() {
return lChild;
}
public void setLchild(double lChild) {
this.lChild = lChild;
}
public double getRchild() {
return rChild;
}
public void setRchild(double rChild) {
this.rChild = rChild;
}
public double getParents() {
return parent;
}
public void setParents(double root) {
this.parent = root;
}
}
亲，你这是在考验这个题目的难度啊，
首先：学生注册登记，他是数据库的插入操作、还是利用集合（collection）、数组等进行存储
再者：分析可知可能是数据库，你也没说是那种数据库，每种数据库的连接方式也不同
最后：怎么进行写代码， 这个不只是代码的要求，你提取的数据是打印在控制台，还是用图形化界面，还是网页...等等 一系类问题你没有说清楚啊。
以上回答你满意么？
