第三次作业

这个作业属于哪个课程	https://edu.cnblogs.com/campus/qdu/DS2020
这个作业要求在哪里	https://edu.cnblogs.com/campus/qdu/DS2020/homework/11232
这个作业的目标	<掌握线性表和链表的基本功能>
学号	2017207338

一、实验目的

1、掌握线性表中元素的前驱、后续的概念。
2、掌握顺序表与链表的建立、插入元素、删除表中某元素的算法。
3、对线性表相应算法的时间复杂度进行分析。
4、理解顺序表、链表数据结构的特点（优缺点）。

二、实验预习

说明以下概念
1、线性表：
是由n个数据元素（节点）组成的有限序列
2、顺序表：
每个节点的存储地址是该节点的在表中位置的线性函数
3、链表：
通常将连接方式的存储的线性表成为链表

三、实验内容和要求

1、阅读下面程序，在横线处填写函数的基本功能。并运行程序，写出结果。

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1

#define INIT_SIZE 5     /*初始分配的顺序表长度*/
#define INCREM 5        /*溢出时，顺序表长度的增量*/
typedef  int ElemType;  /*定义表元素的类型*/
typedef struct Sqlist {
	ElemType *slist;      /*存储空间的基地址*/
	int length;           /*顺序表的当前长度*/
	int listsize;         /*当前分配的存储空间*/
} Sqlist;

int InitList_sq(Sqlist *L); /*声明一个长度为5的空线性表*/
int CreateList_sq(Sqlist *L,int n); /*创建一个长度为n的线性表*/
int ListInsert_sq(Sqlist *L,int i,ElemType e);/*在第i个节点插入e*/
int PrintList_sq(Sqlist *L);  /*输出顺序表的元素*/
int ListDelete_sq(Sqlist *L,int i); /*删除第i个元素*/
int ListLocate(Sqlist *L,ElemType e); /*查找值为e的元素*/

int InitList_sq(Sqlist *L) {
	L->slist=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));
	if(!L->slist) return ERROR;
	L->length=0;
	L->listsize=INIT_SIZE;
	return OK;
}/*InitList*/

int CreateList_sq(Sqlist *L,int n) {
	ElemType e;
	int i;
	for(i=0; i<n; i++) {
		printf("input data %d:",i+1);
		scanf("%d",&e);
		if(!ListInsert_sq(L,i+1,e))
			return ERROR;
	}
	return OK;
}/*CreateList*/

/*输出顺序表中的元素*/
int PrintList_sq(Sqlist *L) {
	int i;
	for(i=1; i<=L->length; i++)
		printf("%5d",L->slist[i-1]);
	return OK;
}/*PrintList*/

int ListInsert_sq(Sqlist *L,int i,ElemType e) {
	int k;
	if(i<1||i>L->length+1)
		return ERROR;
	if(L->length>=L->listsize) {
		L->slist=(ElemType*)realloc(L->slist,(INIT_SIZE+INCREM)*sizeof(ElemType));
		if(!L->slist)
			return ERROR;
		L->listsize+=INCREM;
	}
	for(k=L->length-1; k>=i-1; k--) {
		L->slist[k+1]= L->slist[k];
	} 
	L->slist[i-1]=e;
	L->length++;
	return OK;
}/*ListInsert*/

/*在顺序表中删除第i个元素*/
int ListDelete_sq(Sqlist *L,int i) {
	int k = 0;
	if(i>(L->length)) return ERROR;
	for(k = i-1;k<L->length-1;k++){
		L->slist[k] = L->slist[k+1];
	}
	L->slist[L->length-1]=NULL;
	L->length--;
	return OK;
}
/*在顺序表中查找指定值元素，返回其序号*/
int ListLocate(Sqlist *L,ElemType e) {
	int k = 0;
	for(k = 0;k<L->length;k++){
		if(e==L->slist[k]) return k+1;
	}
	return ERROR;
}

