数据结构day4作业_单链表的相关操作代码_与数据结构单链表相关的编程作业和项目任务-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_64646641/article/details/145651267

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//节点结构体的定义
//节点包含数据域和指针域
//Node不可以省略
typedef  int datatype;
enum passble{SUCCESS,FALSE=-1};
typedef struct Node
{
	//数据域：存储数据元素
	datatype data;

	//指针域：节点之间的关系，下一个节点的地址
	struct Node *next;
}*Linklist;

void output_Linklist(Linklist head);

Linklist create_node();

Linklist insert_head(datatype element, Linklist head);

Linklist delete_head(Linklist head);

Linklist insert_tail(datatype element, Linklist head);

Linklist delete_tail(Linklist head);

int get_len(Linklist head);

Linklist insert_pos(Linklist head, int pos, datatype element);

Linklist delete_pos(Linklist head, int pos);

Linklist change_pos(Linklist head, int pos, datatype element);

Linklist find_pos(Linklist head, int pos);

int find_element(Linklist head, datatype element);

Linklist delete_element(Linklist head, datatype element);

Linklist change_element(Linklist head, datatype element ,datatype x);

Linklist reserve_linklist(Linklist head);

Linklist backwards_pos(Linklist head, int n);

void bubble_sort(Linklist head);

void free_Linklist(Linklist head);


#endif

main.c

#include "head.h"

int main(int argc, const char *argv[])
{
	
	//声明一个链表
	Linklist head=NULL;

	/************单链表的头插*************/
	//循环调用头插函数
	int n;
	printf("please enter n:");
	scanf("%d", &n);
	datatype element;
	for(int i=0; i<n; i++)
	{
		printf("please enter %d element:", i+1);
		scanf("%d", &element);
		head = insert_head(element, head);
	}
	output_Linklist(head);

	/************单链表的头删**************/
	head = delete_head(head);
	head = delete_head(head);
	output_Linklist(head);



	/***********单链表的尾插**************/
	printf("please enter n:");
	scanf("%d", &n);
	for(int i=0; i<n; i++)
	{
		printf("please enter %d element:", i+1);
		scanf("%d", &element);
		head = insert_tail(element, head);
	}
	output_Linklist(head);

	/***********单链表的尾删*************/
	head = delete_tail(head);
	output_Linklist(head);



	/************单链表的按位置插入***********/
	int pos;
	printf("please enter a pos what you want to insert:");
	scanf("%d", &pos);
	printf("please enter a element what you want to insert:");
	scanf("%d", &element);
	head = insert_pos(head, pos, element);
	output_Linklist(head);

	/****************单链表的按位置删除***********/
	printf("please enter a pos what you want to del:");
	scanf("%d", &pos);
	head = delete_pos(head, pos);
	output_Linklist(head);

	/****************单链表的按位置修改**********/
	printf("please enter a pos what you want to change:"); //输入需要修改的位置
	scanf("%d", &pos);
	printf("printf enter a element what you want to change:"); //输入修改后的值
	scanf("%d", &element);
	head = change_pos(head, pos, element);
	output_Linklist(head);

	/***************单链表的按位置查找**********/
	printf("please enter a pos what you want to find:"); //输入需要查找的位置
	scanf("%d", &pos);
	Linklist result = find_pos(head, pos);
	if(result != NULL)
	{
		printf("the element at pos %d is %d\n", pos, result->data);
	}
	else 
		printf("pos is invalid\n");

	output_Linklist(head);

	/***************单链表的按元素查找**********/
	printf("please enter a element what you want to find:");
	scanf("%d", &element);
	pos = find_element(head, element);
	if(pos != -1)
		printf("element %d found in pos %d\n", element, pos);
	else
		printf("element %d not found in the Linklist\n", element);

	output_Linklist(head);

	/**********单链表的按元素删除***************/
	printf("please enter a element what you want to del:");
	scanf("%d", &element);
	head = delete_element(head, element);
	output_Linklist(head);

	/*************单链表的按元素修改***********/
	datatype x;
	printf("please enter what you wang to change element:");
	scanf("%d", &element);
	printf("please enter a new element:");
	scanf("%d", &x);
	head = change_element(head, element, x);
	output_Linklist(head);

	/**************单链表的逆置*************/
	head = reserve_linklist(head);
	output_Linklist(head);

	/**************单链表查找倒数第n个节点******/
	printf("please enter a count backwards pos:");
	scanf("%d", &pos);
	result = backwards_pos(head, pos);
	if(result != NULL)
	{
		printf("the count backwards pos %d element is %d\n", pos, result->data);
	}
	else
		printf("invalid pos or empty list\n");

	output_Linklist(head);

	/**************单链表排序***********/
	bubble_sort(head);
	output_Linklist(head);




	/***************单链表释放内存**********/
	free_Linklist(head);	
	head = NULL;
	return 0;
}

