12.27 22111作业

作业：

1> 完成单向链表按值进行修改函数：int list_update_value(LinkList L, datatype old_e, datatype new_e);

2> 完成单向链表排序（简单选择排序）：void list_sort(LinkList L);

#include"linklist.h"
#include<stdio.h>
#include<stdlib.h>


//创建链表
LinkList list_create()
{
	//在堆区申请一个头结点
	LinkList L = (LinkList)malloc(sizeof(Node));
	if(NULL==L)
	{
		printf("创建失败\n");
		return NULL;
	}

	//初始化
	L->len = 0;
	L->next = NULL;      //给指针域初始化

	printf("创建成功\n");
	return L;
}

//申请结点封装数据函数
LinkList apply_node(datatype e)
{
	//申请结点空间
	LinkList p = (LinkList)malloc(sizeof(Node));
	if(NULL==p)
	{
		printf("结点申请失败\n");
		return NULL;
	}

	//将数据封装到结点中
	p->data = e;
	p->next = NULL;

	return p;
}

//判空
int list_empty(LinkList L)
{
	return L->next == NULL;    //1表示空，0表示非空
}


//头插
int list_insert_head(LinkList L, datatype e)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("所给链表不合法\n");
		return -1;
	}

	//申请结点封装数据
	LinkList p = apply_node(e);
	if(NULL == p)
	{
		return -1;
	}

	//头插逻辑
	p->next = L->next;   //新结点指针域指向第一个结点
	L->next = p;         //头结点指针域指向新节点

	//表长变化
	L->len++;
	printf("头插成功\n");
	return 0;
}


//遍历
void list_show(LinkList L)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("遍历失败\n");
		return ;
	}

	//定义遍历指针从第一个结点出发
	LinkList q = L->next;
	while(q != NULL)
	{
		printf("%c\t", q->data);
		q = q->next;
	}
	printf("\n");
}

//按位置进行查找函数，返回找到的结点
LinkList find_node(LinkList L, int pos)
{
	//判断逻辑
	if(NULL==L || list_empty(L) || pos<0 || pos>L->len)
	{
		printf("查找失败\n");
		return NULL;
	}

	//查找逻辑
	LinkList q = L;     //定义遍历指针从头结点开始
	for(int i=1; i<=pos; i++)
	{
		q = q->next;
	}

	return q;       //将找到的结点返回
}

//尾插
int list_insert_tail(LinkList L, datatype e)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("所给链表不合法\n");
		return -1;
	}

	//申请结点封装数据
	LinkList p = apply_node(e);

	//找到最后一个结点
	LinkList q = find_node(L, L->len);

	//将q当做头结点进行头插
	p->next = q->next;
	q->next = p;

	//表长变化
	L->len++;

	printf("尾插成功\n");
	return 0;
}

//任意位置插入
int list_inset_pos(LinkList L, int pos, datatype e)
{
	//判断逻辑
	if(NULL==L || pos<1 || pos>L->len+1)
	{
		printf("插入失败\n");
		return -1;
	}
	
	//申请结点封装数据
	LinkList p = apply_node(e);

	//找到要插入结点的前驱结点
	LinkList q = find_node(L, pos-1);

	//插入逻辑
	p->next = q->next;
	q->next = p;

	//表长变化
	L->len++;
	printf("插入成功\n");
	return 0;
}


//头删
int list_delete_head(LinkList L)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("删除失败\n");
		return -1;
	}

	//删除逻辑
	LinkList p = L->next;      //标记要删除的结点
	L->next = p->next;  //L->next = L->next->next; 孤立要删除的结点
	free(p);      //释放要删除的结点
	p = NULL;

	//表长变化
	L->len--;
	printf("删除成功\n");
	return 0;
}

//任意删
int list_delete_pos(LinkList L, int pos)
{
	//判断逻辑
	if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
	{
		printf("删除失败\n");
		return -1;
	}

	//找到要删除结点的前驱结点
	LinkList q = find_node(L, pos-1);

	//删除逻辑
	LinkList p = q->next;     //标记要删除的结点
	q->next = p->next;      //q->next = q->next->next  孤立要删除的结点
	free(p);               //释放要删除的结点
	p = NULL;

	//表长变化
	L->len--;
	printf("删除成功\n");
	return 0;
}


//尾删
int list_delete_tail(LinkList L)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("删除失败\n");
		return -1;
	}

	//找到要删除结点的前驱结点
	LinkList q = find_node(L, L->len-1);

	//删除逻辑
	/*
	LinkList p = q->next;     //标记要删除的结点
	q->next = p->next;      //q->next = q->next->next  孤立要删除的结点
	free(p);               //释放要删除的结点
	p = NULL;*/

	free(q->next);     //释放最后一个结点
	q->next = NULL;    //将新的最后一个结点指针域置空


	//表长变化
	L->len--;
	printf("删除成功\n");
	return 0;
}

//任意位置修改函数
int list_update_pos(LinkList L, int pos, datatype e)
{
	//判断逻辑
	if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
	{
		printf("修改失败\n");
		return -1;
	}

	//找到要删除的结点
	LinkList p = find_node(L, pos);

	//修改逻辑
	p->data = e;

	printf("修改成功\n");
	return 0;
}

//按值查找返回对应的位置
int list_search_value(LinkList L, datatype e)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("查找失败\n");
		return -1;
	}

	//定义遍历指针从第一个结点出发
	LinkList q = L->next;
	int index = 1;
	while(q!=NULL && q->data!=e)
	{
		q = q->next;
		index++;
	}

	if(index > L->len)
	{
		return -1;
	}
	
	return index;  //将找到的结点位置返回
}


//按值进行修改函数
int list_update_value(LinkList L,datatype old_e,datatype new_e)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("修改失败\n");
		return -1;
	}
	int p=list_search_value(L,old_e);

	list_update_pos(L,p,new_e);

	printf("修改成功\n");
	return 0;

}
//使用选择排序排序链表
void list_sort(LinkList L)
{
	int num=0;
	int min=0;
	int arr[num];
	LinkList q=L->next;
	while(q!=NULL)
	{
		arr[num]=q->data;
		q=q->next;
		num++;
	}
	//判断条件
	if(NULL==L||list_empty(L))
	{
		printf("链表排序失败\n");
		return ;
	}
	for(int i=0;i<L->len;i++)
	{
		min=i;
		for(int j=i;j<L->len;j++)
		{
			if(arr[min]>arr[L,j])
			{
				min=j;
			}
		}
		int temp=arr[min];
		arr[min]=arr[i];
		arr[i]=temp;
	}
	for(int i=0;i<L->len;i++)
	{
		printf("%c\t",arr[i]);
	}
	printf("排序完成\n");
}

//链表翻转
void list_reverse(LinkList L)
{
	//判断逻辑
	if(NULL==L || L->len<1)
	{
		printf("翻转失败\n");
		return ;
	}

	//翻转逻辑
	LinkList H = L->next;   //托管链表

	L->next = NULL;       //白手起家

	while( H != NULL )   //旧链表不空
	{
		//定义搬运结点
		LinkList p = H;     //标记要跳槽的结点
		H = H->next;

		//以头插形式插入到新链表中
		p->next = L->next;
		L->next = p;
	}

	printf("翻转成功\n");
	
}

//链表释放
void list_free(LinkList L)
{
	//判断逻辑
	if(NULL==L)
	{
		printf("释放失败\n");
		return;
	}

	//1、将所有结点进行释放
	while(L->next != NULL)
	{
		list_delete_head(L);
	}

	//2、将头结点释放
	free(L);
	L = NULL;

	printf("释放成功\n");
}

结果：