c语言[error] ld returned 1 exit status_单向链表_C语言「抄作业」

最新推荐文章于 2023-10-05 17:07:50 发布

小理同学

最新推荐文章于 2023-10-05 17:07:50 发布

阅读量278

点赞数

文章标签： c语言[error] ld returned 1 exit status

本文链接：https://blog.csdn.net/weixin_32187037/article/details/113054281

版权

C语言「抄作业」系列之单向链表

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

#define elemType int				/* 单链表元素数据类型 */
#define LNODE_SIZE sizeof (struct lNode)	/* 单链表结点空间大小 */

#define status int	/* 状态型变量 */
#define OVERFLOW -1	/* 内存溢出状态码 */
#define ERROR 0		/* 错误状态码 */
#define OK 1		/* 正确状态码 */

/* 单链表数据结构 */
typedef struct lNode {
	elemType data;
	struct lNode *next;
} lNode, *linkList;

/*************************** 含头结点的单链表基本操作(12个) ***************************/
void initList (linkList *L);	/* 初始化 */
void destroyList (linkList L);	/* 销毁 */
void clearList (linkList L);	/* 清空 */

status listIsEmpty (linkList L);	/* 判断单链表是否为空 */
int listLength (linkList L);		/* 获取单链表长度 */
status getElem (linkList L, int i, elemType *e);	/* 获取单链表指定元素值 */

/* 寻找指定特征(compare)元素的位序 */
int locateElem (linkList L, elemType e, status (*compare)(elemType, elemType));

status priorElem (linkList L, elemType cur_e, elemType *pre_e);	/* 获取指定元素的前驱 */
status nextElem (linkList L, elemType cur_e, elemType *next_e);	/* 获取指定元素的后继 */

status listInsertNode (linkList L, int i, elemType e);	/* 单链表指定位置插入新元素 */
status listDeleteNode (linkList L, int i, elemType *e);	/* 删除单链表指定位置元素 */

void listTraverse (linkList L, void (*vi)(elemType));	/* 依次对单链表的每个元素调用函数vi() */
/*************************************************************************************/
status compare (elemType des, elemType src);	/* 数据元素判定 */
void vi (elemType e);				/* vi函数，定义为打印链表 */
/*************************************************************************************/

/* 初始化 */
/* 操作结果：构造一个空的单链表L */
void initList (linkList *L) {
	*L = (linkList) malloc (LNODE_SIZE); /* 产生头结点，并使L指向此头结点 */
	if (!*L) /* 内存分配失败 */
		exit (OVERFLOW);
	(*L)->next = NULL; /* 指针域为空 */
}

/* 销毁 */
/* 初始条件：单链表L已存在。操作结果：销毁单链表L */
void destroyList (linkList L) {
	linkList p, q;
	
	p = L->next; /* p指向第一个结点 */
	while (p) { /* 没到表尾 */
		q = p->next;
		free (p);
		p = q;
	}
	free (L);
}

/* 清空 */
/* 初始条件：单链表L已存在。操作结果：将L重置为空表 */
void clearList (linkList L) {
	linkList p, q;
	
	p = L->next; /* p指向第一个结点 */
	while (p) { /* 没到表尾 */
		q = p->next;
		free (p);
		p = q;
	}
	
	L->next = NULL; /* 头结点指针域为空 */
}

/* 判断单链表是否为空 */
/* 初始条件：单链表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
status listIsEmpty (linkList L) {
	return L->next == NULL;
}

/* 获取单链表长度 */
/* 初始条件：单链表L已存在。操作结果：返回L中数据元素个数 */
int listLength (linkList L) {
	int i = 0;
	linkList p = L->next; /* p指向第一个结点 */
	
	while (p) { /* 没到表尾 */
		i++;
		p=p->next;
	}
	
	return i;
}

