线性表算法设计作业，C实现，完整可编译，严蔚敏数据结构第二版

最新推荐文章于 2024-09-17 14:54:46 发布
最新推荐文章于 2024-09-17 14:54:46 发布
阅读量735 收藏 12
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lei20172017/article/details/117484428
版权

线性表算法设计作业，C实现，完整可编译，严蔚敏数据结构第二版
最终完整代码详见文末，代码AC，文件后缀改成cpp

教材53页2.2题

将两个非递减的有序链表合并为一个非递增的有序链表，要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复的数据。

算法如下，C描述

/*
    线性表算法设计作业 教材53页2.2题
    将两个非递减的有序链表合并为一个非递增的有序链表，要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复的数据。
*/
void merge_down(LNode *&A, LNode *B) {
	LNode *p = A->Next;
	LNode *q = B->Next;
	LNode *s;
	A->Next = NULL;
	free(B);
	while(p !=NULL && q != NULL) {
		//下边的if else语句体现了链表的头插法
		if(p->data <= q->data) {
			s = p;
			p = p->Next;
			s->Next = A->Next;
			A->Next = s;
		} else {
			s = q;
			q = q->Next;
			s->Next = A->Next;
			A->Next = s;
		}
	}
	//下边两个循环是和求递增归并序列不同的地方，必须将剩余元素逐个插入C的头部才能得到最终的递减序列
	while(p != NULL) {
		s = p;
		p = p->Next;
		s->Next = A->Next;
		A->Next = s;
	}
	while(q != NULL) {
		s = q;
		q = q->Next;
		s->Next = A->Next;
		A->Next = s;
	}
}

运行结果：
在这里插入图片描述

教材53页2.3题

已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出A与B的交集，并存放于A链表中。

/*算法思想:采用归并的思想，设置两个工作指针pa和pb,对两个链表进行归并扫描，只有
同时出现在两集合中的元素才链接到结果表中且仅保留一个，其他的结点全部释放。当一个链表
遍历完毕后，释放另一个表中剩下的全部结点
*/

算法如下，C描述

/*
    线性表算法设计作业 教材53页2.3题
    已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出A与B的交集，并存放于A链表中。
*/
/*算法思想:采用归并的思想，设置两个工作指针pa和pb,对两个链表进行归并扫描，只有
同时出现在两集合中的元素才链接到结果表中且仅保留一个，其他的结点全部释放。当一个链表
遍历完毕后，释放另一个表中剩下的全部结点
*/
LNode * Union (LNode *&la,LNode *&lb) {
	LNode *pa=la->Next;//设工作指针分别为pa和pb
	LNode *pb=lb->Next;
	LNode *pc=la;//结果表中当前合并结点的前驱指针
	while (pa&&pb) {
		if (pa->data==pb->data) {//交集并入结果表中
			pc->Next=pa;//A中结点链接到结果表
			pc=pa;
			pa=pa->Next;
			LNode * u=pb;//B中结点释放
			pb=pb->Next;
			free(u);
		} else if (pa->data<pb->data) { //若A中当前结点值小于B中当前结点值
			LNode * u=pa;
			pa=pa->Next;//后移指针
			free(u);//释放A中当前结点
		} else { //若B中当前结点值小于A中当前结点值
			LNode * u=pb;
			pb=pb->Next;//后移指针
			free(u);//释放B中当前结点
		}
	}//while结束
	while (pa) {//B已遍历完，A未完
		LNode * u=pa;
		pa=pa->Next;
		free(u);//释放A中剩余结点
	}
	while (pb) {//A已遍历完，B未完
		LNode * u=pb;
		pb=pb->Next;
		free(u);//释放B中剩余结点
	}
	pc->Next=NULL;//置结果链表尾指针为NULL
	free(lb);//释放B表的头结点
	return la;
}

运行结果：
在这里插入图片描述

教材53页2.7题

