寒假作业：2024/2/4
作业1：编程实现双向链表的头插、头删、尾插、尾删
1.1头插：
函数代码：
#include "head.h"
/*
* function: 双向链表节点创建
* @param [ in]
* @param [out]
* @return 成功返回节点，失败返回NULL
*/
Doublelist create()
{
Doublelist s=(Doublelist)malloc(sizeof(struct Node));
//失败返回NULL
if(NULL==s)
return NULL;
//成功则初始化返回节点
s->data=0;
s->next=s->prev=NULL;
return s;
}
/*
* function: 头插
* @param [ in]
* @param [out] 头，插入的值
* @return 头
*/
Doublelist inster_head(Doublelist head,datatype element)
{
//先创建新节点
Doublelist s=create();
s->data=element;
//如果链表为空
if(NULL==head){
head=s;
}else{//不为空
s->next=head;
head->prev=s;
head=s;
}
return head;
}
效果图：
1.2尾插：
函数代码：
/*
* function: 尾插
* @param [ in]
* @param [out] 头，插入的值
* @return 头
*/
Doublelist inster_rear(Doublelist head,datatype element)
{
//创建新节点
Doublelist s=create();
s->data=element;
//链表为空
if(NULL==head){
head=s;
}else{//链表不为空
//找到尾节点
Doublelist p=head;
while(p->next!=NULL)
{
p=p->next;
}
p->next=s;
s->prev=p;
}
return head;
}
效果图：
1.3头删：
函数代码：
/*
* function: 头删
* @param [ in]
* @param [out] 头
* @return 头
*/
Doublelist delete_head(Doublelist head)
{
//链表为空
if(NULL==head)
return head;
//链表不为空
Doublelist del=head;
head=head->next;
head->prev=NULL;
free(del);
del=NULL;
return head;
}
效果图：
1.4尾删：
函数代码：
/*
* function: 尾删
* @param [ in]
* @param [out] 头
* @return 头
*/
Doublelist delete_rear(Doublelist head)
{
//如果链表为空
if(NULL==head)
return head;
//如果链表只有一个节点
if(head->next==NULL)
{
free(head);
head=NULL;
return head;
}
//链表有多个节点
Doublelist p=head;
while(p->next!=NULL)
{
p=p->next;
}
p->prev->next=NULL;
free(p);
p=NULL;
return head;
}
效果图：
作业2：编程实现双向链表按任意位置插入、删除、修改、查找
2.1插入
函数代码：
/*
* function: 计算链表长度
* @param [ in]
* @param [out] 头
* @return 长度
*/
int length(Doublelist head)
{
int len=0;
Doublelist p=head;
while(p)
{
len++;
p=p->next;
}
return len;
}
/*
* function: 任意位置插入
* @param [ in]
* @param [out] 头，位置，插入的值
* @return 头
*/
Doublelist inster_index(Doublelist head,int pos,datatype element)
{
//判断链表是否为空，插入的位置是否合法
if(NULL==head || pos<1 || pos>length(head)+1)
{
puts("empty or pos is error");
return head;
}
//创建新节点
Doublelist s=create();
s->data=element;
//判断是否在第一个位置插入
if(pos==1){
head=inster_head(head,element);
return head;
}
//判断是否是在最后一个位置插入
if(pos==length(head)+1)
{
head=inster_rear(head,element);
return head;
}
//在其他位置插入
Doublelist p=head;
for(int i=1;inext;
}
s->next=p->next;
s->prev=p;
p->next->prev=s;
p->next=s;
return head;
}
效果图：
2.2删除
函数代码：
/*
* function: 按任意位置删除
* @param [ in]
* @param [out] 头，删除的位置
* @return 头
*/
Doublelist delete_index(Doublelist head,int pos)
{
//链表为空，位置不合法
if(NULL==head || pos<1 || pos>length(head))
{
puts("empty or pos is error");
return head;
}
//在第一个位置删除
if(pos==1)
{
head=delete_head(head);
return head;
}
//在最后一个位置删除
if(pos==length(head))
{
head=delete_rear(head);
return head;
}
//不是第一个位置删除
Doublelist p=head;
for(int i=1;inext;
}
Doublelist del=p->next;
p->next=del->next;
del->next->prev=p;
free(del);
del=NULL;
return head;
}
效果图：
2.3修改
函数代码：
/*
* function: 按任意位置修改
* @param [ in]
* @param [out] 头，位置，修改的值
* @return 无
*/
void modify_index(Doublelist head,datatype element,int pos)
{
//链表为空，位置不合法
if(NULL==head || pos<1 || pos>length(head))
{
puts("empty or pos is error");
return;
}
//链表不为空且位置合法
Doublelist p=head;
for(int i=1;inext;
}
p->data=element;
}
效果图：
2.4查找：
函数代码：
/*
* function: 按任意位置查找
* @param [ in]
* @param [out] 头，位置
* @return 无
*/
void search_index(Doublelist head,int pos)
{
//判断链表是否为空，位置是否合法
if(NULL==head || pos<1 || pos>length(head))
{
puts("empty or pos is error");
return;
}
Doublelist p=head;
for(int i=1;inext;
}
printf("%d\n",p->data);
}
效果图：
总代码：
head.h:
#ifndef __HEAD_H__
#define __HEAD_H__
#include
#include
#include
typedef int datatype;
//双向链表节点结构体的创建
typedef struct Node
{
//数据域
datatype data;
//指向下一个节点的指针域
struct Node *next;
//指向上一个节点的指针域、
struct Node *prev;
}*Doublelist;
//函数声明
Doublelist create();
Doublelist inster_head(Doublelist head,datatype element);
Doublelist delete_head(Doublelist head);
Doublelist inster_rear(Doublelist head,datatype element);
Doublelist delete_rear(Doublelist head);
int length(Doublelist head);
Doublelist inster_index(Doublelist head,int pos,datatype element);
Doublelist delete_index(Doublelist head,int pos);
void modify_index(Doublelist head,datatype element,int pos);
void search_index(Doublelist head,int pos);
void output(Doublelist head);
#endif
main,c:
#include "head.h"
int main(int argc, const char *argv[])
{
Doublelist head=NULL;
int n;
printf("please enter n:");
scanf("%d",&n);
datatype element;
int pos;
for(int i=0;itest.c:
#include "head.h"
/*
* function: 双向链表节点创建
* @param [ in]
* @param [out]
* @return 成功返回节点，失败返回NULL
*/
Doublelist create()
{
Doublelist s=(Doublelist)malloc(sizeof(struct Node));
//失败返回NULL
if(NULL==s)
return NULL;
//成功则初始化返回节点
s->data=0;
s->next=s->prev=NULL;
return s;
}
/*
* function: 头插
* @param [ in]
* @param [out] 头，插入的值
* @return 头
*/
Doublelist inster_head(Doublelist head,datatype element)
{
//先创建新节点
Doublelist s=create();
s->data=element;
//如果链表为空
if(NULL==head){
head=s;
}else{//不为空
s->next=head;
head->prev=s;
head=s;
}
return head;
}
/*
* function: 头删
* @param [ in]
* @param [out] 头
* @return 头
*/
Doublelist delete_head(Doublelist head)
{
//链表为空
if(NULL==head)
return head;
//链表不为空
Doublelist del=head;
head=head->next;
head->prev=NULL;
free(del);
del=NULL;
return head;
}
/*
* function: 尾插
* @param [ in]
* @param [out] 头，插入的值
* @return 头
*/
Doublelist inster_rear(Doublelist head,datatype element)
{
//创建新节点
Doublelist s=create();
s->data=element;
//链表为空
if(NULL==head){
head=s;
}else{//链表不为空
//找到尾节点
Doublelist p=head;
while(p->next!=NULL)
{
p=p->next;
}
p->next=s;
s->prev=p;
}
return head;
}
/*
* function: 尾删
* @param [ in]
* @param [out] 头
* @return 头
*/
Doublelist delete_rear(Doublelist head)
{
//如果链表为空
if(NULL==head)
return head;
//如果链表只有一个节点
if(head->next==NULL)
{
free(head);
head=NULL;
return head;
}
//链表有多个节点
Doublelist p=head;
while(p->next!=NULL)
{
p=p->next;
}
p->prev->next=NULL;
free(p);
p=NULL;
return head;
}
/*
* function: 计算链表长度
* @param [ in]
* @param [out] 头
* @return 长度
*/
int length(Doublelist head)
{
int len=0;
Doublelist p=head;
while(p)
{
len++;
p=p->next;
}
return len;
}
/*
* function: 任意位置插入
* @param [ in]
* @param [out] 头，位置，插入的值
* @return 头
*/
Doublelist inster_index(Doublelist head,int pos,datatype element)
{
//判断链表是否为空，插入的位置是否合法
if(NULL==head || pos<1 || pos>length(head)+1)
{
puts("empty or pos is error");
return head;
}
//创建新节点
Doublelist s=create();
s->data=element;
//判断是否在第一个位置插入
if(pos==1){
head=inster_head(head,element);
return head;
}
//判断是否是在最后一个位置插入
if(pos==length(head)+1)
{
head=inster_rear(head,element);
return head;
}
//在其他位置插入
Doublelist p=head;
for(int i=1;inext;
}
s->next=p->next;
s->prev=p;
p->next->prev=s;
p->next=s;
return head;
}
/*
* function: 按任意位置删除
* @param [ in]
* @param [out] 头，删除的位置
* @return 头
*/
Doublelist delete_index(Doublelist head,int pos)
{
//链表为空，位置不合法
if(NULL==head || pos<1 || pos>length(head))
{
puts("empty or pos is error");
return head;
}
//在第一个位置删除
if(pos==1)
{
head=delete_head(head);
return head;
}
//在最后一个位置删除
if(pos==length(head))
{
head=delete_rear(head);
return head;
}
//不是第一个位置删除
Doublelist p=head;
for(int i=1;inext;
}
Doublelist del=p->next;
p->next=del->next;
del->next->prev=p;
free(del);
del=NULL;
return head;
}
/*
* function: 按任意位置修改
* @param [ in]
* @param [out] 头，位置，修改的值
* @return 无
*/
void modify_index(Doublelist head,datatype element,int pos)
{
//链表为空，位置不合法
if(NULL==head || pos<1 || pos>length(head))
{
puts("empty or pos is error");
return;
}
//链表不为空且位置合法
Doublelist p=head;
for(int i=1;inext;
}
p->data=element;
}
/*
* function: 按任意位置查找
* @param [ in]
* @param [out] 头，位置
* @return 无
*/
void search_index(Doublelist head,int pos)
{
//判断链表是否为空，位置是否合法
if(NULL==head || pos<1 || pos>length(head))
{
puts("empty or pos is error");
return;
}
Doublelist p=head;
for(int i=1;inext;
}
printf("%d\n",p->data);
}
/*
* function: 双向链表的遍历
* @param [ in]
* @param [out] 头
* @return 无
*/
void output(Doublelist head)
{
if(NULL==head)
return;
//正向遍历
Doublelist p=head;
while(p->next!=NULL)
{
printf("%-4d",p->data);
p=p->next;
}
printf("%-4d\n",p->data);
//逆向遍历
while(p!=NULL)
{
printf("%-4d",p->data);
p=p->prev;
}
puts("");
}
作业3：简述栈和队列的区别
栈：
1.栈是只能在栈顶插入和删除的操作受限的线性表
2.栈的思想是先进后出
队列：
1.队列是只能在队头删除，队尾插入的操作受限的线性表
2.队列的思想是先进先出
作业4：简述空间泄露
空间泄露：是指在堆区手动申请了内存，在手动释放时未让指针指向申请的内存的首地址，导致只手动释放了一部分内存，剩下的内存丢失，造成了空间泄露。