int main() {
	Sqlist sl;
	int n,m,k;
	printf("please input n:");  /*输入顺序表的元素个数*/
	scanf("%d",&n);
	if(n>0) {
		printf("\n1-Create Sqlist:\n");
		InitList_sq(&sl);
		CreateList_sq(&sl,n);
		printf("\n2-Print Sqlist:\n");
		PrintList_sq(&sl);
		printf("\nplease input insert location and data:(location,data)\n");
		scanf("%d,%d",&m,&k);
		ListInsert_sq(&sl,m,k);
		printf("\n3-Print Sqlist:\n");
		PrintList_sq(&sl);
		printf("\n");
	} else
		printf("ERROR");
	return 0;
}

算法分析
空间复杂度：输入规模为logN
时间复杂度：插入算法的平均复杂度为n/2,删除算法的平均复杂度为n/2;
删除算法代码：

/*在顺序表中删除第i个元素*/
int ListDelete_sq(Sqlist *L,int i) {
	int k = 0;
	if(i<1||i>(L->length)) return ERROR;
	for(k = i-1;k<L->length-1;k++){
		L->slist[k] = L->slist[k+1];
	}
	L->slist[L->length-1]=NULL;
	L->length--;
	return OK;
}

查找算法代码：

/*在顺序表中查找指定值元素，返回其序号*/
int ListLocate(Sqlist *L,ElemType e) {
	int k = 0;
	for(k = 0;k<L->length;k++){
		if(e==L->slist[k]) return k+1;
	}
	return ERROR;
}

#include <stdio.h>
#include <stdlib.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
typedef  int ElemType; /*定义表元素的类型*/
typedef struct LNode { /*线性表的单链表存储*/
	ElemType data;
	struct LNode *next;
} LNode,*LinkList;

LinkList CreateList(int n); /*创建一个长度为n的链表*/
void PrintList(LinkList L); /*输出带头结点单链表的所有元素*/
int GetElem(LinkList L,int i,ElemType *e); /*获得第i个位置的元素*/
int InsertList(LinkList L,int i,ElemType* e);/*在第i个位置插入元素*/
int DeleteList(LinkList L,int i);/*删除第i个位置的元素*/
int LengthList(LinkList L);/*求链表的长度*/ 

LinkList CreateList(int n) {
	LNode *p,*q,*head;
	int i;
	head=(LinkList)malloc(sizeof(LNode));
	head->next = NULL;
	p=head;
	for(i=0; i<n; i++) {
		q=(LinkList)malloc(sizeof(LNode));
		printf("input data %i:",i+1);
		scanf("%d",&q->data);            /*输入元素值*/
		q->next=NULL;                    /*结点指针域置空*/
		p->next=q;                       /*新结点连在表末尾*/
		p=q;
	}
	return head;
}/*CreateList*/

void PrintList(LinkList L) {
	LNode *p;
	p=L->next;  /*p指向单链表的第1个元素*/
	while(p!=NULL) {
		printf("%5d",p->data);
		p=p->next;
	}
}/*PrintList*/

int GetElem(LinkList L,int i,ElemType *e) {
	LNode *p;
	int j=1;
	p=L->next;
	while(p&&j<i) {
		p=p->next;
		j++;
	}
	if(!p||j>i)
		return ERROR;
	*e=p->data;
	return OK;
}/*GetElem*/

int LengthList(LinkList L){
	int i = 0;
	LNode* p = NULL;
	for(p = L;p->next!=NULL;p=p->next){
		i++;
	}
	return i;
}
int InsertList(LinkList L,int i) {//插在第i个位置的后面，如果要插在表头，则i=0 
	if(i<0||i>LengthList(L)) return ERROR;
	LNode* p;
	LNode* q;
	LNode* r;
	int e = 0;
	r = (LinkList)malloc(sizeof(LNode));
	printf("输入要插入的元素：");
	scanf("%d",&e);
	r->data = e;
	if(i==0){
		p = L;
		q = p->next;
		p->next = r;
		r->next = q;
		return OK;
	} 
	int j = 0;
	for(p = L;j < i;j++){
		p=p->next;			
	}
	q = p->next;
	p->next = r;
	r->next = q;
	return OK;
}

int DeleteList(LinkList L,int i) {

}