设计一个算法，将链表中所有结点的链表方向“原地”逆转，即要求仅利用原表的存储空间，换句话说要求算法的空间复杂度为O（1）。
解法一:将头结点摘下，然后从第一结点开始，依次插入到头结点的后面(头插法建立单链表)，直到最后一个结点为止，这样就实现了链表的逆置。
解法二 ：假设pre、p和r指向3个相邻的结点，如下图所示。假设经过若干操作后，pre 之前的;
结点的指针都已调整完毕，它们的Next都指向其原前驱结点。现在令p结点的Next域指向
*pre结点，注意到一旦调整指针的指向后，p 的后继结点的链就会断开，为此需要用r来指向
原p的后继结点。处理时需要注意两点:一是在处理第一个结点时，应将其Next域置为NULL,
而不是指向头结点(因为它将作为新表的尾结点);二是在处理完最后一个结点后，需要将头结
点的指针指向它。
算法如下：C语言描述：

/*
    线性表算法设计作业 教材53页2.7题
    设计一个算法，将链表中所有结点的链表方向“原地”逆转，即要求仅利用原表的存储空间，换句话说，要求算法的空间复杂度为O（1）。
*/
/*解法一:将头结点摘下，然后从第一结点开始，依次插入到头结点的后面(头插法建立单链
表)，直到最后一个结点为止，这样就实现了链表的逆置
*/
LNode * Reverse_1 (LNode *L) {//L是带头结点的单链表，本算法将L就地逆置
	LNode *p, *r;//p为工作指针，r为p的后继，以防断链
	p=L->Next;//从第一个元素结点开始
	L->Next=NULL;//先将头结点L的Next域置为NULL
	while (p!=NULL) {//依次将元素结点摘下
		r=p->Next;//暂存P的后继
		p->Next=L->Next;//将P结点插入到头结点之后
		L->Next=p;
		p=r;
	}
	return L;
}


/*解法二 ：假设pre、p和r指向3个相邻的结点，如下图所示。假设经过若干操作后，*pre 之前的;
结点的指针都已调整完毕，它们的Next都指向其原前驱结点。现在令*p结点的Next域指向
*pre结点，注意到一旦调整指针的指向后，*p 的后继结点的链就会断开，为此需要用r来指向
原*p的后继结点。处理时需要注意两点:一是在处理第一个结点时，应将其Next域置为NULL,
而不是指向头结点(因为它将作为新表的尾结点);二是在处理完最后一个结点后，需要将头结
点的指针指向它。
*/
LNode * Reverse_2 (LNode *L) {//依次遍历线性表L,并将结点指针反转
	LNode *pre, *p=L->Next, *r=p->Next;
	p->Next=NULL;//处理第一个结点
	while(r!=NULL) {//r为空，则说明p为最后一个结点
		pre=p;//依次继续遍历
		p=r;
		r=r->Next;
		p->Next=pre;//指针反转
	}
	L->Next=p;//处理最后一个结点
	return L;
}

运行结果：
在这里插入图片描述

教材53页2.8题

设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。

算法如下，C语言描述：

/*
    线性表算法设计作业 教材53页2.8题
    设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。
*/
void RangeDelete (LNode *&L, int mink, int maxk) {
	LNode *pr = L, *p=L->Next;//p是检测指针，pr是其前驱
	while (p !=NULL)
		if (p->data>mink && p->data<maxk) { //寻找到被删结点，删除
			pr->Next = p->Next;
			free(p);
			p = pr->Next;
		} else {//否则继续寻找被删结点
			pr = p;
			p =p->Next;
		}
}

运行结果：
在这里插入图片描述

教材53页2.10题

已知长度为n的线性表A采用顺序存储结构,请写一个时间复杂度为o(n)、空间复杂度为o(1)的算法, 该算法可删除线性表中所有值为item的数据元素。

算法如下，C语言描述：

/*
    线性表算法设计作业 教材53页2.10题
    已知长度为n的线性表A采用顺序存储结构,请写一个时间复杂度为o(n)、空间复杂度为o(1)的算法, 该算法可删除线性表中所有值为item的数据元素。
*/
/*解法一:用k记录顺序表L中不等于item的元素个数(即需要保存的元素个数)，边扫描L边
统计k,并将不等于item的元素向前移动k个位置，最后修改L的长度。
*/
void del_item_1 (SqList &L, ElementType item) {//本算法实现删除顺序表L中所有值为item的数据元素
	int k=0;//记录值不等于item的元素个数
	for (int i=0; i<L.length; i++)
		if (L.data[i] != item) {
			L.data[k] = L.data[i];
			k++;//不等于item的元素增 1
		}
	L.length=k;//更新顺序表L的长度等于k
}
/*解法二:用k记录顺序表L中等于item的元素个数，边扫描L边统计k,并将不等于item的元素
前移k个位置，最后修改L的长度。
*/
void del_item_2 (SqList &L, ElementType item) {
	int k=0, i=0;//k记录值等于item的元素个数
	while (i < L.length) {
		if (L.data[i] == item)
			k++;
		else
			L.data[i-k] = L.data[i]; //当前元素前移k个位置
		i++;
	}
	L.length = L.length - k;//顺序表L的长度递减
}