test.c

#include "head.h"

/***************相关操作的函数的定义*****************/



// 打印链表中的所有元素
void output_Linklist(Linklist head)
{
    // 判断链表是否为空
    if (head == NULL) {
        printf("The list is empty.\n");
        return;
    }
	
	//打印 
    Linklist p = head; // 设置当前节点为头节点
    while (p)   // p!=NULL 
	{
        printf("%d ", p->data); // 打印当前节点的数据
        p = p->next;      // 移动到下一个节点
    }
    printf("\n"); // 打印结束后的换行
}

//创建新节点
Linklist create_node()
{
	//创建一个新节点
	Linklist s=(Linklist)malloc(sizeof(struct Node));
	if(s==NULL)
		return NULL;
	//初始化新节点的数据域
	s->data = 0;
	//初始化新节点的指针域
	s->next = NULL;
	return s;
}

//单链表的头插入
Linklist insert_head(datatype element, Linklist head)
{
	Linklist s = create_node();
	s->data = element;
	//判断链表是否为空
	if(head == NULL)
		head = s;
	else
	{
		s->next = head;
		head = s;
	}
	return head;
}

//单链表的头删
Linklist delete_head(Linklist head)
{
	//判断单链表是否为空
	if(head == NULL)
		return NULL;
	//实现单链表的删除
	Linklist del = head;
	head = head->next;
	free(del);
	del = NULL;
	return head;
}

//单链表的尾插
Linklist insert_tail(datatype element, Linklist head)
{
	//创建新节点
	Linklist s = create_node();
	s->data = element;
	//判断链表是否为空
	if(head == NULL)
		head = s;
	else //  链表不为空 (节点数>=1)
	{
		Linklist p = head;
		while(p->next)
			p = p->next;
		p->next = s;
	}
	return head;
}

//单链表的尾删
Linklist delete_tail(Linklist head)
{
	//判断单链表是否为空
	if(head == NULL)
		return NULL;
	else if(head->next == NULL) //判断单链表是否只有一个节点
	{
		free(head);
		head = NULL;
		return NULL;
	}
	else  // 判断单链表是否有多个节点(节点数 >=2)
	{
		Linklist del = head;
		while(del->next->next)
		{
			del = del->next;
		}

		free(del->next);
		del->next = NULL;
	}
	return head;
}

//判断单链表的长度
int get_len(Linklist head)
{
	//判断单链表是否为空
	if(head == NULL)
		return 0;
	int count = 0;
	Linklist p = head; // 设置当前节点为头节点
    while (p)   // p!=NULL 
		{
        	count++;
        	p = p->next;      // 移动到下一个节点
    	}
	return count;
}

//单链表的按位置插入
Linklist insert_pos(Linklist head, int pos, datatype element)
{
	//判断插入的位置是否合法
	if(pos<1 || pos>get_len(head)+1)
		return head;
	//在第一个位置插入(pos=1)
	if(pos == 1)
	{
		head = insert_head(element, head);
		return head;
	}
	//插入的位置大于1(pos>1)
	Linklist p = head;
	for(int i=1; i<pos-1; i++)
	{
		p = p->next;
	}

	//插入新节点
	Linklist s = create_node();
	s->data = element;
	
	//链接指针域
	s->next = p->next;
	p->next = s;
	return head;

}

//单链表的按位置删除
Linklist delete_pos(Linklist head, int pos)
{
	//判断链表是否为空
	if(head == NULL)
		return NULL;
	//判断删除的位置是否合法
	if(pos<1 || pos>get_len(head))
		return head;
	//在第一个位置删除(pos=1)
	if(pos == 1)
	{
		head = delete_head(head);
		return head;
	}
	//删除位置大于1的(pos>1)
	Linklist p = head;
	for(int i=1; i<pos-1; i++)
	{
		p = p->next;
	}
	Linklist del = p->next;
	p->next = p->next->next;
	free(del);
	del->next = NULL;
	return head;
}