/* 获取单链表指定元素值 */
/* 操作结果：L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR */
status getElem (linkList L, int i, elemType *e) {
	int j = 1; /* j为计数器 */
	linkList p = L->next; /* p指向第一个结点 */
	
	while (p && j<i) { /* 顺指针向后查找，直到p指向第i个元素或p为空 */
		p = p->next;
		j++;
	}
	
	if (!p || j>i) /* 第i个元素不存在 */
		return ERROR;
	
	*e = p->data; /* 取第i个元素 */
	
	return OK;
}

/* 寻找指定特征(compare)元素的位序 */
/* 初始条件: 单链表L已存在，compare()是数据元素判定函数(满足为1，否则为0) */
/* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序 */
/* 若这样的数据元素不存在，则返回值为0 */
int locateElem (linkList L, elemType e, status (*compare)(elemType, elemType)) {
	linkList p = L->next;
	int i = 0;
	
	while (p) {
		i++;
		if (compare (p->data, e)) /*找到这样的数据元素*/
			return i;
		p = p->next;
	}
	
	return 0;
}

/* 获取指定元素的前驱 */
/* 初始条件: 单链表L已存在 */
/* 操作结果: 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
/* 返回OK；否则操作失败，pre_e无定义，返回ERROR */
status priorElem (linkList L, elemType cur_e, elemType *pre_e) {
	linkList q, p = L->next; /* p指向第一个结点 */
	
	while (p->next) { /* p所指结点有后继 */
		q = p->next; /* q为p的后继 */
		if (q->data == cur_e) {
			*pre_e = p->data;
			return OK;
		}
		p = q; /* p向后移 */
	}
	
	return ERROR;
}

/* 获取指定元素的后继 */
/* 初始条件：单链表L已存在 */
/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
/* 返回OK;否则操作失败，next_e无定义，返回ERROR */
status nextElem (linkList L, elemType cur_e, elemType *next_e) {
	linkList p = L->next; /* p指向第一个结点 */
	
	while (p->next) { /* p所指结点有后继 */
		if (p->data == cur_e) {
			*next_e = p->next->data;
			return OK;
		}
		p = p->next;
	}
	
	return ERROR;
}

/* 单链表指定位置插入新元素 */
/* 操作结果：在带头结点的单链表L中第i个位置之前插入元素e */
status listInsertNode (linkList L, int i, elemType e) {
	linkList p = L, s;
	int j = 0;
	
	while (p && j<i-1) { /* 寻找第i-1个结点 */
		p = p->next;
		j++;
	}
	
	if (!p || j>i-1) /* 插入位置不合理：i小于1或者大于表长 */
		return ERROR;
	
	/* 生成新结点，并插入L中 */
	s = (linkList) malloc (LNODE_SIZE);
	if (!s) /* 内存分配失败 */
		exit (OVERFLOW);
	s->data = e;
	s->next = p->next;
	p->next = s;
	
	return OK;
}

/* 删除单链表指定位置元素 */
/* 操作结果：在带头结点的单链表L中，删除第i个元素，并由e返回其值 */
status listDeleteNode (linkList L, int i, elemType *e) {
	linkList p = L, q;
	int j = 0;
	
	while (p->next && j<i-1) { /* 寻找第i个结点，并令p指向其前驱结点 */
		p = p->next;
		j++;
	}
	
	if (!p->next || j>i-1) /* 删除位置不合理：i小于1或者大于表长 */
		return ERROR;
	
	/* 删除并释放结点 */
	q = p->next;
	p->next = q->next;
	*e = q->data;
	free (q);
	return OK;
}

/* 依次对单链表的每个元素调用函数vi() */
/* 初始条件：单链表L已存在 */
/* 操作结果：依次对L的每个数据元素调用函数vi() */
void listTraverse (linkList L, void (*vi)(elemType)) {
	linkList p = L->next; /* p指向第一个结点 */
	
	if (p == NULL)
		puts ("The linked list is empty! ");
	
	while (p) {
		vi (p->data);
		p = p->next;
	}
	putchar ('n');
}

/* 数据元素判定 */
/* 满足返回TRUE，否则返回FALSE */
status compare (elemType des, elemType src) {
	return des == src;
}

