华清远见第三课程作业day5

最新推荐文章于 2024-10-12 13:59:20 发布
最新推荐文章于 2024-10-12 13:59:20 发布
阅读量475 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57665894/article/details/132154744
版权

头文件

#ifndef _LIAN_H_ 
#define _LIAN_H_ 
 
typedef char datatype;    //类型重命名 
 
//定义节点类型
typedef struct Node 
{ 
union 
 { 
		datatype data;      //数据域 
		int len;             //头结点数据域 
 }; 
 
struct Node *next;      //指针域 
}Node, *LinkListPtr; 
 
//创建链表
LinkListPtr list_create(); 
 
//判空操作
int list_empty(LinkListPtr L); 
 
//申请结点封装数据函数
LinkListPtr node_buy(datatype e); 
 
//头插
int list_insert_head(LinkListPtr L, datatype e); 
 
//遍历
void list_show(LinkListPtr L); 
 
//按位置查找返回节点
LinkListPtr list_search_pos(LinkListPtr L, int pos); 
 
//尾插
int list_insert_tail(LinkListPtr L, datatype e); 
 
//任意位置插入
int list_insert_post(LinkListPtr L, int pos, datatype e); 
 
//头删
int list_delete_head(LinkListPtr L); 
 
//尾删
int list_delete_tail(LinkListPtr L); 
 
//任意位置删除
int list_delete_pos(LinkListPtr L, int pos); 
 
 
//按值查找返回节点位置
int list_search_value(LinkListPtr L, datatype e); 
 
//按位置进行修改
int list_update_pos(LinkListPtr L,int pos,datatype e); 
//按值进行修改
int list_update_value(LinkListPtr L,datatype value,datatype e);
//链表排序
int list_sort(LinkListPtr L,int flag);
//递归实现链表反转
LinkListPtr list_reverse_self(LinkListPtr L);
//链表的反转
void list_reverse(LinkListPtr L); 
 
//返回链表长度
int list_length(LinkListPtr L); 
 
//链表的销毁
void list_free(LinkListPtr L); 
 
 
#endif

 源文件

#include"lian.h" 
#include<stdio.h> 
#include<stdlib.h> 
 
//创建链表
LinkListPtr list_create() 
{ 
//在堆区申请一个头结点类型 
	LinkListPtr L = (LinkListPtr)malloc(sizeof(Node)); 
if(NULL == L) 
{ 
		printf("创建失败\n"); 
		return NULL; 
} 
 
//创建成功，对节点进行初始化 
	L->len = 0;       //初始链表长度为0 
	L->next = NULL;     //链表上没有任何结点 
 
printf("创建成功\n"); 
return L; 
} 
 
//判空操作
int list_empty(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL == L) 
{ 
		printf("所给链表不合法\n"); 
		return -1; 
} 
 
//判断指针域的内容 
return L->next == NULL && L->len==0; 
} 
 
 
//申请结点封装数据函数
LinkListPtr node_buy(datatype e) 
{ 
//在堆区申请结点 
	LinkListPtr p = (LinkListPtr)malloc(sizeof(Node)); 
if(NULL == p) 
{ 
		printf("结点申请失败\n"); 
		return NULL; 
} 
 
//结点申请成功，将数据封装进去 
	p->data = e; 
	p->next = NULL; 
 
return p; 
} 
 
//头插
int list_insert_head(LinkListPtr L, datatype e) 
{ 
//判断逻辑 
if(NULL == L) 
{ 
		printf("所给链表不合法\n"); 
		return 0; 
} 
 
//调用申请结点封装数据 
	LinkListPtr p = node_buy(e); 
if(NULL==p) 
{ 
		return 0; 
} 
 
//结点已经准备好，头插逻辑 
	p->next = L->next; 
	L->next = p; 
 
//表的变化 
	L->len++; 
 
printf("插入成功\n"); 
return 1; 
} 
 
 
//遍历
void list_show(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L)) 
{ 
		printf("遍历失败\n"); 
		return ; 
} 
 
//遍历逻辑 
printf("当前链表元素分别是："); 
//1、定义遍历指针从第一个结点开始 
	LinkListPtr q = L->next; 
