数据结构上机作业模板

合集下载

数据结构上机作业答案

作业1. 线性表编程作业：1．将顺序表逆置，要求用最少的附加空间。

参考答案#include <stdio.h>#include <malloc.h>#include <process.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct{ ElemType *elem;int length;int listsize;}SqList;//创建空顺序表Status InitList_Sq( SqList &L ){L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof(ElemType));if (!L.elem)exit(OVERFLOW);L.length = 0;L.listsize = LIST_INIT_SIZE;return OK;}//顺序表在第i个元素之前插入eStatus ListInsert_Sq( SqList &L, int i, ElemType e){ ElemType *newbase,*q,*p;if(i<1 || i>L.length+1) //插入位置非法return ERROR;if(L.length>=L.listsize)//溢出，动态追加空间{ newbase= (ElemType *)realloc(L.elem, (L.listsize+ LISTINCREMENT) *sizeof(ElemType));if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;p--) //元素后移*(p+1)=*p;*q=e; //完成元素插入++L.length;return(OK);}//顺序表遍历显示Status ListTraverse_Sq(SqList L){ int i=0;if(!L.elem)return ERROR;while(i<L.length)printf("%d ",L.elem[i++]);printf("\n");return OK;}//顺序表逆置void Reverse_Sq(SqList &L){int i,j;ElemType temp;for(i=0,j=L.length-1; i<j; i++,j--){temp=L.elem[i];L.elem[i]=L.elem[j];L.elem[j]=temp;}}void main(){SqList L;char flag;int i;ElemType e;if(InitList_Sq(L)==OK){printf("建立空顺序表成功！\n");do{printf("当前线性表长度为：%d\n",L.length);printf("请输入要插入元素的位置：");scanf("%d",&i);printf("请输入要插入的元素值：");scanf("%d",&e);if(ListInsert_Sq(L,i,e)==OK){printf("插入成功，插入后顺序表长度为：%d\n",L.length);printf("插入后的顺序表为：");ListTraverse_Sq(L);}elseprintf("插入失败");printf("\n继续插入元素？(y/n) ");fflush(stdin);scanf("%c",&flag);}while(flag=='y');Reverse_Sq(L);printf("顺序表逆置后为：\n");ListTraverse_Sq(L);}elseprintf("顺序表初始化失败！\n");}2．从键盘读入n个整数（升序），请编写算法实现：（1）CreateList()：建立带表头结点的单链表；（2）PrintList()：显示单链表，（形如：H->10->20->30->40）;（3）InsertList()：在有序单链表中插入元素x；（4）ReverseList()：单链表就地逆置；（5）DelList()：在有序单链表中删除所有值大于mink且小于maxk的元素。

数据结构第一次上机作业

数据结构第一次上机作业一．上机时间：2010年9月9日二．报告时间：2010年9月13日三．摘要1.试验目的：熟悉线性表的基本操作2.实验方法:（下面）3.实验结果（下面）四．内容（1）问题重新陈述题目的要求是随机的给四个人发牌，要求（斗地主为例，这个不用处理花色和王）1.每人手里要有13张牌（不用大小王，）2.每人每次手里的牌不能都是一样的（即：手中的牌是没有固定规律的）3.每轮每张牌只能出现一次，每个花色各有13张4.每人手中的牌要按照花色的顺序出现，再在同种花色中按照从小到大的顺序放置（2）验证：看是否满足上面的要求1．由于每张牌具有唯一性，则看每种花色的每张牌是否都出现过一次2．总数要是523．测试的方法：做差法（排序，就行做差，b[i+1]-b[i]）4．测试的内容：差值是否为15．判别标准：把花色转化成数字（分别用13乘以0，1，2，3在加上拍死的数字），看是否52个数字全出现了五．所用技术1．排序方法：由于每副扑克有54张牌，但是桥牌之需要出去大小王的52张。

