順序存儲記錄學生成績
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）．