数据结构和算法（三）

最新推荐文章于 2022-12-05 15:13:56 发布
最新推荐文章于 2022-12-05 15:13:56 发布
阅读量257 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40979987/article/details/109017495
版权

作业分析讲解
================
    1.  结构体相关的
                 结构体变量之间可以直接赋值
                 结构体变量比较不能用 ==   >    <
                 判断结构体大小，把结构体中所有的成员一个个比较


双向链表
================
    1.  原理： 在单向链表的基础上多增加了一个指针(指向前面一个节点的指针)
             总结成公式           struct  双向链表的名字
                                       {
                                                 int data;  //真实的数据     数据域
                                                 struct 双向链表的名字 *prev;   //指向前面一个节点的指针
                                                 struct 双向链表的名字 *next;   //指向后面一个节点的指针
                                       };
        双向链表多了一个指针，没有增加代码书写的难度，相反降低了难度
        双向链表： 一定是可以只用一个指针解决增删改查的操作
        总结链表的几种写法技巧：
                 while(p!=NULL)   //遍历完链表  p指向最后一个节点的后面
                 while(p->next!=NULL)  //循环退出，p指向最后一个节点
    2. 找好工作基础四大件
               数据结构和算法 --》逻辑思维怎么样
               操作系统 --》linux  
               网络编程 --》
               刷题做好经验上的准备--》leetcode这个app刷题

练习：
        训练大家对应链表代码书写的技巧(画图，配合代码书写)
        双向循环链表的代码和图示分析

双向循环链表
==============
     1. 在双向链表的基础上，首尾相接
                while(p!=NULL)  --》while(p!=head)
         注意：双向循环链表，插入和删除注意最后一个节点的写法发生改变，中间位置的节点写法一样


作业：
      1.  使用今天学习的双向循环链表配合目录操作，读取一个目录中所有的bmp图片路径，存放到双向循环链表，实现图片上一张，下一张的显示


内核链表  栈    队列   树和二叉树   BST  
============
     

单链表的销毁

#include "myhead.h"

//封装一个结构体表示单链表
typedef struct siglist
{
	int data; //存放真实数据
	struct siglist *next; //指向下一个节点的指针
}list,*plist;

//链表的初始化
plist init_list()
{
	//初始化了一个空的头节点(没有存放任何有效数据)
	plist head=malloc(sizeof(list));
	head->next=NULL;
	return head;
}

//插入数据(尾部插入)
int insert_tail(int newdata,plist head)
{
	//准备一个新的节点
	plist newnode=malloc(sizeof(list));
	newnode->data=newdata;
	newnode->next=NULL;
	
	//把新的节点插入到链表的尾部
	plist p=head;
	while(p->next!=NULL) //找到尾部
		p=p->next;  //p=p+1;错误，链表中节点并不是连续(可能连续可能不连续)
	//插入新的节点
	p->next=newnode;
	return 0;
}

//插入数据，中间插入 把newdata插入到olddata的后面
int insert_mid(int olddata,int newdata,plist head)
{
	//准备好新的节点
	plist newnode=malloc(sizeof(list));
	newnode->data=newdata;
	newnode->next=NULL;
	
	//找到olddata节点的位置
	plist p=head;
	while(p->next!=NULL)
	{
		p=p->next;
		if(p->data==olddata) //找到了就结束循环
			break;
	}
	//循环结束，并且最后一个节点也不等于olddata，说明没有olddata
	if(p->next==NULL && p->data!=olddata)
	{
		printf("对不起，你要插入的数据 %d 不存在!\n",olddata);
		return -1;
	}
	//把新的节点插入到p的后面
	newnode->next=p->next;
	p->next=newnode;
	return 0;
}

//单链表删除，只用一个指针(有bug的,删除不干净)
int remove_list(int deldata,plist head)
{
	//找到要删除的节点的前一个节点
	plist p=head;
	while(p->next!=NULL)
	{
		//if(p->data==deldata)  //p指向的是要删除的节点，不对
		if(p->next->data==deldata) //p指向的是要删除的节点前面一个
			break;
		p=p->next;
	}
	//删除p后面的一个节点
	p->next=p->next->next;  //删除得不够彻底
	return 0;
}

