寒假作业2024.2.4

1.请编程实现双向链表的头插，头删、尾插、尾删

请编程实现双向链表按任意位置插入、删除、修改、查找

头文件：

#ifndef _HEAD_H_
#define _HEAD_H_
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
//枚举
enum A
{
	FALSE=-1,
	SUCCESS
};
typedef char datatype;
//定义双向链表结构体
typedef struct Node
{
	//数据域：存储数据元素
	datatype data;
	//指针域：下一个节点的地址
	struct Node*next;
	//指针域：上一个节点的地址
	struct Node*prev;	
}*Doublelink;
 
Doublelink create();
Doublelink insert_head(Doublelink head,datatype element);
void output(Doublelink head);
Doublelink insert_tail(Doublelink head,datatype element);
Doublelink delet_head(Doublelink head);
Doublelink delet_tail(Doublelink head);
int length(Doublelink head);
Doublelink insert_pos(Doublelink head,int pos,datatype element);
Doublelink delet_pos(Doublelink head,int pos);
Doublelink amend_pos(Doublelink head,int pos,datatype element);
Doublelink search_pos(Doublelink head,int pos);

#endif

主函数：

#include "head.h"
int main(int argc, const char *argv[])
{
	Doublelink head=NULL;
	int n;
	int pos;
	datatype element;
	printf("please enter n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("please enter element:");
		scanf(" %c",&element);
//		head=insert_head(head,element);//头插
		head=insert_tail(head,element);//尾插
	}
	output(head);
	
/*	head=delet_head(head);//头删
	output(head);
	
	head=delet_tail(head);//尾删
	output(head);
*/	
	//双链表按任意位置插入
	printf("please enter insert pos and insert element:");
	scanf(" %d %c",&pos,&element);
	head=insert_pos(head,pos,element);
	output(head);
	//双链表按任意位置删除
	printf("please enter delet pos:");
	scanf(" %d",&pos);
	head=delet_pos(head,pos);
	output(head);

	//双链表按任意位置修改
	printf("please enter amend pos and amend element:");
	scanf(" %d %c",&pos,&element);
	head=amend_pos(head,pos,element);
	output(head);

	//双链表按任意位置查找
	printf("please enter search pos:");
	scanf(" %d",&pos);
	Doublelink q=search_pos(head,pos);
	printf("the search element is:%c\n",q->data);
	return 0;
}

 封装函数

#include "head.h"
//创建新节点
Doublelink create()
{
	Doublelink s=(Doublelink)malloc(sizeof(struct Node));
	if(s==NULL)
		return NULL;
	s->data=0;
	s->next=NULL;
	s->prev=NULL;
	return s;
}
//头插
Doublelink insert_head(Doublelink head,datatype element)
{
	Doublelink s=create();
	s->data=element;
	if(NULL==head)
		head=s;
	else
	{
		s->next=head;
		head->prev=s;
		head=s;
	}
	return head;
}
//遍历输出
void output(Doublelink head)
{
	if(NULL==head)
	{
		puts("empty");
		return;
	}
	//2,循环遍历
	else
	{
		Doublelink p=head;
		//正向
		puts("正向输出");
		while(p->next!=NULL)
		{
			printf("%-4c",p->data);
			p=p->next;//后移
		}
		printf("%-4c\n",p->data);
		/*		//逆向
				puts("逆向输出");
				while(p!=NULL)
				{
				printf("%-4c",p->data);
				p=p->prev;//前移
				} 
				puts("");
				*/
	}
 
}   
//尾插
Doublelink insert_tail(Doublelink head,datatype element)
{
	Doublelink s=create();
	s->data=element;
	if(NULL==head)
		head=s;
	else
	{
		Doublelink p=head;
		while(p->next!=NULL)
		{
			p=p->next;
		}
		p->next=s;
		s->prev=p;
	}
	return head;
}
//头删
Doublelink delet_head(Doublelink head)
{
	if(head==NULL)
	{
		return head;
	}
	else
	{
		Doublelink del=head;
		head=head->next;
		head->prev=NULL;
		free(del);
		del=NULL;
		return head;
	}
}
//尾删
Doublelink delet_tail(Doublelink head)
{
	if(head==NULL)
	{
		return head;
	}
	else
	{
		Doublelink p=head;
		if(p->next==NULL)
		{
			free(head);
			head=NULL;
			return head;
		}
		else
		{
			while(p->next!=NULL)
			{
				p=p->next;
			}
			p->prev->next=NULL;
			free(p);
			p=NULL;
			return head;
		}
	}
}
//计算双向链表长度
int length(Doublelink head)
{
	int len=0;
	Doublelink p=head;
	while(p!=NULL)
	{
		len++;
		p=p->next;
	}
	return len;
}
//双链表按任意位置插入
Doublelink insert_pos(Doublelink head,int pos,datatype element)
{
	if(pos<1 || pos>length(head)+1)
	{
		puts("pos error");
		return head;
	}
	Doublelink s=create();
	s->data=element;
	if(pos==1)
	{
		head=insert_head(head,element);
		return head;
	}
	else
	{
		Doublelink p=head;
		for(int i=1;i<pos-1;i++)
		{
			p=p->next;
		}
		s->next=p->next;
		p->next=s;
		p->next->prev=s;
		s->prev=p;
		return head;
	}
}
//双链表按任意位置删除
Doublelink delet_pos(Doublelink head,int pos)
{
	if(pos<1 || pos>length(head))
	{
		puts("pos error");
		return head;
	}
	if(pos==1)
	{
		head=delet_head(head);
		return head;
	}
	else if(pos==length(head))
	{
		head=delet_tail(head);
		return head;
	}
	else
	{
		Doublelink p=head;
		for(int i=1;i<pos-1;i++)
		{
			p=p->next;
		}
		Doublelink del=p->next;
		del->prev->next=del->next;
		del->next->prev=del->prev;
		del->next=del;
		del->prev=del;
		free(del);
		del=NULL;
		return head;
	}
}
//双向链表按任意位置修改
Doublelink amend_pos(Doublelink head,int pos,datatype element)
{
	if(pos<1 || pos>length(head))
	{
		puts("pos error");
		return head;
	}
	Doublelink p=head;
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	p->data=element;
	return head;
}
//双向链表按任意位置查找
Doublelink search_pos(Doublelink head,int pos)
{
	if(pos<1 || pos>length(head))
	{
		puts("pos error");
		return head;
	}
	Doublelink p=head;
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	return p;	
}

现象展示：

3.请简述栈和队列的区别

（1）栈在一端（栈顶）实现插入和删除，队列：在两端（队头，队尾）实现插入和删除）

（2）栈的思想是先进后出，队列思想是先进先出 

4.请简述什么内存泄露?

     内存泄漏是指程序运行过程中申请了内存空间，但没有释放，导致这部分内存无法再被其他程序使用。内存泄漏可能会导致程序运行时占用的内存越来越多，最终导致系统性能下降或者程序崩溃。

内存泄露有以下几种情况：

(1)忘记释放动态分配的内存：

        当我们使用malloc分配内存时，需要在使用完毕后使用free来释放内存。如果忘记释放，就会造成内存泄漏。

(2)丢失指向动态分配内存的指针:

        当一个指针指向动态分配的内存，但该指针被重新赋值或者丢失，导致无法释放这块内存，也会造成内存泄漏。