运行结果：
在这里插入图片描述

以上各题的完整代码汇总

原创不易，期待三连支持

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef int ElementType;
typedef struct LNode {
	ElementType data;
	struct LNode *Next;
} LNode;

typedef struct {
	ElementType data[MaxSize];
	int length;
} SqList;
/*
    线性表算法设计作业 教材53页2.2题
    将两个非递减的有序链表合并为一个非递增的有序链表，要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复的数据。
*/
void merge_down(LNode *&A, LNode *B) {
	LNode *p = A->Next;
	LNode *q = B->Next;
	LNode *s;
	A->Next = NULL;
	free(B);
	while(p !=NULL && q != NULL) {
		//下边的if else语句体现了链表的头插法
		if(p->data <= q->data) {
			s = p;
			p = p->Next;
			s->Next = A->Next;
			A->Next = s;
		} else {
			s = q;
			q = q->Next;
			s->Next = A->Next;
			A->Next = s;
		}
	}
	//下边两个循环是和求递增归并序列不同的地方，必须将剩余元素逐个插入C的头部才能得到最终的递减序列
	while(p != NULL) {
		s = p;
		p = p->Next;
		s->Next = A->Next;
		A->Next = s;
	}
	while(q != NULL) {
		s = q;
		q = q->Next;
		s->Next = A->Next;
		A->Next = s;
	}
}


/*
    线性表算法设计作业 教材53页2.3题
    已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出A与B的交集，并存放于A链表中。
*/
/*算法思想:采用归并的思想，设置两个工作指针pa和pb,对两个链表进行归并扫描，只有
同时出现在两集合中的元素才链接到结果表中且仅保留一个，其他的结点全部释放。当一个链表
遍历完毕后，释放另一个表中剩下的全部结点
*/
LNode * Union (LNode *&la,LNode *&lb) {
	LNode *pa=la->Next;//设工作指针分别为pa和pb
	LNode *pb=lb->Next;
	LNode *pc=la;//结果表中当前合并结点的前驱指针
	while (pa&&pb) {
		if (pa->data==pb->data) {//交集并入结果表中
			pc->Next=pa;//A中结点链接到结果表
			pc=pa;
			pa=pa->Next;
			LNode * u=pb;//B中结点释放
			pb=pb->Next;
			free(u);
		} else if (pa->data<pb->data) { //若A中当前结点值小于B中当前结点值
			LNode * u=pa;
			pa=pa->Next;//后移指针
			free(u);//释放A中当前结点
		} else { //若B中当前结点值小于A中当前结点值
			LNode * u=pb;
			pb=pb->Next;//后移指针
			free(u);//释放B中当前结点
		}
	}//while结束
	while (pa) {//B已遍历完，A未完
		LNode * u=pa;
		pa=pa->Next;
		free(u);//释放A中剩余结点
	}
	while (pb) {//A已遍历完，B未完
		LNode * u=pb;
		pb=pb->Next;
		free(u);//释放B中剩余结点
	}
	pc->Next=NULL;//置结果链表尾指针为NULL
	free(lb);//释放B表的头结点
	return la;
}



/*
    线性表算法设计作业 教材53页2.7题
    设计一个算法，将链表中所有结点的链表方向“原地”逆转，即要求仅利用原表的存储空间，换句话说，要求算法的空间复杂度为O（1）。
*/
/*解法一:将头结点摘下，然后从第一结点开始，依次插入到头结点的后面(头插法建立单链
表)，直到最后一个结点为止，这样就实现了链表的逆置
*/
LNode * Reverse_1 (LNode *L) {//L是带头结点的单链表，本算法将L就地逆置
	LNode *p, *r;//p为工作指针，r为p的后继，以防断链
	p=L->Next;//从第一个元素结点开始
	L->Next=NULL;//先将头结点L的Next域置为NULL
	while (p!=NULL) {//依次将元素结点摘下
		r=p->Next;//暂存P的后继
		p->Next=L->Next;//将P结点插入到头结点之后
		L->Next=p;
		p=r;
	}
	return L;
}