因此用1-52同52个数字代替每张牌2．J,Q,K,A的处理：让J相当于11，Q相当于12，K相当于13，A相当于13．花色及大小的处理：52张牌除以13所得的商1，2，3和4分别表示四种花色，所得的余数表示牌的数字（A（1），2，3，4，5，6，7，8，9，10，11（J），12（Q），13（K））或者4．随机化洗牌及发牌的方法：运用srand(time(0)), rand()或者#include<stdlib.h>, #include <time.h>例如：#include<stdlib.h>#include<time.h>#include<stdio.h>main(){int r;srand((unsigned)time(NULL));r=random(10);printf("%d\n" ,r);r=random(10);printf("%d\n" ,r);getch();}还有int random(int a,int b)//产生一个它们之间并包括它们的随机数{if(a>b){a^=b^=a^=b;}//交换a,b值，使a小,b大int x=rand()%(b-a+1)+a;}5．洗牌程序void ordinary_shuffle(struct puke pk[52]){for(i=0;i<52;i++){ int t;int tds=0,ths=0;t=rand()%52;/*取随机数*/tds=pk[i].dianshu;/*进行牌与牌之间的随机替换*/ ths=pk[i].huase;pk[i].dianshu=pk[t].dianshu;pk[i].huase=pk[t].huase;pk[t].dianshu=tds;pk[t].huase=ths;}}或者void reset(){produce_seed();for(int i=1;i<=54;i++)v.push_back(i);}void random(){for(int i=0;i<random(m,n);i++)//mn为具体的数字{int index=random(1,53);v[index]^=v[0]^=v[index]^=v[0];}6．六．存在问题1.在验证程序输入时不知道花色怎么处理2.排序时不知道怎么用C语言进行描述3.关于时间和空间复杂度的计算比较混乱4.不能正确的使用C语言编译自己所想七．解决方法1.进行二维数组进行输入用a[j][i]表示某一具体的牌，其中j表示花色，i表示牌数（A，2，3，4，5，6，7，8，9，10，J,Q,K）2.八．设计程序#include <string>#include <iostream>#include <vector>#include <Windows.h>using namespace std;vector<int> v;//储存扑克的容器void produce_seed()//产生种子{SYSTEMTIME sys;GetLocalTime( &sys );srand(sys.wMilliseconds*sys.wSecond*sys.wMinute);//这样理论上能得到3600*1000种牌型}int random(int a,int b)//产生一个它们之间并包括它们的随机数{if(a>b){a^=b^=a^=b;}//交换a,b值，使a小,b大int x=rand()%(b-a+1)+a;return x;}/*产生54张打乱顺序的扑克*/void reset(){produce_seed();for(int i=1;i<=54;i++)v.push_back(i);}void random(){for(int i=0;i<random(200,300);i++)//洗牌200至300次{int index=random(1,53);v[index]^=v[0]^=v[index]^=v[0];}}void paint(const vector<int>& v,bool type=false)//type=false不显示花型{for(int i=0;i<v.size();i++){cout<<" ";if(v[i]==53)cout<<(char)1;else if(v[i]==54)cout<<(char)2;else{if(type)cout<<(char)((v[i]+2)%4+3);if((v[i]+3)/4==13)cout<<"K";else if((v[i]+3)/4==12)cout<<"Q";else if((v[i]+3)/4==11)cout<<"J";else if((v[i]+3)/4==1)cout<<"A";else cout<<(v[i]+3)/4;}//cout<<"="<<v[i];}cout<<endl<<endl;}void sort(vector<int>& v){for(int i=0;i<v.size()-1;i++)for(int j=i+1;j<v.size();j++){if(v[i]<v[j])v[i]^=v[j]^=v[i]^=v[j];if(v[i]<53&&v[j]<53)if(((v[i]+3)/4+10)%13<((v[j]+3)/4+10)%13)v[i]^=v[j]^=v[i]^=v[j];}}void main(){reset();random();vector<int> v1(v.begin(),v.begin()+17);vector<int> v2(v.begin()+17,v.begin()+34);vector<int> v3(v.begin()+34,v.begin()+51);vector<int> v4(v.begin()+51,v.end());sort(v1);sort(v2);sort(v3);sort(v4);paint(v1,/n);paint(v2,/n);paint(v3,/n);paint(v4,/n);system("pause");}九．验证程序#include<stdio.h>void main(){int i,j,m,n;int a[4][13],b[52];flag=0;printf(“Iuput number:/n”);for(i=0;i<13;i++)for(j=0;j<4;j++){Scanf(“%d”,&a[j][i]); /*进行输入*/if(j==0) b[i]= a[j][i];else if(j==1) b[i+j*13]=a[j][i];else if(j==2) b[i+j*13]= a[j][i];else(j==3) b[i+j*13]= a[j][i];}for(i=0;i<52) /*进行验证*/{m=b[i+1]-b[i];if(m!=1) printf(“thit it wrong/n”); break;elso i=i+1;}}十．运行结果十一．。

数据结构上机实验

