数据结构上机实验线性表单链表源代码
数据结构上机第一次 线性表-单链表
实验一线性表的基本操作—单链表本课程实验中已知的预定义常量和类型如下：#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */typedef int Boolean;/* Boolean是布尔类型,其值是TRUE或FALSE */一、实验目的与基本要求1. 掌握数据结构中的一些基本概念。
2. 掌握单链表的定义、存储结构及其基本操作。
二、实验内容已知线性表的单链表存储结构为：/* 线性表的单链表存储结构 */struct LNode{ElemType data;struct LNode *next;};typedef struct LNode *LinkList;/* 另一种定义LinkList的方法 */编写函数void CreateList(LinkList *L，int n)动态生成一个单链表。
（L为单链表的头指针，它指向表中的第一个结点。
）Status ListInsert(LinkList L , int i , int e)实现在单链表L中第i个位置之前插入新的数据元素e。
若插入成功返回OK，否则返回ERROR。
void ListPrint（LinkList L）实现将单链表的元素依次输出到屏幕上。
void ListDelete(LinkList L，int i，int * e)在单链表L中删除第i个元素，并由e返回其值。
若删除成功返回OK（1），否则返回ERROR （0）。
void Merge（LinkList La，LinkList Lb，LinkList *Lc）完成已知两个按值非递减有序排列的单链表La和Lb，归并La和Lb得到一个新的单链表Lc，Lc的元素也按值非递减有序排列。
(数据结构)线性表的链式表示和实现(源代码)
i++;
}while(p!=NULL);
returnOK;
}Байду номын сангаас
main()
{
structnode *head;
chara;
intn;
elemtypee;
while(1)
{
printf("1:构造一个线性表\n2:销毁线性表\n3:将已有线性表置为空表\n4：判断线性表是否为空\n5:计算已有线性表中数据元素的个数\n");
returnOK;
}
statusgetelem(node *head,inti,elemtype&e)
{
node*p;
p=head->next;
intn=1;
if(i<1)
{
printf("输入的i值不合法\n");
returnERROR;
}
while(n<i)
{
p=p->next;
n++;
}
if(p==NULL)
#define OVERFLOW -2
typedefintstatus;
typedefintelemtype;
#include"header.h"
structnode
{
elemtypedate;
structnode *next;
};
structnode*createlist(node *head,intn)
{
if(head==NULL)
returnOK;
else
returnERROR;
数据结构上机实验报告
else insert(lc,i/2,la.list[i]); //偶数位次元素插入lc
}
printf("\n您输入的线性表元素为:\n\n");
print(la);
printf("线性表的奇数位次的元素为：\n\n");
print(lb);
printf("线性表的偶数位次的元素为：\n\n");
print(lc);
}
void initial(sqlist &v)
{printf(" ****本程序可以实现线性表奇偶位序的元素分别输出****\n\n\n");
int i,a;
printf("请输入一个偶数作为线性表的长度：\n\n");
void initlist(sqlist &);
void print(sqlist); //输出线性表
void main()
{printf(" *****************本程序可以实现线性表的复制******************\n");
sqlist la,lb; //声明线性表
initial(la);
【程序设计细想】：
建立三个线性表la,lb,lc，对线性表la进行输入，然后利用循环结构对la中奇数位序的元素对lb进行插入操作，对偶数位序的元素对lc进行插入操作，从而得到线性表lb和lc。
【程序代码】：
#include<stdio.h>
#include<malloc.h>
数据结构上机实验源代码
数据结构上机实验源代码栈的应用十进制数转换为八进制数，逆序输出所输入的数实验代码：//stack.h，头文件class stack{public:stack();bool empty()const;bool full()const;error_code gettop(elementtype &x)const;error_code push(const elementtype x);error_code pop();private:int count;elementtype data[maxlen];};stack::stack(){count=0;}bool stack::empty()const{return count==0;}bool stack::full()const{return count==maxlen;}error_code stack::gettop(elementtype &x)const{if(empty())return underflow;else{x=data[count-1];return success;}}error_code stack::push(const elementtype x){if(full())return overflow;data[count]=x;count++;return success;}error_code stack::pop(){if(empty())return underflow;count--;return success;}//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"stack.h"void read_write() //逆序输出所输入的数{stack s;int i;int n,x;cout<<"please input num int n:";cin>>n;for(i=1;i<=n;i++){cout<<"please input a num:";cin>>x;s.push(x);}while(!s.empty()){s.gettop(x);cout<<x<<" ";s.pop();}cout<<endl;}void Dec_to_Ocx(int n) //十进制转换为八进制{stack s1;int mod,x;while(n!=0){mod=n%8;s1.push(mod);n=n/8;}cout<<"the ocx of the dec is:";while(!s1.empty()){s1.gettop(x);cout<<x;s1.pop();}cout<<endl;}void main(){int n;// read_write();cout<<"please input a dec:";cin>>n;Dec_to_Ocx(n);}队列的应用打印n行杨辉三角实验代码：//queue.hclass queue{public:queue(){count=0;front=rear=0;}bool empty(){return count==0;}bool full(){return count==maxlen-1;}error_code get_front(elementtype &x){if(empty())return underflow;x=data[(front+1)%maxlen];return success;}error_code append(const elementtype x){if(full())return overflow;rear=(rear+1)%maxlen;data[rear]=x;count++;return success;}error_code serve(){if(empty())return underflow;front=(front+1)%maxlen;count--;return success;}private:int count;int front;int rear;int data[maxlen];};//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"queue.h"void out_number(int n) //打印前n行的杨辉三角{int s1,s2;int i;int j;int k;queue q;for(i=1;i<=(n-1)*2;i++)cout<<" ";cout<<"1 "<<endl;q.append(1);for(i=2;i<=n;i++){s1=0;for(k=1;k<=(n-i)*2;k++)cout<<" ";for(j=1;j<=i-1;j++){q.get_front(s2);q.serve();cout<<s1+s2<<" ";q.append(s1+s2);s1=s2;}cout<<"1 "<<endl;q.append(1);}}void main(){int n;cout<<"please input n:";cin>>n;out_number(n);}单链表实验实验目的:实验目的（1）理解线性表的链式存储结构。
数据结构线性表试验报告（最终定稿）
数据结构线性表试验报告（最终定稿）第一篇：数据结构线性表试验报告线性表上机实习1、实验目的（1）熟悉将算法转换为程序代码的过程。
（2）了解顺序表的逻辑结构特性，熟练掌握顺序表存储结构的C 语言描述方法。
（3）熟练掌握顺序表的基本运算：查找、插入、删除等，掌握顺序表的随机存取特性。
（4）了解线性表的链式存储结构，熟练掌握线性表的链式存储结构的C语言描述方法。
（5）熟练掌握线性链表（单链表）的基本运算：查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。
2、实验要求（1）熟悉顺序表的插入、删除和查找。
（2）熟悉单链表的插入、删除和查找。
3、实验内容: ① 顺序表（1）抽象数据类型定义typedef struct {TypeData data[maxsize];//容量为maxsize的静态顺手表int n;//顺序表中的实际元素个数}SeqList;//静态顺序表的定义在本次实验中，首先建立一个空的静态顺序表，然后键盘输入数据存入表中，然后进入菜单选择界面，通过不同的数字输入，实现对顺序表，删除，插入，查找，显示等操作。
（2）存储结构定义及算法思想在顺序表结构体的定义中，typedef int TypeData 为整型，存储结构如下：for(n=0;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似，都是直接赋值与数组的某一位插入版块子函数：void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<k=L.data[b-1];L.data[b-1]=a;c=L.n;L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--;//通过循环，实现插入位置后的数据挨个往后移动一位}L.data[b]=k;} 顺序表的插入与删除操作类似，在插入与删除后，都要循环调整后面数组的每一位元素，同时记录数据元素的长度的标示符也要跟着改变。
数据结构实验5单链表配套代码
数据结构实验5 配套代码1、#include <stdio.h>#include <stdlib.h>#include <ctype.h>#define OK 1#define ERROR 0#define OVERFLOW -2#define MAXSIZE 100#define NULL 0typedef int Status;typedef int ElemType;typedef struct LNode{ElemType data; //数据域struct LNode *next; //指针域}LNode,*LinkList; // *LinkList为Lnode类型的指针int main(){LNode *La=NULL;char choice1,choice2,choice3; // 菜单选项ElemType b[MAXSIZE],b1[MAXSIZE],x,z;int i,num,num1,n,m,e,y;Status InitList_L(LinkList &L);void CreateList_L(LinkList &L,ElemType a[],int n);Status DispList_L(LinkList L);int ListEmpty(LinkList L);Status GetElem_L(LinkList L,int i,ElemType &e);int LocateELem_L (LinkList L,ElemType e);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);int ListLength_L(LinkList L);Status ClearList(LinkList & L);Status DestroyList_L(LinkList &L);InitList_L(La);printf("线性表中元素的个数?\n");scanf("%d",&num);printf("请输入元素:\n");for(i=0;i<num;i++)scanf("%d",&b[i]);CreateList_L(La,b,num);do{printf("\t单链表操作\n");printf("P-输出\t\tG-取值\n");printf("S-查找\t\tI-插入\n");printf("D-删除\t\tC-清空\n");printf("L-求表长\tQ-退出\n");scanf(" %c", &choice1);choice1 = toupper(choice1); //将字符choice转换为大写英文字母switch (choice1){case 'P':printf("线性表中的元素为:\n");DispList_L(La);break;case 'G':printf("要查找第几个元素?\n");scanf("%d",&n);m=GetElem_L(La,n,e);if(!m)printf("要查找的元素位置不合法!\n");elseprintf("要查找的第%d个元素是：%d\n",n,e);break;case 'S':printf("要查找的元素的值为：\n");scanf("%d",&x);m=LocateELem_L(La,x);if(!m)printf("线性表中不存在该元素!\n");elseprintf("%d是本表中的第%d个元素。
数据结构C语言版 线性表源代码
#include <stdio.h>#include <conio.h>#include <malloc.h>#include <stdlib.h>#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10#define OK 1#define ERROR -1#define OVERFLOW -1#define ENDFLAG 0typedef int Status;typedef int ElemType;#define OUTFORMAT "%d "#define INFORMAT "%d"typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList(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;}Status Inputdata(SqList *L){ ///////SqList *L定义首节点的地址ElemType temp,*newbase;printf("\nInput the data of the sequencial list:\nNote:0 is the ending flag:\n");scanf(INFORMAT,&temp);while(temp!=ENDFLAG){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;}L->elem[L->length++]=temp;scanf(INFORMAT,&temp);}return OK;}Status ListInsert(SqList *L,int i,ElemType e){ElemType *p,*q,*newbase;if(i<0||i>L->length)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;}void MyDisplay(SqList L){int i;for(i=0;i<L.length;i++)printf(OUTFORMAT,L.elem[i]);printf("\n");}void main(void){SqList L;ElemType temp;int i;if(!InitList(&L)) { ////如果初始化失败printf("To initialize the sequencial list fail\n");getch(); //////如果失败，按任意键退出exit(0);}if(!Inputdata(&L)){printf("To input the data of the sequencial list fail\n");getch();exit(0);}MyDisplay(L);printf("Input the data that you want to insert:");scanf(INFORMAT,&temp);printf("Input the insert_location:");scanf("%d",&i);if(!ListInsert(&L,i,temp)){printf("To insert fail\n");getch();exit(0);}MyDisplay(L);getch();}。
(数据结构)线性表的链式表示和实现(源代码)
数据结构实验线性表的链式表示和实现（源代码）件inc lude<stdio・h>#tnclude<malloc,h>#include<stdl)b.h>#define TURElttdefine FALSE 0ttdefine OK 1ttdefine ERROR 0ffdefine INEEASLIBE -1#define OVERFLOW -2 typedefint status; typ edefi ntelemty pe; struct nodeelemty pe date; struct node *next;struct node* createlistfnode *headjnt n)printf(“输入的n值不合法\汕); return head;node *p/q;head={struct node*)malloc(sizeof(struct node)); ifllhead) return head; head->next=NULL; head->date=n; q=head;inti=O;for(;i<n;)p=(struct no de*)malloc(sizeof(struct node));printf(“诸输入创建的结点数拯元索的scanf("%d'\&p・>datg);getcharO;p->next=NULL; q->next=p; q=P； i++；systemC^cIs"); return head;struct node* clearlistfnode *head)head=NULL; return head;status destroylist(node *head)head=NULL; free(head); return OK; statuslistempty(node *head)if|head==NULL)return OK;elsereturn ERROR;statusiist!ength(node *head)inti=0; node *p;p=head->next; while ⑴i++； if(p->next==NULL) break;p=p->next；prints该线性表的表长为%d\n\i);return OK;statusgetelem(node *headjnti,elemtype&e)node *p; p=head-> next; int n=1;printfC输入的i傅不合法\屮); return ERROR;while(n<i)p=p・> next;n++;iflp==NULL)printT输入的i值不合法W); return ERROR;e=p->date; return OK;statuslocatelemfnode *head,elemtvpe e)node *p; inti=l; p=head->next; while ⑴if(p->date==e&&p==NULL) break;p=p->next;i++；if)p==NULL)prints该线性表中没有％d这个数据元索\吧6);return ERROR;printfC-%d存在该线性表的第％d位\叭巳i）; return OK; statuspnorelem(node *headjntbelemtype&e)printfC该位上的数据元素为一个元索没有直接前驱元^\nj; return ERROR;struct node *p/q; p=head->next;int j=l;for(;p!=NULL;p=p->next)break;q=p;j++； iflp!=NULL)e*q・>date;printf（“该元索有数据元素并且直接前驱元索已传递给0\""）; returnOK;elseprintfC输入的i值不合法\门”); return ERROR;statusnextelem(node *head,inti,elenritype&e) struct node *p; p=head->next;int j=O;for(;p->next!=NULL; p=p->next)j++；break;iflp->next!=NULL)e=p・> next->date;printf（“该位上有后继元索且K接后继元索的垃已传递给e\n“）;return OK;if(p->next==：NULL&&(j+l)Ki)prints该位上的数据元素为最后一个元素没有直接后继元素Vn； returnERROR;else if(p==NULL&&{j+l)<i)printT输入的i值不合法W); return ERROR;struct node* insert(node *headjnti,elemtype e)printfC输入的i值不合法\门”); return head;struct node *q/p;q=head;int j=l;p=(struct no de*)malloc(sizeof(struct n ode)); p ・>date=e;while(j<i)if(q・>next==NULL) break;q=q->next; j++；p・> next=q->next; q・>next=p;elseprints输入的i值不合法\小;return head;struct node* delete_node{node *head,inti,elemtype&e)printf(”输入的i值不合法W); return head;struct node *p,*q; p 二head;int j=l; while(j<i)if(p・> next->next==NULL) break;p=p・> next;j++；q=p・>n ext;p ・>next=p・> next->next;e=q->date;free(q);ifijd)printfr输入的i值不合法\叶1;return head;status trip(node *head)struct node *p; p=head->next; inti=l;doprintf("第％d 位=~%d\n'\i,p*>datG); p=p・> next;i++；}vzhile(p!=NULL);return OK;main()struct node *head; char a,int n; elemty pe e; while(l)printfCl:构造一个线性後\"2:销毁线性表\n3:将已有线性表置为空表\"4：判断线性衣是否为空\n5:计算已有线性表中数据元素的个数\n”)；printfC'6:取出元索的值\n7:定位元索的位置\n8:插入新的数据元索\n9:删除某一个数据元索\冋显示该线性表中全部的元索W);printfC'b:取出特定位置的貞接前驱元素\皿:取出特定位置上直接后继元素00:退出\n\n\n'*);scanf("%c'\&a);getcharO;systemCcIs”)；switch(a)case O: exit(O);case T:printf("请输入需要创建元索的个数n\n"); scanf(” ％d”,&n);getcharO;head=createlist(head,n); break;case 2:if(destroylist{head)==OK)head=NULL;free(head);prints线性表销毁成功\");break;case 3:clearlist(head);printf(“线性表以置为空表\""); break;case '4':if(listempty(head)==OK) phntfC*线性表为空表\n“)； elsephntfC'线性表不为空表匕“)；break;case S:listlength(head);break;case '6':Printf(“请输入需要取出元素的位数冲“)；scanf(”％cr：&n);getcharO；P rintf("\n");getelem(head,n,e);printf("第％d位数据元索的值为%d\n'\n,e); break;case 7:p hntfC'W输入需要定位元素的值e=");scanfC'%d\&€);getcharO;P rintfCAn-);locatelem(head,e);break;case 8:printf(”请输入需要插入的位置n=");scanf(”％cr：&n);getcharO;printfCAn该位置上的数据元素的值曰)；scanf(-%cl\&e)； getcharO;p hntf("\n");head=insert(head, n^e);break;case 9:Printf(“诸输入需要删除的位置n=-); scanfr%cr&n); getcharO;delGte_node(head,n,G);printf(" C•删除第％(1位上的数据元素％d\n",n,e); break；case N:tnp(head);break;case V:phntfC'i#输入需要取出直接前驱元素的位数n=**)； scanfC'% cT&n);getcharO;if(p norelem(head,n,e)==OK)printf("\n第％€1位的直接前驱元素为%d\n'\n,e); break;case 'c';pmtf(“诸输入需要取出克接后继元素的位数冲“)； scanf("%d'\&n);getcharO；if(nextelem(head,n,e)==OK)printf("\n第％＜1位的直接后继元索为%d\n'\n,e); break；default:printf(”输入不合法 ... 请选择：\n'");printf("\n\n\n'');。
数据结构单链表实验代码
数据结构单链表实验代码1.有一个单链表的第一个节点指针为head，编写一个函数将该单链表逆置，即最后一个节点变成第一个节点，原来倒数第二个节点变成第二个节点，如此等等，在逆置中不能建立新的单链表。
#include#include#define bs -1typedef int db;typedef struct xiangjia{db data;struct xiangjia *next;}lb;lb *tou(){lb *L;L=(lb *)malloc(sizeof(lb));L->next=NULL;return L;}void get(lb *l){lb *L,*h;db x;L=l;printf("请输入你的数据,并在末尾输入-1以示结束\n\n");scanf("%d",&x);while(x!=bs){h=(lb *)malloc(sizeof(lb)); h->data=x;h->next=L->next;L->next=h;scanf("%d",&x);}}void put(lb *l){lb *L;L=l;printf("链表中的数据有:\n"); while(L->next!=NULL) {printf("%d",L->next->data); L=L->next;if(L->next!=NULL){printf("->");}}printf("\n");}main(){lb *a;a=tou();get(a);printf("逆序后的整数表:"); put(a);}2.编写程序，将若干整数从键盘输入，以单链表形式存储起来，然后计算单链表中结点的个数（其中指针P指向该链表的第一个结点）。
《数据结构》实验3链表
三、源代码以及实验结果为
四、源代码以及实验结果为
五、源代码以及实验结果为
六、源代码以及实验结果为
七、附加题以及实验体会：
{
NODE *s; /*定义指向结点类型的指针*/
s=(NODE *)malloc(sizeof(NODE));
/*生成新结点*/
3
4
5
return 1;
}
/*删除P所指向的结点的后继结点*/
void DelLinkList(NODE *p)
{ NODE *q;
if(p->next!=0)
{ q=p->next; /* q指向p的后继结点*/
ch=getchar();
while(ch!='$')
{ p=(NODE *)malloc(sizeof(NODE));
p->data=ch;
1
2
ch=getchar();
}
return (head);
}
/*在链表的P指定结点之后插入值为x的结点*/
int InsLinkList(NODE *p, char x)
四、设有两个单链表A、B，其中元素递增有序，编写算法将A、B归并成一个按元素值递减（允许有相同值）有序的链表C，要求用A、B中的原结点形成，不能重新申请结点。
五、已知单链表表示的线性表中含有两类的数据元素（字母字符，数字字符）。试设计算法，按结点的值将单链表拆分成两个循环链表，分别只含有数字或字母。要求：利用原表中的结点空间作为这两个表的结点空间，头结点可另开辟空间。
附加题：如果换成循环单链表该如何实现？
即题目变成：已知单循环链表表示的线性表中含有两类的数据元素（字母字符，数字字符）。试设计算法，按结点的值将单链表拆分成两个循环链表，分别只含有数字或字母。
数据结构实验代码汇总
destptr->link = new LinkNode<T>(srcptr->link->data);
if(destptr->link == NULL) {
cerr << "存储分配失败!" << endl;
exit(1);
}
destptr = destptr->link;
srcptr = srcptr->link; } destptr->link = NULL; return *this; } }; #include "List.cpp" #endif
first = new LinkNode<T>; if(first == NULL) {
cerr << "存储分配失败!" << endl; exit(1); } } template <class T> List<T>::List(const T x) { first = new LinkNode<T>(x); if(first == NULL) { cerr << "存储分配失败!" << endl; exit(1); } } template <class T> List<T>::List(List<T>& L) { LinkNode<T> *srcptr = L.first; LinkNode<T> *destptr = first = new LinkNode<T>(srcptr->data); if(first == NULL) { cerr << "存储分配失败!" << endl; exit(1); } while(srcptr->link != NULL) { destptr->link = new LinkNode<T>(srcptr->link->data); if(destptr->link == NULL) {
数据结构 线性表 实验代码
#include <stdio.h>#include <stdlib.h>#include<conio.h>struct SQList{int elem[100];int len;} ;SQList creat_SQList()//创建一个线性表{SQList l;int i=0;printf("请输入顺序表");scanf("%d",&l.elem[i]);while(l.elem[i]!=0){i++;scanf("%d",&l.elem[i]);}l.len=i;return l;}void print_SQList(SQList l)//顺序表输出{int i;printf("顺序表中的元素是：\n");for(i=0;i<l.len;i++){printf("%3d",l.elem[i]);}printf("\n");}SQList Merge_SQList(SQList LA,SQList LB,SQList LC)//顺序表合并{int i=0;int j=0;int k=0;while(i<LA.len&&j<LB.len){ if(LA.elem[i]<=LB.elem[j]){LC.elem[k++]=LA.elem[i];i++;}else {LC.elem[k++]=LB.elem[j];j++;}}while(i<LA.len){LC.elem[k++]=LA.elem[i++];}while(j<LB.len){LC.elem[k++]=LB.elem[j++];}LC.len=LA.len+LB.len;return (LC);}SQList SQList_insert(SQList s,int i,int x)//插入一个元素{int j;if(i<0||i>s.len)printf("插入位置不存在");else{for(j=s.len;j>=i;j--)s.elem[j+1]=s.elem[j];s.elem[i]=x;s.len=s.len+1;}//print_SQList(s);return s;}SQList SQList_delete(SQList s,int i)//删除元素{int j;if(i<0||i>s.len)printf("i位置不存在");else{for(j=i;j<s.len;j++)s.elem[j]=s.elem[j+1];s.len--;}//print_SQList(s);return s;}void main()//主菜单{SQList LA,LB,LC;int i,y,cord;//clrsor();do{printf("\n 主菜单\n");printf("1 建立线性表\n");printf("2 插入一个元素\n");printf("3 删除一个元素\n");printf("4 合并线性表\n");printf("5 退出\n");printf("-----------------------\n");printf("请输入你的选择（1,2,3,4,5）");scanf("%d",&cord);switch(cord){case 1:{LA=creat_SQList();LB=creat_SQList();printf("list LA:");print_SQList(LA);printf("list LB:");print_SQList(LB);}break;case 2:{printf("请输入插入位置及元素：");scanf("%d,%d",&i,&y);LA=SQList_insert(LA,i,y);printf("list LA");print_SQList(LA);}break;case 3:{printf("请输入删除位置");scanf("%d",&i);LA=SQList_delete(LA,i);printf("list LA");print_SQList(LA);}break;case 4:{printf("线性表合并：");LC=Merge_SQList(LA,LB,LC);printf("list LC");print_SQList(LC);}break;case 5: exit(0);}}while(cord<=5); }。
数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法，1为插入，2为删除，3为查询！4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);
实验一：线性表操作 数据结构系统上实验代码
#include<stdio.h>#include<malloc.h>#define OK 1#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define ElemType inttypedef struct{int *elem,length,listsize;}SqList;int InitList_Sq(SqList &L){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}int Load_Sq(SqList &L){int i;if(L.length==0)printf("The List is empty!");else{printf("The List is:");for(i=0;i<L.length;i++)printf("% d",L.elem[i]);}printf("\n");return OK;}int ListInsert_Sq(SqList &L,int i,int e){if(i<1||i>L.length+1)return ERROR;ElemType *newbase,*q,*p;if(L.length>=L.listsize){newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));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;}int ListDelete_Sq(SqList &L,int i,int &e){ElemType *q,*p;if(i<1||i>L.length)return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;p++)*(p-1)=*p;L.length--;return OK;}int main(){SqList T;int a,i;ElemType e,x;if(InitList_Sq(T)){printf("A Sequence List Has Created.\n");}while(1){printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d%d",&i,&x);if(!ListInsert_Sq(T,i,x))printf("Insert Error!\n");elseprintf("The Element %d is Successfully Inserted!\n",x);break;case 2: scanf("%d",&i);if(!ListDelete_Sq(T,i,e))printf("Delete Error!\n");elseprintf("The Element %d is Successfully Deleted!\n",e);break;case 3: Load_Sq(T);break;case 0: return 1;}}}222222222222222222222222222222222222222222222222222222222222222222222222222222 #include<stdio.h>#include<malloc.h>#define OK 1#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define ElemType inttypedef struct{int *elem,length,listsize;}SqList;int InitList_Sq(SqList &L){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}int Load_Sq(SqList &L){int i;for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");return OK;}int ListLength(SqList L){return L.length;}int GetElem(SqList L,int i,ElemType &e){e=L.elem[i-1];return OK;}int ListInsert_Sq(SqList &L,int i,int e){if(i<1||i>L.length+1)return ERROR;ElemType *p,*q,*newbase;if(L.listsize<=L.length){newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));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;}void MergeList(SqList La,SqList Lb,SqList &Lc){int i,j,k,La_len,Lb_len,ai,bj;i=j=1;k=0;InitList_Sq(Lc);La_len=ListLength(La);Lb_len=ListLength(Lb);while((i<=La_len)&&(j<=Lb_len)){GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ListInsert_Sq(Lc,++k,ai);i++;}else{ListInsert_Sq(Lc,++k,bj);j++;}}while(i<=La_len){GetElem(La,i++,ai);ListInsert_Sq(Lc,++k,ai);}while(j<=Lb_len){GetElem(Lb,j++,bj);ListInsert_Sq(Lc,++k,bj);}Load_Sq(Lc);}int main(){int an,bn,i,e;SqList La,Lb,Lc;InitList_Sq(La);scanf("%d",&an);for(i=1;i<=an;i++){scanf("%d",&e);ListInsert_Sq(La,i,e);}printf("List A:");Load_Sq(La);InitList_Sq(Lb);scanf("%d",&bn);for(i=1;i<=an;i++){scanf("%d",&e);ListInsert_Sq(Lb,i,e);}printf("List B:");Load_Sq(Lb);printf("List C:");MergeList(La,Lb,Lc);return 0;}333333333333333333333333333333333333333333333333333333333333333333333333333333 #include<stdio.h>#include<malloc.h>#define OK 1#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define ElemType inttypedef struct{int *elem,length,listsize;}SqList;int InitList_Sq(SqList &L){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem){printf("NO1");return ERROR;}L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}int Load_Sq(SqList &L){int i;if(!L.length){printf("This List is empty!\n");return ERROR;}else{for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);}printf("\n");return OK;}int ListInsert_Sq(SqList &L,int i,int e){ElemType *newbase,*p,*q;if(L.length>=L.listsize){newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase){printf("NO2");return ERROR;}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;}int swap(SqList &L,int n){int i,j,temp;for(i=0,j=n-1;j>i;i++,j--){temp=L.elem[i];L.elem[i]=L.elem[j];L.elem[j]=temp;}return OK;}int main(){SqList T;int n,i;ElemType x;scanf("%d",&n);InitList_Sq(T);for(i=1;i<n+1;i++){scanf("%d",&x);ListInsert_Sq(T,i,x);}printf("The List is:");Load_Sq(T);swap(T,n);printf("The turned List is:");Load_Sq(T);return 0;}444444444444444444444444444444444444444444444444444444444444444444444444444444 #include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define ElemType inttypedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n){LinkList p,q;int i;ElemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;for(i=0;i<n;i++){scanf("%d",&e);p=(LinkList)malloc(sizeof(LNode));p->data=e;p->next=q->next;q->next=p;q=q->next;}return OK;}int LoadLink_L(LinkList &L){LinkList p=L->next;if(!p)printf("The List is empty!");else{printf("The LinkList is:");while(p){printf("%d ",p->data);p=p->next;}}printf("\n");return OK;}int LinkInsert_L(LinkList &L,int i,ElemType e) {LNode *p=L,*s;int j=0;while(p&&j<i-1){p=p->next;j++;}if(!p||j>i-1)return ERROR;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}int LinkDelete_L(LinkList &L,int i,ElemType &e) {LNode *p=L,*q;int j=0;while(p->next&&j<i-1){p=p->next;j++;}if(!(p->next)||j<i-1)return ERROR;q=p->next;p->next=q->next;e=q->data;free(q);return OK;}int main(){LinkList T;int a,n,i;ElemType x,e;printf("Please input the init size of the linklist:\n");scanf("%d",&n);printf("Please input the %d element of the linklist:\n",n);if(CreateLink_L(T,n)){printf("A Link List Has Created.\n");LoadLink_L(T);}while(1){printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1:scanf("%d%d",&i,&x);if(!LinkInsert_L(T,i,x))printf("Insert Error!\n");elseprintf("The Element %d is Successfully Inserted!\n",x);break;case 2:scanf("%d",&i);if(!LinkDelete_L(T,i,e))printf("Delete Error!\n");elseprintf("The Element %d is Successfully Deleted!\n",e);break;case 3:LoadLink_L(T);break;case 0:return 1;}}}555555555555555555555555555555555555555555555555555555555555555555555555555555 #include<stdio.h>#include<malloc.h>#define ERROR 0#define OK 1#define ElemType inttypedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int CreateLink_L(LinkList &L,int n){LinkList p,q;int i;ElemType e;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;q=(LinkList)malloc(sizeof(LNode));q=L;for(i=0;i<n;i++){scanf("%d",&e);p=(LinkList)malloc(sizeof(LNode));p->data=e;p->next=q->next;q->next=p;q=q->next;}return OK;}int LoadLink_L(LinkList &L){LinkList p=L->next;if(!p)printf("The List is empty!");else{while(p){printf("%d ",p->data);p=p->next;}}printf("\n");return OK;}void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc) {LinkList pa,pb,pc;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else{pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;free(Lb);}int main(){LinkList La,Lb,Lc;int n;scanf("%d",&n);CreateLink_L(La,n);printf("List A:");LoadLink_L(La);scanf("%d",&n);CreateLink_L(Lb,n);printf("List B:");LoadLink_L(Lb);MergeList_L(La,Lb,Lc);printf("List C:");LoadLink_L(Lc);return 0;}。
北邮数据结构实验一线性表及源代码
数据结构实验报告实验名称：实验一——线性表学生姓名：SECRET班级：SECRET班内序号：SECRET学号：SECRET日期：2050年5月20日1．实验要求根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。
线性表存储结构（五选一）：1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能：1、构造：使用头插法、尾插法两种方法2、插入：要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他：可自行定义编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构2.2 关键算法分析关键算法1：头插法自然语言描述：a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:修改新结点的指针域d:修改头结点的指针域。
将新结点加入链表中伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:s->next=front->next;d:front->next=s2：尾插法自然语言描述：a:在堆中建立新结点：b:将a[i]写入到新结点的数据域：c:将新结点加入到链表中d:修改修改尾指针伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:r->next=s;d:r=s3：析构/删除函数自然语言描述：a:新建立一个指针，指向头结点b:判断要释放的结点是否存在，c:暂时保存要释放的结点d:移动a 中建立的指针e:释放要释放的指针伪代码描述a:Node <T> * p=frontb:while(p)c: front=pd:p=p->nexte:delete front4：按位查找函数自然语言描述：a:初始化工作指针p 和计数器j，p 指向第一个结点，j=1b:循环以下操作，直到p 为空或者j 等于1b1：p 指向下一个结点b2：j 加1c:若p 为空，说明第i 个元素不存在，抛出异常d:否则，说明p 指向的元素就是所查找的元素，返回元素地址伪代码描述a:Node <T> * p=front->next;j=1;b:while(p&&j!=1)b1:p=p->nextb2:j++c:if(!p) throw ”error”d:return p5：按位查找函数自然语言描述：a:初始化工作指针p 和计数器j，p 指向第一个结点，j=1b:循环以下操作，找到这个元素或者p 指向最后一个结点b1：判断p 指向的结点是不是要查找的值，如果是，返回j，否则p 指向下一个结点，并且j 的值加一c:如果找到最后一个结点还没有找到要查找的元素，返回查找失败信息伪代码描述a:Node <T> * p=front->next;j=1;b:while(p)b1:if(p->next==x) return jp=p->nextj++c:return “error”6：插入函数自然语言描述：a:在堆中建立新结点b:将要插入的结点的数据写入到新结点的数据域c:修改新结点的指针域d:修改前一个指针的指针域，使其指向新插入的结点的位置伪代码描述a:Node <T> * s=new Node <T>;b:s-data=p->datac:s->next=p->nextd:p->next=se:p->data=x7：删除函数自然语言描述：a:从第一个结点开始，查找要删除的位数i 前一个位置i-1 的结点b:设q 指向第i 个元素c:将q 元素从链表中删除d:保存q 元素的数据e:释放q 元素伪代码描述a:q=p->nextb:p->next=q->nextc:x=q->datad:delete q8：遍历打印函数自然语言描述：a:判断该链表是否为空链表，如果是，报错b:如果不是空链表，新建立一个temp 指针c:将temp 指针指向头结点d:打印temp 指针的data 域e:逐个往后移动temp 指针，直到temp 指针的指向的指针的next 域为空伪代码描述If front->next==NULLThrow ”an empty list ”Node<T>* temp=front->next;while(temp->next){cout<<temp->data<<" ";temp=temp->next;}9：获取链表长度函数自然语言描述：a:判断该链表是否为空链表，如果是，输出长度0b:如果不是空链表，新建立一个temp 指针，初始化整形数n 为0c:将temp 指针指向头结点d:判断temp 指针指向的结点的next 域是否为空，如果不是，n 加一，否则return ne: 使temp 指针逐个后移，重复d 操作，直到temp 指针指向的结点的next 域为0，返回n伪代码描述int n=0if front->next==NULLn=0else{Node<T>* temp=front->next;while(temp->next)n++;temp=temp->next;}return n;二代码详细分析1：头插法插入链表四句关键代码Node <T> *s =new Node <T>;s->data=a[i];s->next=front->next;front->next=s;return n;示意图2:尾插法插入链表四句关键代码Node<T> *s=new Node <T>; s->data=a[i];r->next=s;r=s;示意图3：查找算法四句关键代码Node<T>*p=front->next;int j=1;while(p&&j!=i){p=p->next;j++;}示意图4：删除算法关键代码Node<T>*p=front;if(i!=1)p=Get(i-1);Node<T>*q=p->next;p->next=q->next;T x=q->data;delete q;示意图关键算法的时间、空间复杂度头插法/尾插法O(n)按位查找/按值查找O(n)插入操作O(n)3. 程序运行结果流程图4. 总结1、调试时出现的问题及解决的方法在编写按值查找函数时，由于没有处理好指针类型的原因，导致指针无法正常返回，屡屡报错。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表（1）掌握线性表的基本运算。
（2）掌握顺序存储的概念，学会对顺序存储数据结构进⾏操作。
（3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数：（1）InitList(LIST *L,int ms)初始化线性表；（2）InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素；（3）DeleteList1(LIST *L,int item)删除指定元素值的线性表记录；（4）DeleteList2(LIST *L,int rc)删除指定位置的线性表记录；（5）FindList(LIST *L,int item)查找线性表的元素；（6）OutputList(LIST *L)输出线性表元素；2、调⽤上述函数实现下列操作：（1）初始化线性表；（2）调⽤插⼊函数建⽴⼀个线性表；（3）在线性表中寻找指定的元素；（4）在线性表中删除指定值的元素；（5）在线性表中删除指定位置的元素；（6）遍历并输出线性表；l 实验结果1、顺序表（1）流程图（2）程序运⾏主要结果截图（3）程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值；rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素，返回值>=0为元素的位置，返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录，返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值，输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输⼊查找元素值，输⼊0结束查找操作：");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输⼊删除元素值，输⼊0结束查找操作：");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置，输⼊0结束查找操作：");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表（1）掌握链表的概念，学会对链表进⾏操作。
数据结构 实验二：单链表的基本操作
数据结构实验二：单链表的基本操作数据结构实验二：单链表的基本操作实验二：单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握建立单链表和显示单链表元素的算法。
3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表，手动输入10个数，并从屏幕显示单链表元素列表。
2、从键盘输入一个数，查找在以上创建的单链表中是否存在该数;如果存在，显示它的位置;如果不存在，给出相应提示。
3、删除上述单链表中指定位置的元素。
以下就是程序部分代码，恳请调试并补足并使之恰当运转：１．linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间，申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai（0≤i≤size）结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错！\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai（0≤i≤size-1）结点*//*删除结点的数据元素域值由x带回。
数据结构上机实验线性表单链表源代码
数据结构上机实验线性表单链表源代码#includetemplateclass LinearList{public:virtual bool IsEmpty()const=0;virtual int Length()const=0;virtual bool Find(int i,T& x)const=0;virtual int Search(T x)const=0;virtual bool Insert(int i,T x)=0;virtual bool Update(int i,T x)=0;virtual bool Delete(int i)=0;virtual void Output(ostream& out)const=0; protected:int n;};#include "linearlist"templateclass SeqList:public LinearLisr{public:SeqList(int mSize);~SeqList(){delete [] elements;}bool IsEmpty()const;bool Find(int i,T& x)const;int Length()const;int Search(T x)const;bool Insert(int i,T x);bool Update(int i,T x);bool Delete(int i);void Output(ostream& out)const; private:int maxLength;T *elements;};templateSeqList::SeqList(int mSize){maxLength=mSize;elements=new T[maxLength];n=0;}templatebool SeqList::IsEmpty()const{return n==0;}templateint SeqList::Length()const{return 0;}templatebool SeqList::Find(int i,T& x)const{if(i<0||i>n-1){cont<<"Out of Bounds"<<endl;< p="">return false;}x=elements[i];return true;}templateint SeqList::Search(T x)const{for(int j=0;j<n;j++)< p="">if(elements[j]==x)return -1;}templatebool SeqList::Insert(int i,T x){if(i<-1||i>n-1){cout<<"OUt of Bounds"<<="" p=""> }if(n==maxLength){cout<<"OverFlow"<<endl;< p=""> return false;}for(int j=n-1;j>i;j--)elements[j+1]=elements[j]; elements[j+1]=x;n++;return true;}templatebool SeqList::Delete(int i){if(!n){cout<<"UnderFlow"<<endl;< p="">return false;}if(i<0||i>n-1){cout<<"OUt of Bounds"<<="" p="">}for(int j=i+1;j<n;j++)< p="">elements[j-1]=elements[j];n--;return true;}templatebool SeqList::Update(int i,T x){if(i<0||i>n-1){cout<<"OUt of Bounds"<<="" p="">}elements[i]=x;return true;}templatebool SeqList::Output(ostream& out)const{for(int i=0;i<n;i++)out<<elements[i]<<'';< p=""> out<<endl;< p="">}</endl;<></n;i++)out<<elements[i]<<'';<> </n;j++)<></endl;<></endl;<></n;j++)<></endl;<>。
线性表之单链表C++实现
线性表之单链表C++实现 线性表之单链表⼀、头⽂件：LinkedList.h1//单链表是⽤⼀组任意的存储单元存放线性表的元素，这组单元可以是连续的也可以是不连续的，甚⾄可以是零散分布在内存中的任意位置。
2//单链表头⽂件3 #include<iostream>4using namespace std;5//定义单链表结点-结构体类型6 template<class DataType>7struct Node8 {9 //数据域，存放该结点的数据10 DataType data;11 //指针域，指向下⼀个结点12 Node<DataType> *next;13 };1415 template<class DataType>16class LinkedList{17public:18 //单链表⽆参构造器19 LinkedList();20 //单链表有参构造器21 LinkedList(DataType array[], int n);22 LinkedList(int n, DataType array[]);23 //单链表析构函数24 ~LinkedList();25 //获取单链表的长度26 int GetLength();27 //查找单链表指定元素的序号28 int GetLocal(DataType x);29 //获取单链表指序号的元素30 DataType GetElement(int index);31 //单链表中在指定位置插⼊指定的元素32 void Insert(int index, DataType x);33 //在单链表中删除指定位置的元素34 DataType Delete(int index);35 //按序号输出单链表中的元素36 void PrintLinkedList();3738private :39 //声明单链表的头指针40 Node<DataType> *first;41 };4243//实现单链表的⽆参构造函数44 template<class DataType>45 LinkedList<DataType>::LinkedList()46 {47 first = new Node<DataType>;48 first->next = NULL;49 }5051//头插法建⽴单链表52 template<class DataType>53 LinkedList<DataType>::LinkedList(int n,DataType array[])54 {55 //初始化⼀个空链表56 first = new Node<DataType>;57 first->next = NULL;58 for (int i = 0; i < n; i++)59 {60 //为每⼀个数组元素都申请新结点61 Node<DataType> *s = new Node<DataType>;62 //数组元素赋值给结点数据域63 s->data = array[i];64 //将结点插⼊到头结点之前65 s->next = first->next;66 first->next = s;6768 }69 }7071//尾插法建⽴单链表72 template<class DataType>73 LinkedList<DataType>::LinkedList(DataType array[], int n)74 {75 //⽣成头结点76 first = new Node<DataType>;77 //定义尾结点78 Node<DataType> *r = first;79 for (int i = 0; i < n; i++)80 {81 //为每⼀个数组元素申请⼀个结点82 Node<DataType> *s = new Node<DataType>;83 //把数组元素赋值给结点的数据域84 s->data = array[i];85 //将每⼀个结点追加到终端结点之后86 r->next = s;87 r = s;88 }89 //尾结点尾NULL90 r->next = NULL;91 }9293//实现单链表的析构函数94 template<class DataType>95 LinkedList<DataType>::~LinkedList()96 {97 //声明⼯作指针98 Node<DataType> *q;99 while (first != NULL)100 {101 //暂存被释放的结点102 q = first;103 //让头指针指向要释放结点的下⼀个结点104 first = first->next;105 delete q;106 }107 }108109//实现单链表插⼊:在指定的位置插⼊指定的元素110 template<class DataType>111void LinkedList<DataType>::Insert(int index, DataType x)112 {113 //定义⼯作指针114 Node<DataType> *p = first->next;115 //定义计数器，初始值为0116 int count = 0;117 while (p != NULL &&count < index - 1)118 {119 //⼯作指针后移120 p = p->next;121 count ++;122 }123 //找到 index-1 的位置124 if (p == NULL)125 {126 throw"插⼊的位置有误";127 }128 else129 {130 //申请⼀个新结点131 Node<DataType> *s;132 s= new Node<DataType>;133 //其数据域为 x134 s->data = x;135 //在新结点的指针域存放⼯作指针p的指针域136 s->next = p->next;137 //将结点s插⼊到p结点之后138 p->next = s;139 }140 }141142//实现单链表的按值查找，返回指定元素在单链表中的序号（如不存在，则返回0）143 template<class DataType>144int LinkedList<DataType>::GetLocal(DataType x)145 {146 //定义⼯作指针147 Node<DataType> *p = first->next;148 //定义计数器，初始值是1149 int count = 1;150 //查找序号所对应的位置151 while (p != NULL)152 {153 if (p->data == x)154 {155 return count;156 }157 //⼯作指针后移158 p = p->next;159 //计数器加1160 count++;161 }162 //如果找不到该元素，则返回0163 return0;164 }165166//实现单链表按位查找，返回指定位置的元素167 template<class DataType>168 DataType LinkedList<DataType>::GetElement(int index)169 {170 //定义⼯作指针171 Node<DataType> *p = first->next;172 //定义计数器，初始值是1173 int count = 1;174 //查找序号所对应的位置175 while (p != NULL&&count < index)176 {177 //⼯作指针后移178 p = p->next;179 //计数器加1180 count++;181 }182 //如果找到单链表的末尾，还找不到指定的位置，则抛出异常183 if (p == NULL)184 {185 throw"查找的位置有误";186 }187 else188 {189 //当找到合适的位置时，返回该位置上的元素190 return p->data;191 }192193 }194195//实现获取单链表的长度196 template<class DataType>197int LinkedList<DataType>::GetLength()198 {199 //定义计数器，⽤来计算单链表的长度200 int count = 0;201 //定义⼯作指针202 Node<DataType> *p = first->next;203 while (p != NULL)204 {205 p = p->next;206 count++;207 }208 return count;209210 }211212//实现单链表的按序号输出元素213 template<class DataType>214void LinkedList<DataType>::PrintLinkedList()215 {216 //声明⼯作指针217 Node<DataType> *p;218 //初始化⼯作指针219 p = first->next;220 while(p != NULL)221 {222 cout << p->data << "";223 //⼯作指针向后移动224 p = p->next;225 }226 cout << endl;227 }228229//实现单链表的删除230 template<class DataType>231 DataType LinkedList<DataType>::Delete(int index)232 {233 Node<DataType> *p = first->next;234 int count = 0;235 //查找第 index-1 位置结点236 while (p != NULL&&count < index - 1)237 {238 p = p->next;239 count++;240 }241 //如果能找到242 if (p == NULL || p->next == NULL)243 {244 throw"删除的位置有误";245 }246 else247 {248 Node<DataType> *q = p->next;249 DataType x = q->data;250 p->next = q->next;251 delete q;252 return x;253 }254 }⼆、测试线性表之单链表的源⽂件：TestLinkedList.cpp1 #include<iostream>2 #include "LinkedList.h"3using namespace std;4void show()5 {6 cout << "---------------------------------------" << endl;7 }8int main()9 {10 int array[] = { 1, 3, 5, 2, 7, 6, 9, 8, 10, 4};11 //声明单链表12 LinkedList<int> linkedList = LinkedList<int>(10,array);13 cout << "输出单链表：" << endl;14 linkedList.PrintLinkedList();15 show();16 cout << "单链表的长度:" << linkedList.GetLength() << endl;17 cout << "单链表中第5个元素是：" << linkedList.GetElement(5) << endl; 18 cout << "单链表中元素5的位置是：" << linkedList.GetLocal(5) << endl; 19 show();20 cout << "在单链表的第5个位置上插⼊元素22" << endl;21 linkedList.Insert(5, 22);22 cout << "输出单链表：" << endl;23 linkedList.PrintLinkedList();24 cout << "单链表的长度:" << linkedList.GetLength() << endl;25 show();26 cout << "删除第5位置的元素" << endl;27 linkedList.Delete(5);28 cout << "输出单链表：" << endl;29 linkedList.PrintLinkedList();30 cout << "单链表的长度:" << linkedList.GetLength() << endl;31 show();32 return0;33 }三、运⾏⽰例结果。
线性表的C语言代码
《数据结构》实验报告实验目的：1、掌握用Turbo C上机调试线性表的基本方法。
2、掌握线性表的基本操作，建立、查找、插入及删除操作的算法实现。
实验内容：1、建立一个带头结点的线性链表（以输入一个非正整数为结束）。
2、在线性表中值为x的元素前插入一个值为y的数据元素。
若值为x的结点不存在，则将y插在表尾。
3、删除线性表中第i个数据元素。
#include <stdio.h>#include <malloc.h>#include <stdlib.h>struct lnode{int data;struct lnode * next;};int main(){int x,y,i,d;struct lnode *head, *p,*q,*m,*a;head =NULL;q =NULL;head = ( struct lnode *) malloc (sizeof( struct lnode));head->next=NULL;printf("请输入一个正整数，按回车输入第二个数；若输入的是非正整数即负数和零，则进入下一个阶段：\n");scanf("%d",&d);while( d > 0 ){p = ( struct lnode *) malloc (sizeof( struct lnode));p->data = d;p->next =NULL;if(head->next ==NULL) head->next=p;else q->next = p;q = p;scanf("%d",&d);}p=head->next;printf("单链表:\n");while(p!=NULL){printf("%d ",p->data);p=p->next;}printf("\n\n插入功能\n请输入你要插入数字之前的数是：");p=head->next;scanf("%d",&d);while(p->next!=NULL&&p->next->data!=d){p=p->next;}printf("请输入您要插入的数:");scanf("%d",&d);m = ( struct lnode *) malloc (sizeof( struct lnode));m->next=p->next;m->data=d;p->next=m;p=head->next;printf("插入后的单链表为:\n");while(p){printf("%d ",p->data);p=p->next;}printf("\n\n删除功能\n请输入您要删除的数是：");p=head->next;scanf("%d",&i);while(p->next!=NULL&&p->next->data!=i){p=p->next;}if(!p->next){printf("没找到该数\n");exit(0);}elseq=p->next;p->next=q->next;i =q->data;free(q);p=head->next;printf("删除后的单链表为:\n");while(p){printf("%d ",p->data);p=p->next;}总结：（1）因为线性表的特点是：存在唯一的一个被称作“第一个”的数据元素；存在唯一的一个被称作“最后一个”的数据元素；除第一个之外，集合中每一个数据结构元素均只有一个前驱；除最后一个之外，集合中每一个数据结构元素均只有一个后继；且线性表的顺序存储结构是一种随机存取的存储结构。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include<iostream.h>
template <class T>
class LinearList
{
public:
virtual bool IsEmpty()const=0;
virtual int Length()const=0;
virtual bool Find(int i,T& x)const=0;
virtual int Search(T x)const=0;
virtual bool Insert(int i,T x)=0;
virtual bool Update(int i,T x)=0;
virtual bool Delete(int i)=0;
virtual void Output(ostream& out)const=0;
protected:
int n;
};
#include "linearlist"
template <class T>
class SeqList:public LinearLisr<T>
{
public:
SeqList(int mSize);
~SeqList(){delete [] elements;}
bool IsEmpty()const;
bool Find(int i,T& x)const;
int Length()const;
int Search(T x)const;
bool Insert(int i,T x);
bool Update(int i,T x);
bool Delete(int i);
void Output(ostream& out)const;
private:
int maxLength;
T *elements;
};
template <class T>
SeqList<T>::SeqList(int mSize)
{
maxLength=mSize;
elements=new T[maxLength];
n=0;
}
template <class T>
bool SeqList<T>::IsEmpty()const
{
return n==0;
}
template <class T>
int SeqList::Length()const
{
return 0;
}
template <class T>
bool SeqList<T>::Find(int i,T& x)const
{
if(i<0||i>n-1)
{
cont<<"Out of Bounds"<<endl;
return false;
}
x=elements[i];
return true;
}
template <class T>
int SeqList<T>::Search(T x)const
{
for(int j=0;j<n;j++)
if(elements[j]==x)
return -1;
}
template <class T>
bool SeqList<T>::Insert(int i,T x)
{
if(i<-1||i>n-1)
{
cout<<"OUt of Bounds"<<endl;return false;
}
if(n==maxLength){
cout<<"OverFlow"<<endl;
return false;
}
for(int j=n-1;j>i;j--)
elements[j+1]=elements[j];
elements[j+1]=x;
n++;return true;
}
template <class T>
bool SeqList::Delete(int i)
{
if(!n){
cout<<"UnderFlow"<<endl;
return false;
}
if(i<0||i>n-1)
{
cout<<"OUt of Bounds"<<endl;return false;
}
for(int j=i+1;j<n;j++)
elements[j-1]=elements[j];
n--;return true;
}
template <class T>
bool SeqList::Update(int i,T x)
{
if(i<0||i>n-1)
{
cout<<"OUt of Bounds"<<endl;return false;
}
elements[i]=x;
return true;
}
template <class T>
bool SeqList::Output(ostream& out)const
{
for(int i=0;i<n;i++)out<<elements[i]<<'';
out<<endl;
}。