//用两个指针删除节点
int remove_list2(int deldata,plist head)
{
	plist q=head;
	plist p=head->next;
	int flag=0;
	//往后一前一后遍历
	while(p->next!=NULL) //漏掉最后一个节点
	{
		if(p->data==deldata)  //把链表中所有重复出现的都删除
		{
			flag=1;
			//删除节点
			q->next=p->next;
			p->next=NULL;
			free(p);
			p=q->next;
			continue;
		}			
		p=p->next;
		q=q->next;
	}
	//判断最后一个节点,刚才循环漏掉了
	if(p->data==deldata)
	{
		//删除节点
		q->next=p->next;
		p->next=NULL;
		free(p);
	}
	//判断deldata不存在的情况
	if(flag==0)
	{
		printf("对不起，没有找到要删除的数据:%d\n",deldata);
		return -1;
	}
	
	return 0;
}

//每次删除链表的最后一个节点
int remove_tail(plist head)
{
	plist q=head;
	plist p=head->next;
	//往后一前一后遍历
	while(p->next!=NULL)
	{
		//两个指针一前一后挪动
		p=p->next;
		q=q->next;
	}
	
	//删除节点
	q->next=p->next;
	p->next=NULL;
	free(p);
	return 0;
}

//链表的销毁--》从最后一个节点开始(从后往前)一个个删除
int destroy_list(plist head)
{
	//统计一下链表中节点个数
	int count=0;
	plist p=head;
	while(p->next!=NULL)  
	{
		p=p->next;
		count++;
	}
	for(int i=0; i<count; i++) //删除所有的有效节点，头节点没有删除
		remove_tail(head);	
}

//链表的销毁--》从前往后一个个删除
int destroy_list2(plist head)
{
	//留给没有写出来的同学
	plist q=head->next;
	
	//循环删除
	while(q!=NULL)
	{
		head->next=head->next->next;
		q->next=NULL;
		free(q);
		//q往后挪动
		q=head->next;
	}
	return 0;
}

//打印链表
int show_list(plist head)
{
	plist p=head;
	//循环遍历打印
	while(p->next!=NULL)  //p的下一个节点不为NULL
	{
		p=p->next; //p指向下一个节点
		printf("我遍历到的节点中数据是:%d\n",p->data);
	}
	return 0;
}

int main()
{
	int delnum;
	//初始化一个头节点
	plist myhead=init_list();
	
	//尾部插入数据
	insert_tail(999,myhead);
	insert_tail(999,myhead);
	insert_tail(999,myhead);
	insert_tail(999,myhead);
	
	//中间插入
	insert_mid(999,44,myhead);
	
	printf("======插入完毕========\n");
	//打印链表
	show_list(myhead);
	
	//删除某个节点
	printf("请输入要删除的节点!\n");
	scanf("%d",&delnum);
	//remove_list(delnum,myhead);
	remove_list2(delnum,myhead);
	printf("======删除完毕========\n");
	//打印链表
	show_list(myhead); 
	
	//销毁链表
	//destroy_list(myhead);  //从后往前
	destroy_list2(myhead);  //从前往后
	printf("======销毁链表========\n");
	//打印链表
	show_list(myhead);
	free(myhead);
}

 

双向链表的基本操作

#include "myhead.h"

//定义一个结构体表示双向链表
struct doublelist
{
	int data; //真实数据
	struct doublelist *prev;
	struct doublelist *next; 
};

//初始化
struct doublelist *init_list()
{
	struct doublelist *head=malloc(sizeof(struct doublelist));
	head->prev=NULL;
	head->next=NULL;
	return head;
}

//尾插
int insert_tail(int newdata,struct doublelist *head)
{
	//定义新的节点
	struct doublelist *newnode=malloc(sizeof(struct doublelist));
	newnode->data=newdata;
	newnode->next=NULL;
	newnode->prev=NULL;
	
	//找到链表的尾部
	struct doublelist *p=head;
	while(p->next!=NULL)
		p=p->next;
	p->next=newnode;
	newnode->prev=p;
	return 0;
}