目录第1章绪论——上机实验题1解析实验题1.1求素数实验题1.2求一个正整数的各位数字之和实验题1.3求一个字符串是否为回文第2章线性表——上机实验题2解析实验题2.1实现顺序表各种基本运算的算法/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e){if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->elem[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; /*将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}实验题2.2实现单链表各种基本运算的算法*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e)int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}第3章栈和队列——上机实验题3解析实验题3.1实现顺序栈各种基本运算的算法*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s){free(s);}int StackLength(SqStack *s){return(s->top+1);}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e){if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s){int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}实验题3.2实现链栈各种基本运算的算法/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct linknode{ElemType data; /*数据域*/struct linknode *next; /*指针域*/} LiStack;void InitStack(LiStack *&s){s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s){LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}}int StackLength(LiStack *s){int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s){return(s->next==NULL);}void Push(LiStack *&s,ElemType e){LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s){LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}实验题3.3实现顺序队列各种基本运算的算法/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType;typedef struct{ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q){q=(SqQueue *)malloc (sizeof(SqQueue));q->front=q->rear=0;}void ClearQueue(SqQueue *&q){free(q);}int QueueEmpty(SqQueue *q){return(q->front==q->rear);}int QueueLength(SqQueue *q){return (q->rear-q->front+MaxSize)%MaxSize; }int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e){if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}实验题3.4实现链队各种基本运算的算法/*文件名:algo3-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue));q->front=q->rear=NULL;}void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/{r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q){if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/{t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}第4章串——上机实验题4解析实验题4.1实现顺序串各种基本运算的算法/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/ int len; /*标记当前实际串长*/} SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ {int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/same=0;}return same;}int StrLength(SqString s){return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0]～s.ch[s.len-1]复制到str*/ str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/ str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j){SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=i-1;k<i+j-1;k++) /*将s.ch[i]～s.ch[i+j]复制到str*/str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0]～s1.ch[i-2]复制到str*/str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0]～s2.ch[s2.len-1]复制到str*/str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1]～s.ch[s1.len-1]复制到str*/str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1]～ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1]～ch[s.len-1]复制到str*/str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str){int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}实验题4.2实现链串各种基本运算的算法*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]){int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t){LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t){LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data){p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}第5章数组和稀疏矩阵——上机实验题5解析实验题5.1求5×5阶螺旋方阵/*文件名:exp5-1.cpp*/#include <stdio.h>#define MaxLen 10void fun(int a[MaxLen][MaxLen],int n){int i,j,k=0,m;if (n%2==0) //m=én/2ùm=n/2;elsem=n/2+1;for (i=0;i<m;i++){for (j=i;j<n-i;j++){k++;a[i][j]=k;}for (j=i+1;j<n-i;j++){k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;a[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("\n");printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}printf("\n");}实验题5.2求一个矩阵的马鞍点/*文件名:exp5-2.cpp*/#include <stdio.h>#define M 4#define N 4void MinMax(int A[M][N]){int i,j,have=0;int min[M],max[N];for (i=0;i<M;i++) /*计算出每行的最小值元素,放入min[0..M-1]之中*/{min[i]=A[i][0];for (j=1;j<N;j++)if (A[i][j]<min[i])min[i]=A[i][j];}for (j=0;j<N;j++) /*计算出每列的最大值元素,放入max[0..N-1]之中*/{max[j]=A[0][j];for (i=1;i<M;i++)if (A[i][j]>max[j])max[j]=A[i][j];}for (i=0;i<M;i++)for (j=0;j<N;j++)if (min[i]==max[j]){printf(" A[%d,%d]=%d\n",i,j,A[i][j]); /*显示马鞍点*/have=1;}if (!have)printf("没有鞍点\n");}void main(){int i,j;int A[M][N]={{9, 7, 6, 8},{20,26,22,25},{28,36,25,30},{12,4, 2, 6}};printf("A矩阵:\n");for (i=0;i<M;i++){for (j=0;j<N;j++)printf("%4d",A[i][j]);printf("\n");}printf("A矩阵中的马鞍点:\n");MinMax(A); /*调用MinMax()找马鞍点*/}实验题5.3求两个对称矩阵之和与乘积/*文件名:exp5-3.cpp*/#include <stdio.h>#define n 4#define m 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[n][n]){int i,j;for (i=0;i<n;i++)for (j=0;j<n;j++)c[i][j]=value(a,i,j)+value(b,i,j);}void mult(int a[],int b[],int c[n][n]){int i,j,k,s;for (i=0;i<n;i++)for (j=0;j<n;j++){s=0;for (k=0;k<n;k++)s=s+value(a,i,k)*value(b,k,j); c[i][j]=s;}}void disp1(int a[]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",value(a,i,j));printf("\n");}}void disp2(int c[n][n]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",c[i][j]);printf("\n");}}void main(){int a[m]={1,2,3,4,5,6,7,8,9,10};int b[m]={1,1,1,1,1,1,1,1,1,1};int c1[n][n],c2[n][n];madd(a,b,c1);mult(a,b,c2);printf("\n");printf("a矩阵:\n");disp1(a);printf("b矩阵:\n");disp1(b);printf("a+b:\n");disp2(c1);printf("a*b:\n");disp2(c2);printf("\n");}实验题5.4实现稀疏矩阵（采用三元组表示）的基本运算/*文件名:exp5-4.cpp*/#include <stdio.h>#define N 4typedef int ElemType;#define MaxSize 100 /*矩阵中非零元素最多个数*/ typedef struct{ int r; /*行号*/int c; /*列号*/ElemType d; /*元素值*/} TupNode; /*三元组定义*/typedef struct{ int rows; /*行数值*/int cols; /*列数值*/int nums; /*非零元素个数*/TupNode data[MaxSize];} TSMatrix; /*三元组顺序表定义*/void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nums].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);printf("\t------------------\n");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); }void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v; /*q为tb.data的下标*/tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++) /*tb.data[q]中的记录以c 域的次序排列*/for (p=0;p<t.nums;p++) /*p为t.data的下标*/if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}int MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c){int i=0,j=0,k=0;ElemType v;if (a.rows!=b.rows || a.cols!=b.cols)return 0; /*行数或列数不等时不能进行相加运算*/c.rows=a.rows;c.cols=a.cols; /*c的行列数与a的相同*/while (i<a.nums && j<b.nums) /*处理a和b中的每个元素*/{if (a.data[i].r==b.data[j].r) /*行号相等时*/{if(a.data[i].c<b.data[j].c) /*a元素的列号小于b 元素的列号*/{c.data[k].r=a.data[i].r;/*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if (a.data[i].c>b.data[j].c)/*a元素的列号大于b元素的列号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else /*a元素的列号等于b元素的列号*/{v=a.data[i].d+b.data[j].d;if (v!=0) /*只将不为0的结果添加到c中*/{c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if (a.data[i].r<b.data[j].r) /*a元素的行号小于b元素的行号*/{c.data[k].r=a.data[i].r; /*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else /*a元素的行号大于b元素的行号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return 1;}int value(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j))k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}int MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows) /*a的列数不等于b的行数时不能进行相乘运算*/return 0;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+value(a,i,k)*value(b,k,j);if (s!=0) /*产生一个三元组元素*/{c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=p;return 1;}void main(){ElemType a1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};ElemType b1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};TSMatrix a,b,c;CreatMat(a,a1);CreatMat(b,b1);printf("a的三元组:\n");DispMat(a);printf("b的三元组:\n");DispMat(b);printf("a转置为c\n");TranMat(a,c);printf("c的三元组:\n");DispMat(c);printf("c=a+b\n");MatAdd(a,b,c);printf("c的三元组:\n");DispMat(c);printf("c=a*b\n");MatMul(a,b,c);printf("c的三元组:\n");DispMat(c);}实验题5.5实现广义表的基本运算#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct lnode{ int tag; /*结点类型标识*/ union{ElemType data;struct lnode *sublist;}val;struct lnode *link; /*指向下一个元素*/} GLNode;extern GLNode *CreatGL(char *&s);extern void DispGL(GLNode *g);void Change(GLNode *&g,ElemType s,ElemType t) /*将广义表g中所有原子s 替换成t*/{if (g!=NULL){if (g->tag==1) /*子表的情况*/Change(g->val.sublist,s,t);else if (g->val.data==s) /*原子且data域值为s的情况*/g->val.data=t;Change(g->link,s,t);}}void Reverse(GLNode *&g) /*将广义表g所有元素逆置*/{GLNode *p,*q,*t;t=NULL;if (g!=NULL){p=g;while (p!=NULL) /*将同级的兄弟逆置*/{q=p->link;if (t==NULL){t=p;p->link=NULL;}else{p->link=t;t=p;}p=q;}g=t;p=g;while (p!=NULL){if (p->tag==1)Reverse(p->val.sublist);p=p->link;}}}int Same(GLNode *g1,GLNode *g2) /*判断两个广义表是否相同*/ {int s;if (g1==NULL && g2==NULL) /*均为NULL的情况*/return 1;else if ((g1==NULL && g2!=NULL) || (g1!=NULL && g2==NULL)) /*一个为NULL,另一不为NULL的情况*/return 0;else{s=1;while (g1!=NULL && g2!=NULL && s==1){if (g1->tag==1 && g2->tag==1)/*均为子表的情况*/s=Same(g1->val.sublist,g2->val.sublist);else if (g1->tag==0 && g2->tag==0)/*均为原子的情况*/{if (g1->val.data!=g2->val.data)s=0;}else /*一个为原子,另一为子表的情况*/s=0;g1=g1->link;g2=g2->link;}if (g1!=NULL || g2!=NULL) /*有一个子表尚未比较完时*/s=0;return s;}}ElemType MaxAtom(GLNode *g) /*求广义表g中最大的原子*/{ElemType m=0,m1; /*m赋初值0*/while (g!=NULL){if (g->tag==1) /*子表的情况*/{m1=MaxAtom(g->val.sublist); /*对子表递归调用*/if (m1>m) m=m1;}else{if (g->val.data>m) /*为原子时,进行原子比较*/m=g->val.data;}g=g->link;}return m;}void DelAtom(GLNode *&g,ElemType x) /*删除广义表g中的第一个为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtom(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/{if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}return;}}pre=p;p=q;}}void DelAtomAll(GLNode *&g,ElemType x) /*删除广义表g中的所有为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtomAll(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}}pre=p;p=q;}}void PreOrder(GLNode *g) /*采用先根遍历g*/{if (g!=NULL){if (g->tag==0) /*为原子结点时*/printf("%c ",g->val.data);elsePreOrder(g->val.sublist); /*为子表时*/ PreOrder(g->link);}}void main(){GLNode *g1,*g2,*g3,*g4;char *str1="(a,(a),((a,b)),((a)),a)";char *str2="(a,(b),((c,d)),((e)),f)";char *str3="(a,(a,b),(a,b,c)))";char *str4="(a,(b),((c,d)),((e)),f)";g1=CreatGL(str1);printf("\n");printf(" 广义表g1:");DispGL(g1);printf("\n");printf(" 将广义表g1中所有'a'改为'b'\n");Change(g1,'a','b');printf(" 广义表g1:");DispGL(g1);printf("\n\n");g2=CreatGL(str2);printf(" 广义表g2:");DispGL(g2);printf("\n");printf(" 广义表g2中最大原子:%c\n",MaxAtom(g2));printf(" 将g2的元素逆置\n");Reverse(g2);printf(" 广义表g2:");DispGL(g2);printf("\n\n");printf(" 广义表g1和g2%s\n\n",(Same(g1,g2)?"相同":"不相同"));g3=CreatGL(str3);printf(" 广义表g3:");DispGL(g3);printf("\n");printf(" 删除广义表g3的第一个为'a'的原子\n");DelAtom(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");printf(" 删除广义表g3中的所有'a'原子\n");DelAtomAll(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");g4=CreatGL(str4);printf(" 广义表g4:");DispGL(g4);printf("\n");printf(" 采用先根遍历g4的结果:");PreOrder(g4);printf("\n\n");}。