while(q != NULL)     //2、只要当前结点存在 
{ 
		//3、输出数据域 
		printf("%c\t", q->data); 
 
		q = q->next;        //4、指针后移 
} 
printf("\n"); 
} 
 
 
//按位置查找返回节点
LinkListPtr list_search_pos(LinkListPtr L, int pos) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L) || pos<0 || pos>L->len) 
{ 
		printf("查找失败\n"); 
		return NULL; 
} 
 
//说明可以进行查找 
//定义遍历指针从头结点开始 
	LinkListPtr q = L; 
for(int i=0; i<pos; i++) 
{ 
		q = q->next; 
} 
 
//将找到的结点返回 
return q; 
} 
 
 
//任意位置插入
int list_insert_post(LinkListPtr L, int pos, datatype e) 
{ 
//判断逻辑 
if(NULL==L || pos<1 || pos>L->len+1) 
{ 
		printf("插入失败\n"); 
		return 0; 
} 
 
//申请结点封装数据函数 
	LinkListPtr p = node_buy(e); 
if(NULL==p) 
{ 
		return 0; 
} 
 
//找到要插入位置的前一个结点 
	LinkListPtr q = list_search_pos(L, pos-1); 
	
//执行插入逻辑 
	p->next = q->next; 
	q->next = p; 
 
//表长变化 
	L->len++; 
 
printf("插入成功\n"); 
return 1; 
} 
 
//尾插
int list_insert_tail(LinkListPtr L, datatype e) 
{ 
//判断逻辑 
if(NULL==L) 
{ 
		printf("所给链表不合法\n"); 
		return 0; 
} 
 
//找到最后一个结点 
//LinkListPtr q = list_search_pos(L, L->len); 
	
//1、定义遍历指针从头结点出发 
	LinkListPtr q = L; 
//2、遍历找到最后一个结点 
while(q->next != NULL) 
{ 
		q = q->next; 
} 
 
//申请结点封装要插入的数据 
	LinkListPtr p =node_buy(e); 
if(NULL==p) 
{ 
		return 0; 
} 
 
//尾插 
//p->next = q->next; 
	q->next = p; 
 
//表长变化 
	L->len++; 
printf("尾插成功\n"); 
return 1; 
} 
 
 
//头删
int list_delete_head(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L)) 
{ 
		printf("删除失败\n"); 
		return 0; 
} 
 
//删除逻辑 
//1、标记要删除的结点 
	LinkListPtr p = L->next; 
//2、孤立要删除的结点 
	L->next = p->next;  //L->next = L->next->next; 
//释放要删除的结点 
free(p); 
	p = NULL; 
 
//表长变化 
	L->len--; 
printf("删除成功\n"); 
return 1; 
} 
 
 
//任意位置删除
int list_delete_pos(LinkListPtr L, int pos) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L) || pos<1 || pos>L->len) 
{ 
		printf("删除失败\n"); 
		return 0; 
} 
 
//找到要删除结点的前驱结点 
	LinkListPtr q = list_search_pos(L, pos-1); 
 
//删除逻辑 
//1、标记要删除的结点 
	LinkListPtr p = q->next; 
//2、孤立要删除的结点 
	q->next = p->next; 
//3、释放要删除的结点 
free(p); 
	p = NULL; 
	q = NULL; 
 
//表长变化 
	L->len--; 
printf("删除成功\n"); 
} 
 
//尾删
int list_delete_tail(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L)) 
{ 
		printf("删除失败\n"); 
		return 0; 
} 
 
//找到倒数第二个结点 
//LinkListPtr q = list_search_pos(L, L->len-1); 
	
	LinkListPtr q = L;     //从头结点出发 
while(q->next->next != NULL) 
{ 
		q = q->next; 
} 
 
//删除逻辑 
free(q->next);        //释放最后一个结点 
	q->next = NULL;     //将新的最后一个结点指针域置空 
 
//表长变化 
	L->len--; 
 
printf("删除成功\n"); 
return 1; 
} 
 
 
//按值查找返回节点位置
int list_search_value(LinkListPtr L, datatype e) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L)) 
{ 
		printf("查找失败\n"); 
		return 0; 
} 
 