//中间插入  把newdata插入到olddata的后面
int insert_mid(int olddata,int newdata,struct doublelist *head)
{
	//准备新的节点
	struct doublelist *newnode=malloc(sizeof(struct doublelist));
	newnode->data=newdata;
	newnode->next=NULL;
	newnode->prev=NULL;
	
	//找到olddata
	struct doublelist *p=head;
	while(p!=NULL)  // 23  13  33  43
	{
		if(p->data==olddata)
			break;
		p=p->next;
	}
	//判断olddata不存在的情况
	if(p==NULL)
	{
		printf("对不起，没有%d这个数据!\n",olddata);
		return -1;
	}
	//特殊情况 p刚好指向最后一个节点时候
	if(p->next==NULL)
	{
		p->next=newnode;
		newnode->prev=p;
		return 0;
	}
	else{
		//插入新的节点
		newnode->next=p->next;
		p->next=newnode;
		newnode->next->prev=newnode;
		newnode->prev=p;
		return 0;
	}	
}

//删除
int remove_list(int deldata,struct doublelist *head)
{
	//找到要删除的数据
	struct doublelist *p=head;
	while(p!=NULL)  
	{
		if(p->data==deldata)
			break;
		p=p->next;
	}
	//判断deldata不存在的情况
	if(p==NULL)
	{
		printf("对不起，没有你要删除的数据:%d\n",deldata);
		return -1;
	}
	
	//判断p是最后一个节点的情况
	if(p->next==NULL)
	{
		p->prev->next=NULL;
		p->prev=NULL;
		free(p);
		p=NULL;
	}
	else
	{
		//删除p指向的节点
		p->prev->next=p->next;
		p->next->prev=p->prev;
		p->next=NULL;
		p->prev=NULL;
		free(p);
		p=NULL;
	}

}

//打印
int show_list(struct doublelist *head)
{
	struct doublelist *p=head;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("当前节点中的数据是:%d\n",p->data);
	}
	return 0;
}

//销毁链表
int destroy_list(struct doublelist *head)
{
	struct doublelist *p=head->next;
	while(p->next!=NULL)  //循环删除中间部分的节点，最后一个节点单独删除
	{
		printf("p当前遍历的节点:%d\n",p->data);
		head->next=p->next;
		p->next->prev=head;
		p->next=NULL;
		p->prev=NULL;
		free(p);
		//p继续挪动
		p=head->next;
	}
	//单独删除最后一个节点
	head->next=NULL;
	p->prev=NULL;
	free(p);
	p=NULL;
}

int main()
{
	int olddata,newdata;
	int deldata;
	//初始化一个双向链表
	struct doublelist *myhead=init_list();
	
	//尾插数据
	insert_tail(23,myhead);
	insert_tail(13,myhead);
	insert_tail(33,myhead);
	insert_tail(43,myhead);
	
	printf("====尾插完毕======\n");
	//打印
	show_list(myhead);
	
	/* //中间插入
	printf("请输入中间插入的数据！\n");
	scanf("%d%d",&olddata,&newdata);
	insert_mid(olddata,newdata,myhead);
	printf("====中间插入完毕======\n");
	//打印
	show_list(myhead);
	
	//删除
	printf("请输入要删除的数据!\n");
	scanf("%d",&deldata);
	remove_list(deldata,myhead);
	printf("====删除完毕======\n");
	//打印
	show_list(myhead); */
	
	//销毁链表
	destroy_list(myhead);
	printf("====销毁完毕======\n");
	//打印
	show_list(myhead);
	free(myhead);
}

双向循环链表的基本操作

#include "myhead.h"

//定义一个结构体表示双向循环链表
struct doublelist
{
	int data; //真实数据
	struct doublelist *prev;
	struct doublelist *next; 
};

//初始化
struct doublelist *init_list()
{
	struct doublelist *head=malloc(sizeof(struct doublelist));
	head->prev=head;
	head->next=head;
	return head;
}

//尾插
int insert_tail(int newdata,struct doublelist *head)
{
	//定义新的节点
	struct doublelist *newnode=malloc(sizeof(struct doublelist));
	newnode->data=newdata;
	newnode->next=NULL;
	newnode->prev=NULL;
	
	//找到链表的尾部
	struct doublelist *p=head;
	while(p->next!=head)
		p=p->next;
	p->next=newnode;
	newnode->prev=p;
	newnode->next=head;
	head->prev=newnode;
	return 0;
}