数据结构与算法上机作业

数据结构与算法上机作业第三章树一、选择题1、在一棵树中,如果结点A有3个兄弟,B就是A得双亲,则B得度为 DA、1B、2C、3D、42、深度为h得完全二叉树至少有 D 个结点,至多有 B 个结点A、2hB、2h-1C、2h+1D、2h-13、具有n个结点得满二叉树有 C 个叶结点。

A、n/2B、(n-1)/2C、(n+1)/2D、n/2+14、一棵具有25个叶结点得完全二叉树最多有 C 个结点。

A、48B、49C、50D、515、已知二叉树得先根遍历序列就是ABCDEF,中根遍历序列就是CBAEDF,则后根遍历序列就是 A 。

A、CBEFDAB、FEDCBAC、CBEDFAD、不定6、具有10个叶结点得二叉树中有 B 个度为2得结点。

A、8B、9C、10D、117、一棵非空二叉树得先序遍历序列与后序遍历序列正好相反,则该二叉树一定满足B 。

A、所有非叶结点均无左孩子B、所有非叶结点均无右孩子C、只有一个叶子结点D、A与B同时成立8、在线索二叉树中,t所指结点没有左子树得充要条件就是 D 。

A、t->left=NULLB、t->ltag=TRUEC、t->ltag=TRUE且t->left=NULLD、以上都不对9、n个结点得线索二叉树上含有得线索数为 C 。

