419作业

最新推荐文章于 2024-07-21 14:33:09 发布

HОИОЯ

最新推荐文章于 2024-07-21 14:33:09 发布

阅读量24

点赞数

文章标签：链表数据结构算法

本文链接：https://blog.csdn.net/weixin_46286353/article/details/130285748

版权

//head.h
#ifndef __HEAD_H__

#define __HEAD_H__

#include <stdio.h>
#include <stdlib.h>
typedef int datatype;
//定义节点
typedef struct Node
{
	//数据域
	union{
		int len;//头节点的数据域：链表长度
		datatype data;//其他节点的数据域:数据元素
	};
	//指针域：下一个节点的地址
	struct Node *next;
}*linklist;

int delete_rear(linklist L);

int search_pos(linklist L,int pos);
int delete_pos(linklist L,int pos);
int insert_pos(linklist L,int pos,datatype e);
int delete_head(linklist L);
int insert_rear(linklist L,datatype e);
linklist create_head(int flag);
int insert_head(linklist L,datatype e);
void output(linklist L);

void rev_lilinklist(linklist L);
int search_data(linklist L,datatype e);


#endif

//main.c
#include "head.h"
int main(int argc, const char *argv[])
{
	linklist L=create_head(1);//1表示创建头

#if 0
	//头插：在头结点的后面插入
	int n;
	datatype e;
	printf("请输入插入数据元素的个数：");
		scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("请输入插入的值：");
		scanf("%d",&e);
		insert_head(L,e);
	}
	output(L);
#endif
	//尾插：在尾部插入
	int n;
	int pos;
	datatype e;
	printf("请输入插入数据元素的个数：");
		scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("请输入插入的值：");
		scanf("%d",&e);
		insert_rear(L,e);
	}
	output(L);

#if 0
	//头删除：删除头结点后面的节点
	delete_head(L);
	delete_head(L);
	printf("头删的结果是\n");
	output(L);
#endif
#if 0
	//尾部删除：删除的最后一个节点
	delete_rear(L);
	delete_rear(L);
	output(L);
#endif
#if 0
	//按位置插入
	printf("请输入插入的位置：");
	scanf("%d",&pos);
	printf("请输入插入的值：");
	scanf("%d",&e);
	insert_pos(L,pos,e);
	output(L);

	//按位置删除
	printf("请输入删除的位置：");
	scanf("%d",&pos);
	delete_pos(L,pos);
	output(L);

	//按位置查找
	printf("请输入查找的位置：");
	scanf("%d",&pos);
	search_pos(L,pos);
#endif	
	//按元素查找
	printf("请输入查找的元素：");
	scanf("%d",&e);
	pos=search_data(L,e);
	if(pos==-1)
	{
		printf("查找失败\n");
	}
	else
	{
		printf("在%d位置查找成功\n",pos);
	}
	//逆置
	rev_lilinklist(L);
	output(L);
	return 0;
}

//test.c
#include "head.h"

/*
 * function:    创建头结点
 * @param [ in] flag=0:普通节点的创建
 * @param [out] flag=1:头节点的创建
 * @return      成功返回地址 失败返回NULL
 */
linklist create_head(int flag)
{
	linklist L=(linklist)malloc(sizeof(struct Node));
	if(L==NULL)
	{
		return NULL;
	}
	if(flag==1)
	{
	//头节点的数据域
	L->len=0;
	}
	else if(flag==0)
	{
		L->data=0;
	}
	//头节点的指针域
	L->next=NULL;
	return L;
}
/*
 * function:    创建其他节点
 * @param [ in] 无
 @param [out] 
 * @return      成功返回地址 失败返回NULL
 */
#if 0
linklist create_node()
{
	linklist p=(linklist)malloc(sizeof(struct Node));
	if(p==NULL)
	{
		return NULL;
	}
	//P的数据域
	p->data=0;
	//p的指针域
	p->next=NULL;
	return p;
}
#endif

/*
 * function:    头插
 * @param [ in] 
 * @param [out] 链表头节点 插入的值 
 * @return      成功返回0 失败返回-1
 */
int insert_head(linklist L,datatype e)
{
	//1,判断链表是否创建成功
	if(L==NULL)
	{
		printf("头插失败\n");
		return -1;
	}
	//2,插入新节点s
	//0表示创建普通节点
	linklist s=create_head(0);
	if(s==NULL)
	{
		return -1;
	}
	//s的数据域
	s->data=e;
	//s的指针域
	s->next=L->next;
	L->next=s;
	L->len++;
}
/*
 * function:    输出
 * @param [ in] 链表 
 * @param [out] 
 * @return      无
 */