int main() {
	int n,i;
	ElemType e;
	LinkList L=NULL;            /*定义指向单链表的指针*/
	printf("please input n:");  /*输入单链表的元素个数*/
	scanf("%d",&n);
	if(n>0) {
		printf("\n1-Create LinkList:\n");
		L=CreateList(n);
		printf("\n2-Print LinkList:\n");
		PrintList(L);
		printf("\n3-GetElem from LinkList:\n");
		printf("input i = ");
		scanf("%d",&i);
		if(GetElem(L,i,&e))
			printf("No%i is %d\n",i,e);
		else
			printf("not exists");
		printf("链表的长度是:%d\n",LengthList(L));
		printf("插入的位置以及值为(插在第i个位置的后面，如果要插在表头，则i=0):");
		int a = 0,b = 0;
		scanf("%d,%d",&a,&b);
		InsertList(L,a);
		PrintList(L);
	} else
		printf("ERROR");
	return 0;
}

运行结果

插入功能

int InsertList(LinkList L,int i) {//插在第i个位置的后面，如果要插在表头，则i=0 
	if(i<0||i>LengthList(L)) return ERROR;
	LNode* p;
	LNode* q;
	LNode* r;
	int e = 0;
	r = (LinkList)malloc(sizeof(LNode));
	printf("输入要插入的元素：");
	scanf("%d",&e);
	r->data = e;
	if(i==0){
		p = L;
		q = p->next;
		p->next = r;
		r->next = q;
		return OK;
	} 
	int j = 0;
	for(p = L;j < i;j++){
		p=p->next;			
	}
	q = p->next;
	p->next = r;
	r->next = q;
	return OK;
}

运行结果

算法分析
插入函数之前先声明，定义了一个求链表长度的函数；求长度的时间复杂度为O(n);
时间复杂度与插入位置有关，对此，其平均复杂度为(n+1)/2,时间复杂度为O(n);

删除算法代码

int DeleteList(LinkList L,int i) {
	if(i<1||i>LengthList(L)) return ERROR;
	LNode* p;
	LNode* q;
	LNode* r;
	int j = 0;
	for(p = L;j < i-1;j++){
		p=p->next;			
	}
	q=p->next;
	r=q->next;
	p->next = r;
	free(q);
	return OK;
}

运行结果

算法分析
最大时间复杂度为链表长度O(n),平均复杂度为(n+1)/2;

四、实验小结

不同的书籍上，其线性表中函数的功能虽然一样，但参数有所不同(有的函数的参数中包含了节点的指针，而另外的却不包含)。但是其内在的本质时相同的，都是由节点够成的一个个结构体指针，线性表的查找操作由于其存储地址时线性关系，所以方便查找，但是不易于插入，删除，而链表由于地址不连续方便插入，删除，但是对于大规模的数据结构如果使用链表，查询会显得十分困难，这是需要注意的，内存分配也同样需要注意，在本实验中的所有例题中应该都加入内存分配失败的情形。
实验中的链表仅仅保存了单个元素，增加元素的个数，就会用来表示不同的类型，比如多项式中每个节点中可以包含两个数据一个是项数，另一个是系数，可以自己在常识练习。
c语言中的基本概念还是要加强，在编写代码过程中对于二级指针的理解不够深刻使自己当时写出了_&L，编译不通过，还有就是链表的插入算法中，插入节点所包含的值总是输入失败，新插入的节点值为0；

int InsertList(LinkList L,int i,ElemType e) {//插在第i个位置的后面，如果要插在表头，则i=0 
	if(i<0||i>LengthList(L)) return ERROR;
	LNode* p;
	LNode* q;
	LNode* r;
	int j = 0;
	for(p = L;j < i;j++){
		p=p->next;
		q=p->next;			
	}
	r = (LinkList)malloc(sizeof(LNode));
	p->next = r;
	r->next = q;
	r->data = e;
	return OK;
}

由于循环中在i=0时不运行，此时q变成了野指针，导致在运行过程中输入i=0时，程序运行出现严重问题，这些细节上都是需要注意的。

posted @ 2020-10-06 22:26 NPCNP 阅读(189) 评论(1) 收藏举报

刷新页面返回顶部

NPCNP

第三次作业

一、实验目的

二、实验预习

三、实验内容和要求

四、实验小结

公告