A、2nB、n-1C、n+1D、n10、二叉树按照某种顺序线索化后,任一结点都有指向其前驱与后继得线索,这种说法 B 。

A、正确B、错误C、不确定D、都有可能11、具有n(n>1)个结点得完全二叉树中,结点i(2i>n)得左孩子结点就是 D 。

A、2iB、2i+1C、2i-1D、不存在12、具有64个结点得完全二叉树得深度为 C 。

A、5B、6C、7D、813、将一颗有100个结点得完全二叉树从上到下、从左到右一次对结点进行编号,根结点得编号为1,则编号为45得结点得右孩子得编号为 D 。

A、46B、47C、90D、9114、在结点数为n得堆中插入一个结点时,复杂度为 C 。

数据结构上机作业6-10章

6.33③假定用两个一维数组L[1..n]和R[1..n]作为有n个结点的二叉树的存储结构，L[i]和R[i]分别指示结点i的左孩子和右孩子，0表示空。

试写一个算法判别结点u是否为结点v的子孙。

要求实现以下函数：Status Dencendant(Array1D L,Array1D R,int n,int u,int v);一维数组类型Array1D的定义：typedef int Array1D[MAXSIZE];Status Dencendant(Array1D L,Array1D R,int n,int u,int v){ if(L[v]==u||R[v]==u) return TRUE;if(L[v])if(Dencendant(L,R,n,u,L[v])) return TRUE;if(R[v])if( Dencendant(L,R,n,u,R[v]) )return TRUE;else return FALSE;}6.34③假定用两个一维数组L[1..n]和R[1..n]作为有n个结点的二叉树的存储结构，L[i]和R[i]分别指示结点i的左孩子和右孩子，0表示空。

试写一个算法,先由L和R建立一维数组T[1..n]，使T中第i(i=1,2,..., n)个分量指示结点i的双亲，然后判别结点u是否为结点v的子孙。

要求实现以下函数：Status Dencend(Array1D L, Array1D R, int n, int u, int v, Array1D T);一维数组类型Array1D的定义：typedef int Array1D[MAXSIZE];Status Dencend(Array1D L, Array1D R, int n, int u, int v, Array1D T){ int i;for( i = 1; i <= n; ++i )T[L[i]] = i;for( i = 1; i <= n; ++i )T[R[i]] = i;while(T[u]!=0){if(T[u]==v)return TRUE;u=T[u];}return FALSE;}6.36③若已知两棵二叉树B1和B2皆为空，或者皆不空且B1的左、右子树和B2的左、右子树分别相似，则称二叉树B1和B2相似。

数据结构线性表上机报告

数据结构（Data Structure）上机报告学号********姓名********专业班级********时间********一上机的目的和要求1．掌握线性结构中顺序表和链表的基本概念、基本操作和应用；2．掌握线性表的基本操作：建表、插入、删除、输出等运算在顺序存储结构和链式存储结构上的实现。

3．通过本次实习加深对高级语言C语言的使用（特别是函数参数、指针类型、链表的使用）。

熟悉线性表的基本运算在两种存储结构（顺序结构和链式结构）上的实现。

二基本知识和原理（一）线性表是最常用的而且也是最简单的一种数据结构，简言之，一个线性表是N个数据元素的有限序列。

至于每个数据的具体含义，在不同的情况下各不相同，它可以是一个数或一个符号，也可以是一页书，甚至其他更复杂的信息。

例如26个英文元素的字母表（A，B，C，D，···），其数据结构的描述为：Linear_list=(D，R)其中，D={ ai |ai属于ElemSet，i=1，2，3，···}，R={<ai-1，ai>| i=2，3，4，…… }。

本实验是以数组的形式把线性表存放在计算机内存的一个连续的区域内，这样便有：LOC(ai+1)=LOC(ai)+mLOC(ai)=L0+m*(i-1)（二）程序说明插入一个新元素到第i个位置，既把元素ai向后移一个位置，成为元素ai+1，把新元素放入到第i个位置，其他元素依次后移。

插入后的表长是n+1（n 是原表长）。

修改第i个元素，到第i个位置是把元素ai冲掉后存上新值。

删除第i个元素就是把余后的元素依次向前移一个位置。

即：以元素ai+1，ai+2，···，依次取代ai，ai+1，···。

删除后的表长是n-1（n是原表长）。