//将所有结点进行遍历 
/*
	for(int i=1; i<=L->len; i++)
	{
		//判断第i个结点的数据域是否跟要查找的数据相等
		if( list_search_pos(L,i)->data == e)
		{
			return i;
		}
	}*/
//定义遍历指针从第一个结点开始 
	LinkListPtr q = L; 
int index = 0; 
while((q=q->next) != NULL) 
{ 
		index ++;      //后移一个结点 
		if(q->data == e) 
		{ 
			return index; 
		} 
} 
 
return 0; 
 
 
} 
 
 
 
//链表的反转
void list_reverse(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L || L->len<=1) 
{ 
		printf("反转失败\n"); 
		return ; 
} 
 
//开始反转 
	LinkListPtr H = L->next;    //将链表托管 
	L->next = NULL;             //头结点指针域置空 
 
	LinkListPtr p;         //结点的搬运工 
while(H != NULL) 
{ 
		//标记要搬运的结点 
		p = H; 
		H = H->next;       //指向下一个结点 
 
		//以头插的形式放入到L链表上 
		p->next = L->next; 
		L->next = p; 
} 
 
printf("反转成功\n"); 
} 
 
 
//返回链表长度
int list_length(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L) 
{ 
		printf("所给链表不合法\n"); 
		return -1; 
} 
 
//返回链表的长度 
return L->len; 
} 
 
 
 
//链表的销毁
void list_free(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L) 
{ 
		printf("释放失败\n"); 
		return ; 
} 
 
//将所有结点全部释放 
while(!list_empty(L)) 
{ 
		list_delete_head(L); 
} 
 
//将头结点释放 
free(L); 
	L = NULL; 
 
printf("释放成功\n"); 
 
} 
//按位置进行修改
int list_update_pos(LinkListPtr L,int pos,datatype e){
	if(NULL==L || list_empty(L) || pos<0 ||pos>L->len){
		printf("链表或者位置不合法\n");
		return -1;
	}
	LinkListPtr p =list_search_pos(L,pos);
	p->data=e;
	printf("修改成功\n");
	return 1;
}

//按值进行修改
int list_update_value(LinkListPtr L,datatype value,datatype e){
	if(NULL==L || list_empty(L)){
		printf("链表不合法\n");
		return -1;
	}
	LinkListPtr p=list_search_pos(L,list_search_value(L,value));
	p->data=e;
	printf("修改成功\n");
	return 1;
}
//排序
int list_sort(LinkListPtr L,int flag){
	if(NULL==L || list_empty(L))
	 {
		printf("空表无法排序\n");
		return -1;
	 }
	LinkListPtr p,q,t;
	p=L;
	datatype temp;
	int a=L->len;
	for(int i=0;i<L->len-1;i++){
		a=L->len-i-1;
		q=L->next;
		p=q->next;
		t=L;
		while(a--){
			if(q->data>p->data&&flag==0){
				q->next=p->next;
				p->next=q;
				t->next=p;
			}
			else if(q->data<p->data&&flag==1){
				q->next=p->next;
				p->next=q;
				t->next=p;
			}
			t=t->next;
			q=t->next;
			p=q->next;
		}
	}
	return 1;
}
//递归反转
LinkListPtr list_reverse_self(LinkListPtr L){
	if(NULL==L || list_empty(L)){
		printf("链表不合法");
		return NULL;
	}
	if(L->next==NULL){
		return L;
	}
	else{
		list_reverse_self(L->next);
		L->next=NULL;
	}
	return L;
}

测试文件

#include"lian.h" 
 
int main(int argc, const char *argv[]) 
{ 
//调用创建函数创建一个链表 
	LinkListPtr L = list_create(); 
 
//调用头插函数 
list_insert_head(L, 'Q'); 
list_insert_head(L, 'W'); 
list_insert_head(L, 'E'); 
list_insert_head(L, 'R'); 
 
//调用遍历函数 
list_show(L); 
 
//调用任意位置插入函数 
list_insert_post(L, 3,'D'); 
list_show(L); 
 
//调用尾插函数 
list_insert_tail(L, 'F'); 
list_insert_tail(L, 'G'); 
list_show(L); 
 
//调用头删函数 
list_delete_head(L); 
list_delete_head(L); 
list_show(L); 
 
//调用尾删函数 
list_delete_tail(L); 
list_show(L); 
 
//调用反转函数 
list_reverse(L); 
list_show(L); 
//按位置修改
list_update_pos(L,2,48);
list_show(L);
//按值进行修改
list_update_value(L,48,49);
list_show(L);
//链表排序
list_sort(L,0);
list_show(L);
//反转
list_reverse_self(L);
list_show(L);
//销毁链表 
list_free(L); 
 
return 0; 
}

