顺序存储记录学生成绩
A. 输入一组学生的单科成绩，用顺序表进行存储
给下面的源程序，有插入排序和归并排序，不要的话可以自己删。运行通过
源程序：
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 20
typedef struct{
int r[MAXSIZE+1];
int length;
}Sqlist;
typedef int RcdType;
void InsertSort(Sqlist &L)//直接插入排序
{
int i,j;
for(i=2;i<=L.length;i++)
if(L.r[i]<L.r[i-1])
{
L.r[0]=L.r[i];
L.r[i]=L.r[i-1];
for(j=i-2;L.r[0]<L.r[j];j--)
L.r[j+1]=L.r[j];
L.r[j+1]=L.r[0];
}
}
/*SR原表
TR归并排序后的表
功能将有序的SR[i..m]和SR[m+1..n]归并成有序的TR[i..n]
*/
void Merge(RcdType *SR,RcdType *TR,int i,int m,int n)//归并排序
{
int k,j;
for(j = m+1,k = i;i <= m && j <= n;k++)
{
if(SR[i] < SR[j])
TR[k] = SR[i++];
else
TR[k] = SR[j++];
}
if(i<=m)
{
for(;i<=m;i++,k++)
TR[k] = SR[i];
}
if(j<=n)
for(;j<=n;j++,k++)
TR[k]=SR[j];
}
void MSort(RcdType *SR,RcdType *TR1,int s,int t)
//将SR[s..t]归并排序为TR1[s..t].
{
RcdType TR2[MAXSIZE];
int i;
int m;
if(s==t) TR1[s]=SR[s];
else
{
m=(s+t)/2; //将SR[s..t]平分为SR[s..m]和SR[m+1..t]
MSort(SR,TR2,s,m);//递归地将SR[s..m]归并为有序的TR2[s..m]
MSort(SR,TR2,m+1,t);//递归地将SR[m+1..t]归并为有序的TR2[m+1..t]
Merge(TR2,TR1,s,m,t);//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
for(i=s;i<=t;i++)
printf("%d ",TR1[i]);
printf("\n");
}
}
void MergeSort(Sqlist &L)
{
//对顺序表进行归并排序
printf("归并排序过程为:\n");
MSort(L.r,L.r,1,L.length);
printf("归并排序的结果为:\n");
}
void main()
{
int i;
Sqlist L,L1;
printf("输入学生记录个数：\n");
scanf("%d",&L.length);
printf("输入学生成绩:(格式为整数：a,b,c,d)\n");
for(i=1;i<=L.length;i++)
{
if(i!=L.length)
scanf("%d,",&L.r[i]);
else
scanf("%d",&L.r[i]);
}
for(i=1;i<=L.length;i++)
L1.r[i]=L.r[i];
L1.length=L.length;
printf("直接插入排序的结果:\n");
InsertSort(L);
for(i=1;i<=L.length;i++)
printf("%3d ",L.r[i]);
printf("\n");
printf("归并排序的结果为:\n");
MergeSort(L1);
for(i=1;i<=L1.length;i++)
printf("%3d ",L1.r[i]);
printf("\n");
}
测试结果
输入学生记录个数：
10
输入学生成绩:(格式为整数：a,b,c,d)
90,80,50,85,86,91,70,60,80,65
直接插入排序的结果:
50 60 65 70 80 80 85 86 90 91
归并排序的结果为:
归并排序过程为:
80 90
50 80 90
85 86
50 80 85 86 90
70 91
60 70 91
65 80
60 65 70 80 91
50 60 65 70 80 80 85 86 90 91
归并排序的结果为:
50 60 65 70 80 80 85 86 90 91
Press any key to continue
B. 从内存3000H开始的单元中顺序存放着40位同学的某门课的考试成绩,试编写程序段,求该课程的总成绩和平均成绩
;1、推测楼主想求用8086汇编语言编写此程序
;2、按我们受传统教育毒害的常识是：100分满分。所以用一个字节单元存储一门课成绩足以
;3、不知道楼主为什么提问，但楼主如果是学计算机专业的，那建议你把汇编认真学好，
;这是你以后闯江湖的核心基础...
;4、下面就你的提问写一个范例程序，同时希望你在传统大学教育的迫害中坚强的走下去，
;并用自己的"行"来进行改变，改变自己，改变...
assume cs:code;声明。assume 告诉编译器在编译时将cs和code 段关联。
result segment ;用于存储程序结果
dw 0 ;此内存字单元存储总和
db 0 ;此内存字节单元存储平均值
result ends
code segment
start:
;将成绩存储首地址的段地址和偏移地址分别存于ds和si 中
mov ax,3000h
mov ds,ax
mov si,0
;将总成绩和平均值的存储首地址的段地址和偏移地址分别存于es和di 中
mov ax,result
mov es,ax
mov di,0
;进行40次循环，累加成绩
mov cx,40
s: mov al,[si]
mov ah,0
add es:[di],ax
inc si
loop s
;计算40位同学的单科成绩平均值
mov ax,es:[di]
mov bl,40
div bl
inc di
inc di
mov es:[di],al
mov ax,4c00h
int 21h
code ends
end start
C. 利用线性表的顺序存储结构完成一个班级的所有课程的管理c语言要求实现增加，删除，修改学生成绩记录等功
#include <stdio.h>
#include <stdlib.h>
typedef struct LNode{
int data; //链表数据
struct LNode* next; //链表指针
}LNode,*LinkList;
/*头插法-建立单链表*/
LinkList HeadCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode)); //建立头结点
la->next=NULL;
scanf("%d",&num);
while(num!=10)
{
LNode *p=(LinkList)malloc(sizeof(LNode));
p->data=num;
p->next=la->next;
la->next=p;
scanf("%d",&num);
}
return la;
}
/*尾插法-建立单链表*/
LinkList TailCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode));
la->next=NULL;
LinkList s,r=la;
scanf("%d",&num);
while(num!=10)
{
s=(LinkList)malloc(sizeof(LNode));
s->data=num;
r->next=s;
r=s;
scanf("%d",num);
}
r->next=NULL;
return la;
}
/*单链表遍历*/
void TravelList(LinkList la)
{
LinkList p=la->next;
while(p!=NULL)
{
printf("%d->",p->data);
p=p->next;
}
printf("\n");
}
/*单链表的按位查找*/
LinkList GetElem(LinkList la,int i)
{
int j=1;
LNode* p=la->next;
if(i<1)
return NULL;
while(p && j<i)
{
p=p->next;
j++;
}
return p;
}
/*单链表的按值查找*/
LinkList LocalElem(LinkList la,int e)
{
LNode* p=la->next;
while(p!=NULL && p->data!=e)
p=p->next;
return p;
}
/*单链表插入操作*/
bool InsertList(LinkList la,int i,int e)
{
//在la链表中的i位置插入数值e
int j=1;
LinkList p=la,s;
while(p && j<i)
{
p=p->next;
j++;
}
if(p==NULL)
return false;
if((s=(LinkList)malloc(sizeof(LNode)))==NULL)
return false;
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
/*单链表删除操作*/
bool DeleteList(LinkList la,int i)
{
int j=1;
LinkList p=la,q;
while(p && j<i) //p指向第i-1个元素
{
p=p->next;
j++;
}
if(p==NULL || p->next==NULL) //表示不存在第i-1个和第i的元素
return false;
q=p->next;
p->next=q->next;
free(q);
return true;
}
/*单链表的表长*/
int LengthList(LinkList la)
{
int nLen=0;
LinkList p=la->next;
while(p)
{
p=p->next;
nLen++;
}
return nLen;
}
/*单链表逆置*/
LinkList Reserve(LinkList la)
{
if(la==NULL || la->next==NULL)
return la;
LinkList p=la->next,q=p->next,r=q->next;
la->next=NULL;
p->next=NULL;
while(r!=NULL)
{
q->next=p;
p=q;
q=r;
r=r->next;
}
q->next=p;
la->next=q;
return la;
}
int main()
{
LNode la;
LinkList p;
p=HeadCreate(&la); //头插法创建单链表
TravelList(p);
printf("%p\n",GetElem(p,1)); //获得第1个结点地址
InsertList(p,2,10); //在链表的第2个位置插入元素10
TravelList(p);
DeleteList(p,3); //删除链表的第3个元素
TravelList(p);
printf("%d\n",LengthList(p)); //获得链表长度
p=Reserve(p);
TravelList(p);
return 0;
}
//运行结果
//5 6 12 7 8 14 9 3 2 5 14 10 头插法创建链表
//14->5->2->3->9->14->8->7->12->6->5-> 显示链表
//00382490 第一个结点的地址
//14->10->5->2->3->9->14->8->7->12->6->5-> 插入元素值为10的结点
//14->10->2->3->9->14->8->7->12->6->5-> 删除第三个结点
//11 获得链表长度
//5->6->12->7->8->14->9->3->2->10->14-> 链表逆置
//Press any key to continue
这是我写的一个线性表链式存储的综合程序，包含了你所要的创建、删除、插入、按值查找的功能，还有一些额外的功能。下面加注释的是程序运行结果，你可以参考试着改改程序，让程序更加完美。希望对你有帮助，呵呵！
D. 若有100 个学生，每个学生有学号、姓名、平均成绩，若一般无增删操作，采用 什么样的数据结构最方便。
采用顺序存储的数据结构最方便。
将学号、姓名、平均成绩看成-一个记录 (元素，含三个数据项)，将100个这样的记录存于数组中。因一般无增删操作，故宜采用顺序存储。
typedef struct
{ int num;//学号
char name[8];//姓名
float score;//平均成绩
} node;
node student [100].
(4)顺序存储记录学生成绩扩展阅读
数据结构的表示方法：
1、顺序存储方式
数据元素顺序存放，每个存储结点只含一 个元素。存储位置反映数据元素间的逻辑关系。存储密度大，但有些操作（如插入、删除）效率较差。
2、链式存储方式
每个存储结点除包含数据元素信息外还包含一组（至少一个）指针。指针反映数据元素间的逻辑关系。这种方式不要求存储空间连续，便于动态操作( 如插入、删除等)，但存储空间开销大（用于指针），另外不能折半查找等。
3、索引存储方式
除数据元素存储在一地址连续的内存空间外，尚需建立一个索引表，索引表中索引指示存储结点的存储位置（下标）或存储区间端点（下标），兼有静态和动态特性。
4、散列存储方式
通过散列函数和解决冲突的方法，将关键字散列在连续的有限的地址空间内，并将散列函数的值解释成关键字所在元素的存储地址，这种存储方式称为散列存储。其特点是存取速度快，只能按关键字随机存取，不能顺序存取，也不能折半存取。
E. 数据结构 算法设计题 有一个学生成绩线性表，用顺序存储方式进行存储，请编写一个时间复杂度较小的算法，
如果是从头到尾，见到一个满足于60分~70分之间的学生成绩，就删除，显然时间复杂度大。
可以这样去做：
1、用一个指示器i，从前往后找出第一个满足于60分~70分之间的学生成绩；
2、再用另一个指示器j，从尾部开始，由后向前找出第一个不满足于60分~70分之间的学生成绩；3、将i,j所指元素交换一下，直到两指示器相撞，删除结束，删除的操作，利用表长来实现！也就是所有60分~70分之间的学生成绩都在表的后部。
F. 用c编程,实现顺序存储结构的学生成绩表 1.初始化,输入5个同学成绩 2.插入操作，第3号同学插入一个同学成绩
#include <stdio.h>
#include <malloc.h>
#define maxsize 10
typedef struct
{
int num;
int score;
}student;
typedef struct
{
student data[maxsize];
int last;
}SeqList;
//初始化
SeqList *init_SeqList()
{
int x,y,i;
SeqList *L;
L=malloc(sizeof(SeqList));
for (i=0;i<=4;i++)
{
scanf("%d%d",&x,&y);
L->data[i].num=x;
L->data[i].score=y;
}
L->last=5;
return L;
}
//插入
int Insert_SeqList(SeqList *L,int i,int x,int y)
{
int j;
if(L->last==maxsize-1)
{printf("表满");return(-1);}
if(i<1 || i>L->last +2)
{printf("位置错");return(0);}
for(j=L->last;j>=i-1;j--)
L->data[j+1]=L->data[j];
L->data[i-1].num=x;
L->data[i-1].score=y;
L->last++;
return(1);
}
//删除
int Delete_SeqList(SeqList *L,int i)
{
int j;
if(i<1 || i>L->last +1)
{printf("不存在第4个元素");return(0);}
for(j=i;j<=L->last;j++)
L->data[j-1]=L->data[j];
L->last--;
return(1);
}
//查找
int Location_SeqList(SeqList *L,int x)
{
int i=0;
while(i<=L->last+1 && L->data[i].score !=x )
i++;
if(i>L->last) return (-1);
else return (i);
}
void main()
{ int i,ab,a,b,chose,c,d;
SeqList *L;
L=init_SeqList();
printf("1.插入\n");
printf("2.删除\n");
printf("3.查找\n");
printf("4.打印\n");
scanf("%d",&chose);
switch (chose)
{
case 1: {printf("从第几个数据开始插入\n");scanf("%d",&ab);printf("请输入学号和分数\n");scanf("%d%d",&a,&b);Insert_SeqList(L,ab,a,b);}
case 2: {printf("删除第几个数据\n");scanf("%d",&c);Delete_SeqList(L,c);}
case 3: {printf("查找几分\n");scanf("%d",&d);Location_SeqList(L,d);}
case 4: {for (i=0;i<L->last;i++)
printf("%d,%d\n",L->data[i].num,L->data[i].score);}
}
}
G. 顺序表实现学生成绩管理系统用java语言怎么写
声明个学生类，包括各种成绩信息，每个学生用它的一个对象表示。存储顺序表可使用数组，或者使用容器如ArrayList等。需要排序的话要实现Comparator或Comparable，进行排序选择吧。
H. 学生顺序表的处理:在一个数据文件中存放若干学生数据记录
在java里面，你可以定义两个集合，男生集合和女生集合，然后在里面放入对象。在女生集合里和男生集合里都按照成绩递减排序，就可以完成你所需要的排序了，再把排好序的序列添加到一个集合里面就行了。
I. 数据结构课设：学生成绩处理 C语言编程 顺序存储结构 希尔排序
这是考察数据结构的单链表吧，排序方式用冒泡排序是最简单的了。
J. 整数数组scores中依次存放了学号1到100的100名学生成绩排名
程序的算法是首先假设数组的第一个值为最大数值，将其赋值给变量max．然后，通过i对数组进行遍历，从数组中第二个值开始与max进行比较，如果大于max，则对max进行重新赋值．这样，max变量永远存储的都是最大值．代码中，i用在循环语句中，对数组a进行遍历．max定义为单精度浮点数，用于存放每次比较后较大的那个一数值．
故答案为：（1）a（1）；（2）a（i）>max then max=a（i）．