三程序算法分析及实现（代码）一链表#include<stdio.h>#include<stdlib.h>struct linknode/*链表结构声明*/{int data; /*存储结点数据*/struct linknode *next; /*指向下一个结点*/};typedef struct linknode LinkNode; /*定义新类型*/LinkNode *CreatLinkNode() /*链表的创建*/{int i;LinkNode *head, *ptr, *p; /*链表结点*/head = (LinkNode *)malloc(sizeof(LinkNode)); /*分配内存*/ if (!head) /*检查指针内存是否分配成功*/{printf("内存分配失败!\n");exit(1); /*退出*/}printf("请输入第1个数据：");scanf("%d", &head->data); /*创建结点内容*/head->next = NULL; /*设置指针初值*/ptr = head; /*ptr指向链表开始*/for (i = 1; i<5; i++) /*循环创建结点*/{p = (LinkNode *)malloc(sizeof(LinkNode));if (!p){printf("内存分配失败!\n");exit(1);}printf("请输入第%d个数据：", i + 1);scanf("%d", &p->data);p->next = NULL;ptr->next = p; /*连接结点*/ptr = ptr->next; /*指向下一个结点*/}return head;}LinkNode *FindNode(LinkNode *head, int num) /*链表的遍历*/{LinkNode *ptr;ptr = head; /*指向链表起始*/while (ptr != NULL) /*遍历链表*/{if (ptr->data == num) return ptr; /*查找编号*/ptr = ptr->next; /*指向一下结点*/}return ptr;}LinkNode *InsertNode(LinkNode *head, LinkNode *ptr, int vlaue) /*链表结点的插入*/ {LinkNode *newnode = (LinkNode *)malloc(sizeof(LinkNode)); /*分配内存*/if (!newnode) return NULL;newnode->data = vlaue; /*创建结点内容*/newnode->next = NULL; /*设置指针初值*/if (ptr == NULL){newnode->next = head; /*新结点称为链表开始*/return newnode;}else{if (ptr->next == NULL) ptr->next = newnode; /*是否是链表结束指向新结点*/else{newnode->next = ptr->next; /*新结点指向下一个结点*/ptr->next = newnode; /*结点ptr指向新结点*/}}return head;}LinkNode *DeleteNode(LinkNode *head, LinkNode *ptr) /*链表结点删除*/{LinkNode *pre; /*指向前一结点*/if (ptr == head) /*是否是链表的开始*/return head->next; /*输出第二个结点*/else{pre = head;while (pre->next != ptr) /*找结点ptr的前结点*/pre = pre->next;if (ptr->next == NULL) /*是否是链表的结束*/pre->next = NULL; /*最后一个结点*/elsepre->next = ptr->next; /*中间结点*/ }free(ptr); /*释放结点内存*/return head;}void PrintNode(LinkNode *ptr) /*链表输出*/{while (ptr != NULL) /*链表遍历循环*/{printf("%d\t", ptr->data); /*输出结点数据*/ptr = ptr->next; /*指向下一结点*/}printf("\n");}void FreeLinkNode(LinkNode *head) /*链表的内存释放*/{LinkNode *ptr;while (head != NULL){ptr = head;head = head->next;free(ptr);}}int main(){int num, value;LinkNode *head, *ptr; /*指向链表开始*/head = CreatLinkNode(); /*创建链表*/PrintNode(head); /*输出链表*/printf("请输入要查找的数据：\n");scanf("%d", &num);ptr = FindNode(head, num); /*查询数据*/if (!ptr)printf("没有找到\n"); /*没有查询到*/else{printf("找到啦！\n请输入要插入的数据：\n");scanf("%d", &value);head = InsertNode(head, ptr, value); /*插入数据*/PrintNode(head); /*输出链表*/}printf("请输入要查找并删除的数据：\n");scanf("%d", &num);ptr = FindNode(head, num);if (!ptr)printf("没有找到\n");else{printf("找到\n");head = DeleteNode(head, ptr);PrintNode(head);}FreeLinkNode(head); /*释放链表*/return 0;}二顺序表#include<stdio.h>#include<stdlib.h>#define MAXLISTSIZE 1024 /* 定义顺序表最大容量 */typedef struct/* 定义顺序表节点类型 */{int data[MAXLISTSIZE]; /* 顺序表*/int last; /*顺序表元素个数 */}linearlist;void ListList(linearlist* list) /* 打印线性顺序表 */{int i;printf("当前线性表的状态:\n");if (list->last == 0) /*顺序表为空*/printf("当前顺序表为空");elsefor (i = 0; i < (list->last); i++) /*循环遍历顺序表*/printf("[%4d]", list->data[i]); /*输出元素*/printf("\n");}void Output(linearlist* list) /* 打印说明文档 */{system("cls"); /* 清屏 */printf("- 顺序表 -\n"); /* 输入功能菜单 */ printf("- a: 追加一个节点 i: 插入一个节点 -\n");printf("- d: 删除一个节点 e: 退出 -\n");ListList(list); /* 打印线性顺序表 */}linearlist* CreateList()/* 创建线性顺序表 */{linearlist *list = (linearlist*)malloc(sizeof(linearlist)); /* 分配空间 */ list->last = 0; /* 初始化头节点值 */return list; /* 返回初始化头节点指针 */}void AppendNode(linearlist* list, int n) /* 追加节点 */{if (list->last < MAXLISTSIZE) /*顺序表不溢出 */{list->data[list->last] = n; /* 初始化节点值 */list->last += 1; /* 顺序表长度加1 */}}void InsertNode(linearlist* list, int n, int pos) /* 插入节点 */{int j;if (pos < 0 || pos > list->last)printf("所插入的位置超出顺序表的范围\n");else{for (j = list->last; j >= pos; j--) /*逆向遍历顺序表*/list->data[j + 1] = list->data[j]; /*元素后移*/list->data[pos] = n; /*指向节点赋值*/list->last++; /* 顺序表长度加1 */}}void DeleteNode(linearlist* list, int pos) /* 删除节点 */{int j;if ((pos < 0) || (pos > list->last)) /* 删除位置超出顺序表的范围 */ printf("所要删除的位置超出顺序表的范围\n");else{for (j = pos; j < list->last; j++) /*遍历顺序表*/list->data[j] = list->data[j + 1]; /*元素前移*/list->last--; /* 顺序表长度减1 */}}int main(){int key, pos; /*key元素值，pos下标 */char ch;linearlist *list;list = CreateList(); /* 创建顺序表*/while (1){Output(list);printf("请选择:");ch = getchar(); /*接受选项*/fflush(stdin); /*清除缓存*/if (ch == 'a') /*追加*/{printf("请输入要追加的数据:");scanf("%d", &key);AppendNode(list, key);}else if (ch == 'i') /*插入*/{printf("请输入要插入的数据的位置:");scanf("%d", &pos);printf("请输入要插入的数据:");scanf("%d", &key);InsertNode(list, key, pos);}else if (ch == 'd') /*删除*/{printf("请输入要删除的数据的位置:");scanf("%d", &pos);DeleteNode(list, pos);}else if (ch == 'e') /*退出*/exit(0);Output(list);fflush(stdin); /*清除缓存*/}return 0;}四结果分析及测试相关记录链表：五实验体会和学习感悟刚接触数据结构时，觉得好难，学习了一段时间之后，发现果然如此。