//单链表的按位置修改
Linklist change_pos(Linklist head, int pos, datatype element)
{
	//判断单链表是否为空
	if(head == NULL)
		return NULL;
	//判断修改的位置是否合法(pos<0或者pos>get_len(head)
	if(pos<0 || pos>get_len(head))
		return head;
/*	//如果要修改的是第一个节点
	if(pos == 1)
	{
		head->data = element;
		return head;
	}
*/
	//遍历单链表，找到需要修改的节点
	Linklist p = head;
	for(int i=1; i<pos; i++)
	{
		p = p->next;
	}
	p->data = element;
	return head;
}

//单链表的按位置查找
Linklist find_pos(Linklist head, int pos)
{
	//判断单链表是否为空
	if(head == NULL)
		return NULL;
	//判断位置是否合法
	if(pos<0 || pos>get_len(head))
		return NULL;
	//遍历单链表，找到需要查找的节点
	Linklist p = head;
	for(int i = 1; i<pos; i++)
		p = p->next;
	return p;

}

//单链表的按元素查找
int find_element(Linklist head, datatype element)
{
	//判断单链表是否为空
	if(head == NULL)
		return FALSE;

	//按元素查找节点，并返回在该链表中的第几个位置
	Linklist p = head;
	int pos = 1; // 记录当前位置，起始位置为1
	while(p)
	{
		if(p->data == element)
		{
			return pos;
		}
		p = p->next;
		pos++;
	}

	return FALSE;
}

//单链表的按元素删除
Linklist delete_element(Linklist head, datatype element)
{
	//判断单链表是否为空
	if(head == NULL)
		return NULL;
	//查找元素在链表中的位置
	int pos = find_element(head, element);

	//如果元素不存在则返回原链表
	if(pos == -1)
	{
		printf("element %d not found in the Linklist\n", element);
		return head;
	}

	//元素存在则返回删除后的结果
	head = delete_pos(head, pos);
	return head;
}

//单链表的按元素修改
Linklist change_element(Linklist head, datatype element ,datatype x)
{
	//判断单链表是否为空
	if(head == NULL)
		return NULL;
	//查找需要修改的元素所在的位置
	int pos = find_element(head, element);
	if(pos == -1)
	{
		printf("element %d not found in the Linklist\n", element);
		return head;
	}

	//调用按位置修改元素的函数
	head = change_pos(head, pos, x);
	return head;
}

//单链表的逆置
Linklist reserve_linklist(Linklist head)
{
	//判断单链表是否为空
	if(head == NULL)
		return NULL;
	//逆置
	Linklist p = head->next;
	head->next = NULL;

	while(p)
	{
		Linklist t = p;
		p = p->next;
		t->next = head;
		head = t;
	}

	return head;
}

//单链表查找倒数第n个节点
Linklist backwards_pos(Linklist head, int n)
{
	//判断单链表是否为空或者n<0
	if(head == NULL || n<0)
		return NULL;

	//创建2个指针
	Linklist p = head;
	Linklist q = head;

	//将指针p移动n步
	for(int i = 0; i<n; i++)
	{
		if(p == NULL)
			return NULL;
		p = p->next;
	}

	//将指针p和q一起向前移动，直到指针p到链表末尾
	while(p)
	{
		p = p->next;
		q = q->next;
	}

	return q;
}

//单链表的排序
void bubble_sort(Linklist head)
{
	//判断单链表是否为空或者只有一个节点
	if(head == NULL || head->next == NULL)
		return ; 

	//冒泡排序
	Linklist i, j;
	int t;
	for(i=head; i!=NULL; i=i->next)
	{
		for(j=i->next; j!=NULL; j=j->next)
		{
			if(i->data > j->data)
			{
				t = i->data;
				i->data = j->data;
				j->data = t;
			}
		}
	}
}



//释放内存
void free_Linklist(Linklist head)
{
	//判断单链表是否为空
	if(head == NULL)
		return ;
	//先调用尾删函数删除链表中的所有元素
	while(head)
	{
		head = delete_tail(head);
	}

	free(head);
}