/* vi函数 */
/* 打印元素值 */
void vi (elemType e) {
	printf ("%d ", e);
}

int main (void) {
	linkList L;
	elemType e, pre_e, next_e;
	elemType a=1, b=2, c=3, d=4;
	int index, len;
	status sts;
	
	/* 初始化链表 */
	initList (&L);
	printf ("initList: &L -> L's Address: %pn", L);
	putchar ('n');
	
	/* 插入若干元素 */
	index = 1;
	sts = listInsertNode (L, index, a);
	printf ("listInsertNode: L,i=%d,a=%d -> status: %dn", index, a, sts);
	index = 1;
	sts = listInsertNode (L, index, b);
	printf ("listInsertNode: L,i=%d,b=%d -> status: %dn", index, b, sts);
	index = 1;
	sts = listInsertNode (L, index, c);
	printf ("listInsertNode: L,i=%d,c=%d -> status: %dn", index, c, sts);
	index = 1;
	sts = listInsertNode (L, index, d);
	printf ("listInsertNode: L,i=%d,d=%d -> status: %dn", index, d, sts);
	putchar ('n');
	
	/* 依次对单链表的每个元素调用函数vi() */
	/* 打印链表 */
	printf ("L: ");
	listTraverse (L, &vi);
	putchar ('n');
	
	/* 判断单链表是否为空 */
	sts = listIsEmpty (L);
	printf ("listIsEmpty: L -> isEmpty: %dn", sts);
	
	/* 获取单链表长度 */
	len = listLength (L);
	printf ("listLength: L -> length: %dn", len);
	putchar ('n');
	
	/* 获取单链表指定元素值 */
	index = 2;
	sts = getElem (L, index, &e);
	printf ("getElem: L,i=%d,&e -> status: %d, e: %dn", index, sts, e);
	
	/* 寻找指定特征(compare)元素的位序 */
	e = 3;
	index = locateElem (L, e, &compare);
	printf ("locateElem: L,e=%d,&compare -> index: %dn", e, index);
	putchar ('n');
	
	/* 获取指定元素的前驱 */
	e = 3;
	sts = priorElem (L, e, &pre_e);
	printf ("priorElem: L,e=%d,&pre_e -> status: %d, pre_e: %dn", e, sts, pre_e);
	/* 获取指定元素的后继 */
	e = 3;
	sts = nextElem (L, e, &next_e);
	printf ("nextElem: L,e=%d,&next_e -> status: %d, next_e: %dn", e, sts, next_e);
	putchar ('n');
	
	/* 删除单链表指定位置元素 */
	index = 3;
	sts = listDeleteNode (L, index, &e);
	printf ("listDeleteNode: L,i=%d,&e -> status: %d, e: %dn", index, sts, e);
	putchar ('n');
	
	/* 打印链表 */
	printf ("L: ");
	listTraverse (L, &vi);
	putchar ('n');
	
	/* 清空链表 */
	clearList (L);
	printf ("clearList: L -> donen");
	sts = listIsEmpty (L);
	printf ("listIsEmpty: L -> isEmpty: %dn", sts);
	putchar ('n');
	
	/* 销毁链表 */
	destroyList (L);
	printf ("destroyList: L -> donen");
	putchar ('n');
	
	printf ("press any key to exit.n");
	
	getch (); /* 屏幕暂留 */ 
	return 0 ;
}

运行结果

C语言抄作业系列，只有答案，没有讲解！

计算机科学专业毕业多年的一个啥也没学会而转行做了产品经理的家伙，从当年的各种作业里搬运来的一些乱七八糟的东西。

C语言「抄作业」www.zhihu.com

小理同学

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
c语言[error] ld returned 1 exit status_单向链表_C语言「抄作业」

C语言「抄作业」系列之单向链表#include <stdio.h>#include <stdlib.h>#include <conio.h>#define elemType int /* 单链表元素数据类型 */#define LNODE_SIZE sizeof (struct lNode) /* 单链表结点空间大小 */#define st...
复制链接

扫一扫