/*解法二 ：假设pre、p和r指向3个相邻的结点，如下图所示。假设经过若干操作后，*pre 之前的;
结点的指针都已调整完毕，它们的Next都指向其原前驱结点。现在令*p结点的Next域指向
*pre结点，注意到一旦调整指针的指向后，*p 的后继结点的链就会断开，为此需要用r来指向
原*p的后继结点。处理时需要注意两点:一是在处理第一个结点时，应将其Next域置为NULL,
而不是指向头结点(因为它将作为新表的尾结点);二是在处理完最后一个结点后，需要将头结
点的指针指向它。
*/
LNode * Reverse_2 (LNode *L) {//依次遍历线性表L,并将结点指针反转
	LNode *pre, *p=L->Next, *r=p->Next;
	p->Next=NULL;//处理第一个结点
	while(r!=NULL) {//r为空，则说明p为最后一个结点
		pre=p;//依次继续遍历
		p=r;
		r=r->Next;
		p->Next=pre;//指针反转
	}
	L->Next=p;//处理最后一个结点
	return L;
}



/*
    线性表算法设计作业 教材53页2.8题
    设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。
*/
void RangeDelete (LNode *&L, int mink, int maxk) {
	LNode *pr = L, *p=L->Next;//p是检测指针，pr是其前驱
	while (p !=NULL)
		if (p->data>mink && p->data<maxk) { //寻找到被删结点，删除
			pr->Next = p->Next;
			free(p);
			p = pr->Next;
		} else {//否则继续寻找被删结点
			pr = p;
			p =p->Next;
		}
}





/*
    线性表算法设计作业 教材53页2.10题
    已知长度为n的线性表A采用顺序存储结构,请写一个时间复杂度为o(n)、空间复杂度为o(1)的算法, 该算法可删除线性表中所有值为item的数据元素。
*/
/*解法一:用k记录顺序表L中不等于item的元素个数(即需要保存的元素个数)，边扫描L边
统计k,并将不等于item的元素向前移动k个位置，最后修改L的长度。
*/
void del_item_1 (SqList &L, ElementType item) {//本算法实现删除顺序表L中所有值为item的数据元素
	int k=0;//记录值不等于item的元素个数
	for (int i=0; i<L.length; i++)
		if (L.data[i] != item) {
			L.data[k] = L.data[i];
			k++;//不等于item的元素增 1
		}
	L.length=k;//更新顺序表L的长度等于k
}
/*解法二:用k记录顺序表L中等于item的元素个数，边扫描L边统计k,并将不等于item的元素
前移k个位置，最后修改L的长度。
*/
void del_item_2 (SqList &L, ElementType item) {
	int k=0, i=0;//k记录值等于item的元素个数
	while (i < L.length) {
		if (L.data[i] == item)
			k++;
		else
			L.data[i-k] = L.data[i]; //当前元素前移k个位置
		i++;
	}
	L.length = L.length - k;//顺序表L的长度递减
}


/*尾插法建立链表L */
void createListR(LNode *&L) {
	LNode *s, *r;   //s用来指向新申请的结点，r始终指向L的终端结点
	ElementType x;
	L = (LNode *)malloc(sizeof(struct LNode));//申请L的头结点空间
	L->Next = NULL;
	r = L;//r指向头结点，因为此时头结点就是终端结点
	printf("\n(尾插法)请依次输入链表元素(以-999作结束标志)：\n");
	while(1) { //循环申请结点来接收输入缓冲区中的元素，直到遇到-999结束接收
		scanf("%d",&x);
		if(x == -999) break;
		s = (LNode *)malloc(sizeof(struct LNode));//s指向新申请的结点
		s->data = x;//用新申请的结点来接收输入的元素
		r->Next = s;//用r来接纳新结点
		r = r->Next;//r指向终端结点，以便于接纳下一个到来的结点
	}
	r->Next = NULL;//输入缓冲区的所有元素都已经装入链表L中，L的终端结点的指针域置位NULL，L建立完成
}
/*头插法建立链表L */
void createListF(LNode *&L) {
	LNode *s;
	ElementType x;
	L = (LNode *)malloc(sizeof(struct LNode));
	L->Next = NULL;
	printf("\n创建链表(头插法)---请依次输入链表元素(以-999作结束标志)：\n");
	while(1) {
		scanf("%d",&x);
		if(x == -999) break;
		s = (LNode *)malloc(sizeof(struct LNode));
		s->data = x;
		//下边两句是头插法的关键步骤
		s->Next = L->Next;//s所指新结点的指针域Next指向L中的开始结点
		L->Next = s;//头结点的指针域Next指向s结点，使得s成为新的开始结点
	}
}
/*打印链表*/
void printList(LNode *L) {
	LNode *p = L->Next;
//	printf("\n链表元素依次为：");
	while(p != NULL) {
		printf("%d ",p->data);//https://blog.youkuaiyun.com/lei20172017?spm=1010.2135.3001.5343
		p = p->Next;
	}
	printf("\n");
}