数据结构上机报告-范例

int OrderInsert_Sq(SqList &La, ElemType x) //在非递减有序表中插入一个元素
intDelete_Sq(SqList &L, ElemType x) //删除找到的第一个元素x
intDeleteAll_Sq(SqList &L,ElemType x) //删除所有值为x的元素
intListDelete_Sq(SqList &L,inti,int&e) //删除第i个元素
intLocateElem_Sq(SqList L, ElemType e) //查找元素e，若存在，返回位置，否则返回0
voidMergeList_Sq(SqList La,SqList Lb,SqList &Lc) //合并两个有序表
基本要求
1.实现顺序表的基本操作，包括顺序表的初始化、第i个元素前插入一个新的元素、删除第i个元素、查找某元素、顺序表的销毁。
2.写一个函数，建立并显示含有n个整数的顺序表
3.写一个函数，实现对有序表（非递减）插入一个元素的功能
4.写一个函数，实现两个有序（非递减）表合并生成新的有序表的功能
5.编写一个界面友好的测试程序，能够对各种边界条件进行测试，验证上述算法的正确性。
《数据结构》上机报告
2011年月日
姓名：
学号：
班级：
得分：
试验题目
顺序表
实验目的
理解顺序表的逻辑结构和存储结构，熟练掌握顺序表的相关操作。
问题描述
顺序表是指采用顺序存储结构的线性表，它利用内存中的一片连续存储区域存放表中的所有元素。可以根据需要对表中的所有数据进行访问，元素的插入和删除可以在表中的任何位置进行。

《数据结构》上机作业——实验报告（五）[推荐]

《数据结构》上机作业——实验报告（五）[推荐]第一篇：《数据结构》上机作业——实验报告(五)[推荐]“计算机软件技术基础”课程实验报告（五）实验名称：排序算法班级_______ 姓名__________ 学号______实验日期：实验机时：3 学时实验成绩：-----------------一.实验目的：1、掌握主要排序算法的思想和实现技术。

二.实验内容：1、设计一程序，要求：输入学生“软件技术基础”课的成绩（学号、姓名、平均成绩、总学分）；按总学分对学生数据进行排序。

（要求：实现任选3种排序算法）三.程序：1、程序规范（输入数据、功能、输出数据）2、设计分析（数据表示、算法）3、C源代码（电子版）四.程序调试：第二篇：《数据结构》上机作业——实验报告(六)“计算机软件技术基础”课程实验报告（六）实验名称：数据库及SQL语言班级_______ 姓名__________ 学号______实验日期：实验机时：3 学时实验成绩：-----------------一.实验目的：1、学习数据库设计的一般过程及相关技术；2、学习access数据库管理系统；3、掌握数据库的输入、查询、更新操作。

二.实验内容：1、需求陈述：某校图书馆要建立一个图书数据管理系统。

该图书馆的图书（书名、分类号、作者、出版社）存放在不同的借阅室（室名），读者（姓名、系名、类别）在书架上找到所需图书后，可以到服务台办理借阅（借阅时间）。

设计要求：λ分析需求，建立数据库的概念模型；λ将概念模型转换为关系模型（注意：是否需要作规范化处理）；λ写出创建基本表的SQL语句；λ写出以下查询要求的SQL语句：（1）所有“高等数学习题集”书的信息；（2）读者“李林”借了什么书？（3）“社会学原理”在哪个借阅室？2、在access数据库管理系统中建立所设计的关系表；3、向各表中输入一组实验数据（元组）（注意：关系完整性）；4、对数据库进行查询。

三.实验结果：1、实体-关系图；2、数据库表；3、创建基本表的语句；4、查询语句。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

2011上机实习基本要求及内容
上机实习基本目标
计算机学科分为理论、抽象、设计三个形态。