void output(linklist L)
{
	//1,判断链表是否创建成功
	//2，判断链表是否为空
	//  L->len==0 L->next=NULL
	if(L==NULL || L->len==0)
	{
		printf("遍历失败\n");
		return;
	}
	//3，遍历
#if 0
	linklist p=L;
	for(int i=0;i<L->len;i++)
	{
		p=p->next;//后移
		printf("%d\t",p->data);
	}
#else
	linklist p=L;
	while(p->next!=NULL) //while(p->next)
	{
		p=p->next;
		printf("%d\t",p->data);
	}
#endif
	puts("");
}
/*
 * function:    尾部插入
 * @param [ in] 链表  插入的值
 * @param [out] 
 * @return      成功返回0  失败返回-1
 */
int insert_rear(linklist L,datatype e)
{
	//1,判断链表是否创建成功
	if(L==NULL)
	{
		return -1;
	}
	//2,插入的值
	linklist p=L;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	//3,在p节点的后面插入新节点s
	linklist s=create_head(0);
	if(s==NULL)
	{
		return -1;
	}
	s->data=e;
	p->next=s;
	L->len++;
}
/*
 * function:    头删除
 * @param [ in] 链表
 * @param [out] 
 * @return      成功返回0  失败返回-1
 */
int delete_head(linklist L)
{
	//1,判断链表是否创建成功
	//2.判断链表是否为空
	if( L==NULL || L->next==NULL)
	{
		return -1;
	}
	//3,删除
	linklist q=L->next;
	L->next=q->next;
	free(q);
	q=NULL;
	L->len--;
}
/*
 * function:    尾部删除
 * @param [ in] 链表
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delete_rear(linklist L)
{
	//1,判断链表是否创建成功
	//2，判断链表是否为空
	if(L==NULL || L->next==NULL)
	{
		return -1;
	}
	//3,循环到倒数第2个
	linklist p=L;
	while(p->next->next!=NULL)
	{
		p=p->next;
	}
	//4，删除p->next
	linklist q=p->next;
	p->next=q->next;
	free(q);
	q=NULL;
	L->len--;
}
/*
 * function:    按位置插入
 * @param [ in] 链表 位置 插入的值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int insert_pos(linklist L,int pos,datatype e)
{
	//1,判断链表是否创建成功
	//2，判断链表是否为空
	//3.判断位置是否合法
	if(L==NULL || pos<1 || pos>L->len+1)
	{
		printf("插入失败\n");
		return -1;
	}
	//3,循环到pos-1起名字p
	linklist p=L;
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	//4,创建新节点s插入
	linklist s=create_head(0);
	if(s==NULL)
	{
		return -1;
	}
	//s的数据域
	s->data=e;
	//s的指针域
	s->next=p->next;
	p->next=s;
	L->len++;
	return 0;
}
/*
 * function:    按位置删除
 * @param [ in] 链表   删除的位置
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delete_pos(linklist L,int pos)
{
	//1,判断链表是否创建成功
	//2，判断链表是否为空
	//3，判断位置是否合法
	if(L==NULL || L->next==NULL || pos<1||pos>L->len)
	{
		return -1;
	}
	//4,循环到pos-1,起名字p
	
	linklist p=L;
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	//5,删除p->next
	linklist q=p->next;
	p->next=q->next;
	free(q);
	q=NULL;
	L->len--;
	return 0;
}
/*
 * function:    按位置查找
 * @param [ in] 链表  查找的位置
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int search_pos(linklist L,int pos)
{
	//1,判断链表是否创建成功
	//2，判断链表是否为空
	//3，判断位置是否合法
	if(L==NULL ||L->next==NULL || pos<1|| pos>L->len)
	{
		return -1;
	}
	//4,循环到pos起名字p
	linklist p=L;
	for(int i=0;i<pos;i++)
	{
		p=p->next;
	}
	//5，查找：输出
	printf("查找的值是：%d\n",p->data);
	return 0;
}

/*
 * function:    按元素查找
 * @param [ in] 链表 查找的值
 * @param [out] 
 * @return      成功返回位置 失败返回-1 
 */
int search_data(linklist L,datatype e)
{
	//1,判断链表是否创建成功
	//2，判断链表是否为空
	if(L==NULL || L->next==NULL)
	{
		return -1;
	}
	//3,查找
	
	linklist p=L;
	int pos=1;
	while(p->next!=NULL) 
	{
		p=p->next;

		if(p->data==e)
		{
			return pos;
		}
		pos++;
	}
	return -1;
}
/*
 * function:    逆置
 * @param [ in] 链表
 * @param [out] 
 * @return      无
 */
void rev_lilinklist(linklist L)
{
	//1,判断链表是否创建成功
	//2，判断链表是否为空
	if(L==NULL ||L->next==NULL)
	{
		return;
	}

	//3,如果只有一个元素，则不需要逆置
	if(L->len==1)
	{
		printf("只有一个元素，无需逆置\n");
		return;
	}
	//4,逆置
	linklist p=L->next;
	L->next=NULL;
	while(p!=NULL)
	{
		linklist t=p;
		p=p->next;

		t->next=L->next;
		L->next=t;
	}
}