/*创建线性表*/
void createSqList(SqList &L) {
	int i = 0;
	L.data[MaxSize] = 0;
	L.length = 0;
	ElementType e;
	printf("\n创建线性表------请输入线性表元素（以-999结束输入）：");
	while (1) {
		scanf("%d",&e);
		if (e == -999) break;//https://blog.youkuaiyun.com/lei20172017?spm=1010.2135.3001.5343
		L.data[i++] = e;
		L.length++;
		if (L.length > MaxSize) {
			printf("超出MaxSize\n");//leidata Structure
			break;
		}
	}
}
//输出顺序表中元素
void ShowSqList(SqList L) {
	int i;
//	printf("\n线性表为：");
	for (i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);//Lei DataStructure
	}
	printf("\n");
}

void showMenu() {
	printf("******************************线性表算法设计题作业******************************\n");
	printf("1.教材53页2.2题	将两个非递减的有序链表合并为一个非递增的有序链表，要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复的数据。\n");
	printf("2.教材53页2.3题 已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出A与B的交集，并存放于A链表中。\n");//https://blog.youkuaiyun.com/lei20172017?spm=1010.2135.3001.5343
	printf("3.教材53页2.7题 设计一个算法，将链表中所有结点的链表方向“原地”逆转，即要求仅利用原表的存储空间，换句话说，要求算法的空间复杂度为O（1）。\n");
	printf("4.教材53页2.8题 设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。\n");
	printf("5.教材53页2.10题 已知长度为n的线性表A采用顺序存储结构,请写一个时间复杂度为o(n)、空间复杂度为o(1)的算法, 该算法可删除线性表中所有值为item的数据元素。\n");
	printf("0.退出并返回上一级\n\n");
	printf("请输入你的选择：\n");
}