RRREAYA
关注
华清远见第三课程作业day3
RRREAYA的博客
08-03 578
对顺序表进行的一系列操作。
华清远见第三课程作业day7
RRREAYA的博客
08-09 429
【代码】华清远见第三课程作业day7。
华清远见第四课程作业day3
RRREAYA的博客
08-19 132
华清远见第四课程作业day5
RRREAYA的博客
08-21 195
2> 使用三个进程完成两个文件的拷贝，主线程拷贝前三分之一，子线程1拷贝中间三分之一，子线程2拷贝后三分之一，主线程要设置两个子线程为分离态。1> 使用两个线程完成两个文件的拷贝，主线程拷贝前一半内容，子线程拷贝后一半内容，并且主线程要阻塞回收子线程资源。
华清远见第六课程作业day9
RRREAYA的博客
09-18 221
【代码】华清远见第六课程作业day9。
华清远见第三课程作业day1
RRREAYA的博客
08-01 627
自定义函数与主函数的值传递。输入六个成绩并且排序。
华清远见第六课程作业day3
RRREAYA的博客
09-09 502
类 栈 #include <iostream> using namespace std; class Sta{ private: int *data; int top; public: Sta():data(new int(128)){ top=-1; cout<<"stack::无参构造:"<<endl; } ~Sta(){ delete data; c
华清远见第五课程作业day4
RRREAYA的博客
08-30 256
2. 多进程并发服务器。3. 多线程并发服务器。
华清远见第四课程作业day7
RRREAYA的博客
08-23 129
使用消息队列完成两个进程间相互通信。
华清 day5 作业代码作业 作业
07-15
华清 day5 作业代码作业 作业
华清远见-C基础学习-Day1-思维导图
09-22
华清远见-C基础学习-Day1-思维导图
五年级英语下册Unit1Myday第5课时作业人教PEP版
09-09
这篇五年级英语下册Unit1 My day第5课时作业主要涵盖了日常生活活动的英语表达，动词的使用，以及简单的阅读理解。以下是相关的知识点： 1. **动词短语**： - `take a dancing class`: 表示“上舞蹈课”，其中动词...
基于Python的2024年5月28日day01晚自习作业设计源码
10-08
该项目为2024年5月28日day01晚自习的Python作业设计源码，包含24个文件，包括11个Python源文件、5个XML配置文件、4个Markdown文档、2个Git忽略文件、1个开源协议文件、1个IntelliJ IDEA项目文件。这些文件共同构成了...
【数据结构】【链表代码】移除链表元素
Indigo____的博客
10-06 484
【代码】【数据结构】【链表代码】
【数据结构】【队列】算法汇总
Indigo____的博客
10-07 337
【代码】【数据结构】【队列】算法汇总。
#Swift 递归枚举 VS Struct 实现自引用 数据结构 （链表 二叉树）
B9班的真高兴
10-07 617
Enumeration 和 Struct 是 value type 实现 自引用 (self retain) 的数据类型，可以有效避免引用计数管理的问题（Class 是 reference type），递归枚举 因为在自引用类型的使用上和处理上不需要考虑 Struct 实现的空节点 Optional 类型的处理，更readable一些。
《数据结构》--队列【各种实现，算法推荐】
Stark的博客
10-06 882
队列是一种常见的数据结构，按照先进先出（FIFO，First In First Out）的原则排列数据。也就是说，最早进入队列的元素最先被移除。：将元素添加到队列的尾部。：从队列的头部移除并返回元素。：初始化一个空队列。：返回但不移除队列的头部元素（通常称为“peek”或“front”）。：检查队列中是否还有元素。：返回队列中元素的数量。
数据结构编程实践20讲(Python版)—09B树
最新发布
AnFany
10-12 785
数据结构编程实践20讲(Python版)—09B树
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值