数据结构是计算机学科的重要分支研究领域之一。

在算法分析与设计、操作系统、软件工程、数据库概论、编译技术、计算机图形学、人机交互等专业基础课和专业课程中均有涉及。

对特定领域或应用要使用到头特定的数据结构：编译系统要使用栈、散列表及语法树；操作系统中要用队列、存储管理表及目录树等；数据库系统要用线性表、多链表及索引树等；在人工智能领域依求解问题性质的差异将涉及到各种不同的数据结构，如广义表，集合、搜索树及各种有向图等等。

通过数据结构上机实习要让学生掌握链表、树、图是如何实现的，进一步从理论、抽象、设计的角度来考虑问题。

第一，让学生真正理解“数据结构＋算法＝程序”。

程序不仅仅是求解算法的实现，也要配有恰当的数据结构；第二，培养学生数据抽象的能力。

让学生了解链表、树、图等数据结构是如何实现的，特别要加强对数据逻辑关系的分析与认识；第三，培养学生使用数据结构的能力。

要把数据结构与算法的理论分析与编程实践相结合，灵活运用于实际解题中。

需要强调以下几个方面的知识和能力：
（1）掌握并能够灵活应用基本数据结构的抽象数据类型、存储方法、主要的算法，特别是线性结构、二叉树、树、图、文件等；
（2）掌握并应用常用的排序、检索和索引算法和方法；
（3）掌握基本的算法设计和分析技术，并结合具体的设计，对所设计的数据结构和算法进行分析；
（4）在进行程序设计、调试中，注意综合应用，将所学到的数据结构和算法知识应用到对具体数据对象的特性分析。

结合实际例子进行设计，选择合适的数据结构和存贮结构以及相应的算法。

上机实习基本要求
1．合理地选用组织数据、有效地表示数据、正确地处理数据，清晰地表述算法。

2．完成选定题目，按照规范格式（附件一）写出实习报告(原问题、设计算法、DS、程序、给出实例并分析结果、讨论T(n))。

3．线性关系、非线性关系、算法三部分的实习报告电子版提交日期在上机后2日内提交；第四次机考电子版在上机结束时提交(电子版交liuxd@，将四次上机汇总打印纸版笔试前1周交西1楼711室)；请按时提交注意上交电子版与纸版应一致。

4. 请按照附件给定报告内容格式安排。

附件一：报告封面格式
数据结构与算法B上机实习报告
第1次2011-9-dd 题目名称
第2次yyyy-mm-dd 题目名称
第3次yyyy-mm-dd 题目名称
第4次yyyy-mm-dd 题目名称
报告人：MMM
班级：信息nn
学号：nnnnnnnn
附件二：报告内容格式（封面见附件一。

正文要求：A4纸，小4#宋体，右下页码，最小行距）
一、上机实习题目（原问题解目标）
二、相关知识或技术（对应DS部分）
三、算法及数据结构设计（算法设计）
四、上机环境和使用语言（计算机程序实现）
五、源程序（带注释或说明）、运行结果（数据或屏幕显示、结果分析、讨论T(n)）
六、上机总结（体会提高）
七、参考资料
附件三：上机实习参考题目
（1）各个DS的插入、删除、建立、判空；
（2）线性链表操作——插入、删除、合并、排序、查找
（3）将一个递归程序转为非递归程序。

（4）编制标准算法，将两个线性表合并成一个。

（5）用一个数组S（设大小为MAX）作为对开栈的共享空间。

请说明共享方法、栈满/栈空的判断条
件，设计入栈操作push(i,x),其中i为0或1，用于表示栈号，x为入栈值；并设计清、判空、判满、
出栈操作。

（6）对于一个堆栈，若其入栈序列为1,2,3,...,n，不同的出入栈操作将产生不同的出栈序列。

其
出栈序列的个数正好等于节点个数为n的二叉树的个数，且与不同形态的二叉树一一对应。

请简要叙
述一种从堆栈输入（固定为1,2,3,...n）/输出序列对应一种二叉树形态的方法，并以入栈序列1,2,3
（即n等于3）为例加以说明。

（7）求Л到小数点后100位。

（8）长整数四则运算ADT与存储实现。

（9）树和二叉树的递归遍历/非递归遍历；
（10）求二叉树中最长/短路径。

（11）求最大平台问题（n个整数序列，相同值连续最大的称最大平台）。

（12）最小生成树；
（13）检索与查找算法。

（14）排序与广义表算法。

（15）为图书馆借书处/食堂售卡处业务设计一个业务系统完成日常的相关工作。

（16）为民航/火车售票处的票务业务设计一个计划、团体/零售、查询系统。

（17）已知二叉树中结点的左右儿子域分别为left和right。

p指向二叉树的某一节点。

请编一个非递归函数postfirst(p)，求p所对应子树的第一个后序（后根）遍历节点。

（18）已知树中结点的用左孩子右兄弟表示，p指向二叉树的某一结点。

请编遍历树算法。

（19）编程生成国际象棋棋盘，使马踏棋盘各格一次且仅一次。

（20）编程生成迷宫（平面，立体），指定出入口位置，找出一条/所有路径。

（21）图的遍历算法。

（22）求最大平台问题（n个字符的串，相同字符最长的）。

提示：教材各章后练习题、实习题均可选用。

也可选择最基本的ADT操作编程上机调试，作为课程考
核内容；要求认真精选上机题完成上机调试、获取实验结果、写出实习报告。