int main() {
	LNode *La,*Lb;
	SqList L;
	ElementType mink,maxk;
	ElementType item;
	int choice = -1;
	while(1) {
		system("cls");//Lei Data Structure
		showMenu();
		scanf("%d",&choice);
		if(choice  == 0) break;//lei Data Structure
		fflush(stdin);
		switch (choice) {//https://blog.youkuaiyun.com/lei20172017?spm=1010.2135.3001.5343
			case 1:
				printf("创建链表La(元素非递减有序)：");
				createListR(*&La);//https://blog.youkuaiyun.com/lei20172017?spm=1010.2135.3001.5343
				printf("创建链表Lb(元素非递减有序)：");
				createListR(*&Lb);
				merge_down(La, Lb);
				printf("归并成非递增的链表(仍使用原来两个链表的存储空间)：");
				printList(La);
				system("pause");//https://blog.youkuaiyun.com/lei20172017?spm=1010.2135.3001.5343
				break;
			case 2:
				printf("链表A(元素递增排列)：");//leiDataStructure
				createListR(*&La);
				printf("链表B(元素递增排列)：");
				createListR(*&Lb);
				Union(*&La,*&Lb);//leiDataStructure
				printf("求出A与B的交集，并存放于A链表中：\n");
				printList(La);
				system("pause");
				break;
			case 3:
				createListR(*&La);
				La = Reverse_2 (La);//leiDataStructure
				printf("链表就地逆转后：");
				printList(La);
				system("pause");//https://blog.youkuaiyun.com/lei20172017?spm=1010.2135.3001.5343
				break;
			case 4:
				createListR(*&La);
				printf("输入 mink 和 maxk:");
				scanf("%d %d",&mink,&maxk);
				RangeDelete(*&La,mink,maxk);
				printf("删去介于%d和%d之间的所有元素后:",mink,maxk);
				printList(La);
				system("pause");//leiDataStructure
				break;
			case 5:
				createSqList(L);
				printf("input item that you want to delete:");
				scanf("%d",&item);
				del_item_1(L, item);//https://blog.youkuaiyun.com/lei20172017?spm=1010.2135.3001.5343
				printf("after delete %d:\n",item);
				ShowSqList(L);
				system("pause");//https://blog.youkuaiyun.com/lei20172017?spm=1010.2135.3001.5343
				break;
			default:
				printf("\n无效选择，请重新输入！\n");
				system("pause");
				break;
		}
	}
	return 0;
}
线性表 作业
skysys的研究小屋
03-22 332
#include<bits/stdc++.h> using namespace std; typedef struct{ int id; #define MAXSIZE 20 char name[MAXSIZE]; double score; }Node; typedef struct{ Node* data; int length,size; }Linklist; voi...
【数据结构系列】严蔚敏C语言版算法实现并附带详细注释（逐步更新）
weixin_65334260的博客
07-15 4847
数据结构在编程过程中是不可或缺的，是举足轻重的，想要编写出一个好的程序，学好数据结构这门学科是必经之路。本文是各种数据结构实现的目录文章，我会在我学习数据结构这门课程的过程中逐步更新其中的内容。.................................
数据结构——顺序表（4.25作业）
qq_70137750的博客
04-25 931
一、顺序表是数据结构的基础，让我们先看一下copy闵帆老师的代码 #include <stdio.h> #include <malloc.h> #define LIST_MAX_LENGTH 10 /** * Linear list of integers. The key is data. */ typedef struct SequentialList { int actualLength; int data[LIST_MAX_LENGTH]; //
线性表算法设计
01-27
数据结构中线性表部分的习题以及答案，其中算法的主要实现是通过C++程序来的
算法设计与分析——线性表
qq_57633498的博客
03-11 632
线性表是最基本、最简单、也是最常用的一种数据结构，一个线性表是n个具有相同特性的数据元素的有限序列
线性表作业
weixin_60223449的博客
05-04 196
#define MAX 1000 #include<stdio.h> typedef struct ArrayNode { int len; int array[MAX]; }ArrayNode, * pArray; // pArray create2() { pArray p = (ArrayNode*)malloc(sizeof(ArrayNode)); p->len = 0; return p; } // void add2(int val, pArray array) .
严蔚敏数据结构c语言版
03-27
《数据结构》（C语言版）是为“数据结构”课程编写的教材，也可作为学习数据结构及其算法的C程序设计的参数教材。 本书的前半部分从抽象数据类型的角度讨论各种基本类型的数据结构及其应用；后半部分主要讨论查找和...
《数据结构》严蔚敏版算法C语言完整实现下载
资源摘要信息:"严蔚敏版教材《数据结构》上的算法C语言实现.zip包含了《数据结构》这门经典课程中涉及的各种算法的C语言编程实现。严蔚敏教授的《数据结构》是许多高校计算机科学与技术专业的核心教材，其中讲解了...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar )
06-13
4.3 数据输入输出的概念及在 C 语言中的实现 54 4.4 字符数据的输入输出 54 4.4.1 putchar 函数（字符输出函数） 54 4.4.2 getchar函数（键盘输入函数） 55 4.5 格式输入与输出 55 4.5.1 printf 函数（格式输出函数...
严蔚敏版数据结构算法C语言实现详解
C语言因其高效性和灵活性，常用于实现数据结构和算法。严蔚敏是数据结构领域内著名的学者，她的教科书广泛用于高校教学。 ### 数据结构基础知识 数据结构主要分为线性结构和非线性结构。线性结构如线性表、栈、...
数据结构程序作业（线性表、图等）
01-13
里面包括线性表的链式存储，栈的顺序存储，字符串，二叉树，图的实现代码。
线性表算法设计：(1)顺序表元素的循环移动
weixin_43972499的博客
07-28 715
目录1.题目2.题目分析3.参考代码4.测试结果 1.题目   设计一个算法，对于一个存储着若干元素的顺序表，根据用户输入的移动方向和位数，实现对顺序表元素的循环移动。 2.题目分析 1.假设我们获得用户输入的方向和位数分别为左和3位，表示我们要将4号元素及其之后的元素全部前移3位，同时前3号元素移至数组尾部且保持顺序不变。我们想到的是创建一个临时数组，用来保存我们的前三号元素。 2.接着，我们将数组的其他元素依次前移3位。 3.最后，我们把临时数组里保存的前三个元素复制到顺序表的后三个位置，完成我们的
线性表算法设计举例
橘猫吃不胖的博客
11-25 500
【2-4】构造一个顺序表的删除算法，把顺序表L中的数据元素x删除。若删除成功则返回1，若删除失败则返回0。 【算法思想】可以通过一个循环比较过程来实现。当比较过程中找到数据元素x后，删除之。算法设计如下： int ListDataDelete(SeqList *L,DataType x) { int i,j; for(i=0;i<L->size;i++)//寻找数据元素 if(x==L->size[i]) break; if(i==L->size) return 0;//未
第二章：线性表算法设计题（1-4）
搬家啦x
01-05 846
问题描述： （1）合并两顺序表表为一个仍递增的表； （2）合并两顺序表为一个递减的表； （3）求出A,B集合的交集，并放在A中；仍旧使用A中的结点； （4）找出在A中，不在B中的元素，保存在A中。   / 代码实现： 001 #include 002 #include 003 #inclu
数据结构与算法设计#1线性表
yuex666的博客
10-20 245
线性表的定义 表ADT （1）数据元素：单值元素、记录型元素 （2）唯一直接前驱、直接后继。是否按关键字有序排列 （3）操作：生成、清除、查找、插入、删除、排序等 线性表的顺序存储 1. 线性表的顺序存储结构：把线性表的结点一次存储在一组地址连续的存储单元中。 2. 线性表的特点： （1）线性表的逻辑顺序与物理存储顺序一致 （2）相邻元素之间无空隙 （3）已知基地址可以计算任意元素地址 线性表的链式表示和实现 单链表 结点的描述 ...
线性表的基本操作算法实现与设计
ZiQqing的博客
08-12 447
//线性表的基本操作 #include<iostream> using namespace std; typedef struct LNode{ int data; LNode *next; }LNode, *LinkList; //头插法建立单链表 LinkList list_HeadInsert(LinkList &L){ LNode *s; int x; L=(LinkList)malloc(sizeof(LNode));//建立头结点 L->next=NULL;
线性表算法设计：(3)约瑟夫环
weixin_43972499的博客
07-29 695
目录题目题目分析参考代码测试结果 题目   约瑟夫(Josephus)环问题。   约瑟夫环是由古罗马的史学家约瑟夫提出来的，他参加并记录了公元66-70年犹太人反抗罗马的起义。约瑟夫作为一个将军，设法守住了裘达伯特城达43天之后。在城市沦陷后，他和40名死硬的将士在附近的一个洞穴中避难。在那里，这些将士们表决说“要投降毋宁死”。于是，约瑟夫建议每个人轮流杀死他旁边的人，而这个顺序是由抽签决定的。约瑟夫有预谋地抓到了最后一签，并且，作为洞穴中的两个幸存者之一，他说服了他原先的牺牲品一起投降了罗马。   约瑟
线性表作业汇总
sinker
10-23 1428
写在前面 一些题目涉及到多种解法，我会尽量用多种方法解决，如果还有别的方法，欢迎交流，对于一些使用STl的题目，我会先更新使用STL的代码，然后会尽力不使用STL再做一遍，由于时间关系有的题目思路可能写的比较简单 7-1 jmu-ds-顺序表区间元素删除 (15 分) 若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度...
【数据结构】线性表作业——归并排序
最新发布
2402_84389946的博客
09-17 1155
有一个含n（n<=200000）个整数的无序序列，采用链表的二路归并排序实现递增排序【输入形式】一行字符串，包含多个整数，每个数之间用空格分开。【输出形式】递增排序的结果，每个数之间用空格分开。【样例输入】【样例输出】【样例说明】测试数据的文件名为in.txt，输出文件名为out.txt。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值