//中间插入  把newdata插入到olddata的后面
int insert_mid(int olddata,int newdata,struct doublelist *head)
{
	//准备新的节点
	struct doublelist *newnode=malloc(sizeof(struct doublelist));
	newnode->data=newdata;
	newnode->next=NULL;
	newnode->prev=NULL;
	
	//找到olddata
	struct doublelist *p=head->next;
	while(p!=head)  // 23  13  33  43
	{
		if(p->data==olddata)
			break;
		p=p->next;
	}
	//判断olddata不存在的情况
	if(p==head)
	{
		printf("对不起，没有%d这个数据!\n",olddata);
		return -1;
	}
	//特殊情况 p刚好指向最后一个节点时候
	if(p->next==head)
	{
		p->next=newnode;
		newnode->prev=p;
		newnode->next=head;
		head->prev=newnode;
		return 0;
	}
	else{
		//插入新的节点
		newnode->next=p->next;
		p->next=newnode;
		newnode->next->prev=newnode;
		newnode->prev=p;
		return 0;
	}	
}

//删除
int remove_list(int deldata,struct doublelist *head)
{
	//找到要删除的数据
	struct doublelist *p=head->next;
	while(p!=head)  
	{
		if(p->data==deldata)
			break;
		p=p->next;
	}
	//判断deldata不存在的情况
	if(p==head)
	{
		printf("对不起，没有你要删除的数据:%d\n",deldata);
		return -1;
	}
	
	//判断p是最后一个节点的情况
	if(p->next==head)
	{
		p->prev->next=head;
		head->prev=p->prev;
		p->prev=NULL;
		p->next=NULL;
		free(p);
		p=NULL;
	}
	else //删除中间的节点
	{
		//删除p指向的节点
		p->prev->next=p->next;
		p->next->prev=p->prev;
		p->next=NULL;
		p->prev=NULL;
		free(p);
		p=NULL;
	}

}

//打印
int show_list(struct doublelist *head)
{
	struct doublelist *p=head;
	while(p->next!=head)
	{
		p=p->next;
		printf("当前节点中的数据是:%d\n",p->data);
	}
	return 0;
}

//销毁链表
int destroy_list(struct doublelist *head)
{
	struct doublelist *p=head->next;
	while(p->next!=head)  //循环删除中间部分的节点，最后一个节点单独删除
	{
		head->next=p->next;
		p->next->prev=head;
		p->next=NULL;
		p->prev=NULL;
		free(p);
		//p继续挪动
		p=head->next;
	}
	//单独删除最后一个节点
	p->prev->next=head;
	head->prev=p->prev;
	p->prev=NULL;
	p->next=NULL;
	free(p);
	p=NULL;
}

int main()
{
	int olddata,newdata;
	int deldata;
	//初始化一个双向循环链表
	struct doublelist *myhead=init_list();
	
	//尾插数据
	insert_tail(23,myhead);
	insert_tail(13,myhead);
	insert_tail(33,myhead);
	insert_tail(43,myhead);
	
	printf("====尾插完毕======\n");
	//打印
	show_list(myhead);
	
	//中间插入
	printf("请输入中间插入的数据！\n");
	scanf("%d%d",&olddata,&newdata);
	insert_mid(olddata,newdata,myhead);
	printf("====中间插入完毕======\n");
	//打印
	show_list(myhead);
	
	//删除
	printf("请输入要删除的数据!\n");
	scanf("%d",&deldata);
	remove_list(deldata,myhead);
	printf("====删除完毕======\n");
	//打印
	show_list(myhead); 
	
	//销毁链表
	destroy_list(myhead);
	printf("====销毁完毕======\n");
	//打印
	show_list(myhead);
	free(myhead); 
}


 

qq_40979987
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
结构体比较
learn_sunzhuli的专栏
01-26 4634
对于自定义数据类型，如何进行高效的比较？ 这是在面试过程中碰到的一个编程细节。本文提供2中思路对结构体进行比较，显然方法二要更加高效。值得注意的是，在调用方法二时，必须提前对结构体中可能存在的内存缝隙进行填充。感谢面试官们在面试中的指导，特别钦佩有涵养有风度的技术咖！
数据结构与算法（三）
SiranTang的博客
04-03 185
C++ 数据结构与算法 后台开发 面试
c语言专业问题,c语言经典面试题目知识点详解（经典，非常详细）
weixin_34961316的博客
05-17 2759
作为IT行业人士需要掌握的最基本的计算机语言—c语言，如今的地位只高不低，c语言掌握程度的高低往往在面试的时候可以完全表现出来，而有些问题是大家平时似乎是知道的，但却不能完整准确地回答上来的，小编当年也遇到了很多此类问题，所以今天大家带来精心整理的C语言经典面试题 ，希望对大家有所帮助。温馨提示：文章末尾有亮点！已保存预处理问题一：什么是预编译？何时需要预编译？答：预编译又称预处理，是整个编译过程...
C语言结构体变量之间用“=“赋值会怎么样
hahamofu的博客
03-01 1414
结构体变量赋值
C语言中结构体用等号“=”直接赋值的讨论
热门推荐
行者三个石的博客
12-25 2万+
原文地址：https://blog.csdn.net/hazir/article/details/9429017 今天帮师姐调一个程序的BUG，师姐的程序中有个结构体直接赋值的语句，在我印象中结构体好像是不能直接赋值的，正如数组不能直接赋值那样，我怀疑这个地方有问题，但最后证明并不是这个问题。那么就总结一下C语言中结构体赋值的问题吧： 结构体直接赋值的实现 下面是一个实例： #include...
C语言判断两个结构体是否相等
weixin_44712231的博客
08-28 6347
c小记
遇到C语言结构体之间的操作
pangyinglong的博客
11-22 717
目的：比较两个同类型的结构体A、B是否相同 方法：A==B 结果：【error: invalid operands to binary ==】 原因：C语言中结构体不能直接使用==操作符进行比较 解决方法： 1、重载逻辑比较运算符，operate == < > >= <= (struct A, struct B){加入比较结构体的代码，返回bool值} 2...
数据结构和算法PDF文档
06-02
1000多页的算法题解，包含数据结构，排序，查找，递归，回溯算法，二叉树，动态规划，贪心算法，双指针，滑动窗口，前缀和等。
c++数据结构和算法合集.zip
12-28
c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 c++数据结构和算法合集 ...
数据结构和算法学习参考
06-17
数据结构和算法学习参考
数据结构和算法-思维导图.pdf
05-26
数据结构和算法思维导图
结构体没有重载==，不能判断相等！！没有重载=，可以赋值
pjl1119的专栏
04-04 3099
struct stStudent { int num; wstring name; wstring level; bool isTwo; };自定义的结构体，没有重载operator==，是不能进行等于判断的。没有重载operator=，可以进行赋值操作 stStudent a, b; a.isTwo = false; a.level = L"1"; a.name = L"zhans...
golang中如何比较struct,slice,map是否相等以及几种对比方法的区别
铁柱的博客
07-29 4438
对比两个struct或者map，slice是否相等是大家经常会有的需求，想必大家也都接触过很多对比的方式，比如等。这么多种对比方式，适用场景和优缺点都有哪些呢？为什么可以用==，有的却不可以呢？除了这三个，还有其他的方式可以判断相等吗？问题多多，且一起研究研究。Golang几种对象比较方法我们发现对比的两个结构是否相等，方式很多，效率也有高有低。选择合适自己需求的最重要。相对来说，cmp包是要更安全且可操作性更强一点，主要是看大家的喜好了。end。...
判断两个结构体相等
This is bill的专属博客
09-22 9415
好文得转！
c/c++结构体如何判断相等而且是否能相互赋值
biao2488890051的博客
12-05 5434
直接讲结论： 结构体之间， 是支持直接用等号=赋值的 但是不支持直接用==判断是否相等的，编译会报错
c语言结构体可以等号赋值吗_c语言结构体可以通过等号复制么？
weixin_40003478的博客
12-22 2401
#include <stdio.h>#include <stdlib.h>struct test{int a[5];};void print_test(struct test* a, const char* msg){int i;printf("%s:\t", msg);for (i = 0; i < 5; ++i)printf("%d ", a->a[i]);...
尚品汇项目思维导图 根据思维导图进行复习
最新发布
07-13
尚品汇项目思维导图 根据思维导图进行复习
Java数据结构和算法详细笔记
07-09
原博文指路：https://xiaoqistudy.blog.csdn.net/article/details/121134905?spm=1001.2014.3001.5502

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值