华清远见第三课程作业day5

头文件

#ifndef _LIAN_H_ 
#define _LIAN_H_ 
 
typedef char datatype;    //类型重命名 
 
//定义节点类型
typedef struct Node 
{ 
union 
 { 
		datatype data;      //数据域 
		int len;             //头结点数据域 
 }; 
 
struct Node *next;      //指针域 
}Node, *LinkListPtr; 
 
//创建链表
LinkListPtr list_create(); 
 
//判空操作
int list_empty(LinkListPtr L); 
 
//申请结点封装数据函数
LinkListPtr node_buy(datatype e); 
 
//头插
int list_insert_head(LinkListPtr L, datatype e); 
 
//遍历
void list_show(LinkListPtr L); 
 
//按位置查找返回节点
LinkListPtr list_search_pos(LinkListPtr L, int pos); 
 
//尾插
int list_insert_tail(LinkListPtr L, datatype e); 
 
//任意位置插入
int list_insert_post(LinkListPtr L, int pos, datatype e); 
 
//头删
int list_delete_head(LinkListPtr L); 
 
//尾删
int list_delete_tail(LinkListPtr L); 
 
//任意位置删除
int list_delete_pos(LinkListPtr L, int pos); 
 
 
//按值查找返回节点位置
int list_search_value(LinkListPtr L, datatype e); 
 
//按位置进行修改
int list_update_pos(LinkListPtr L,int pos,datatype e); 
//按值进行修改
int list_update_value(LinkListPtr L,datatype value,datatype e);
//链表排序
int list_sort(LinkListPtr L,int flag);
//递归实现链表反转
LinkListPtr list_reverse_self(LinkListPtr L);
//链表的反转
void list_reverse(LinkListPtr L); 
 
//返回链表长度
int list_length(LinkListPtr L); 
 
//链表的销毁
void list_free(LinkListPtr L); 
 
 
#endif 

 源文件

#include"lian.h" 
#include 
#include 
 
//创建链表
LinkListPtr list_create() 
{ 
//在堆区申请一个头结点类型 
	LinkListPtr L = (LinkListPtr)malloc(sizeof(Node)); 
if(NULL == L) 
{ 
		printf("创建失败\n"); 
		return NULL; 
} 
 
//创建成功，对节点进行初始化 
	L->len = 0;       //初始链表长度为0 
	L->next = NULL;     //链表上没有任何结点 
 
printf("创建成功\n"); 
return L; 
} 
 
//判空操作
int list_empty(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL == L) 
{ 
		printf("所给链表不合法\n"); 
		return -1; 
} 
 
//判断指针域的内容 
return L->next == NULL && L->len==0; 
} 
 
 
//申请结点封装数据函数
LinkListPtr node_buy(datatype e) 
{ 
//在堆区申请结点 
	LinkListPtr p = (LinkListPtr)malloc(sizeof(Node)); 
if(NULL == p) 
{ 
		printf("结点申请失败\n"); 
		return NULL; 
} 
 
//结点申请成功，将数据封装进去 
	p->data = e; 
	p->next = NULL; 
 
return p; 
} 
 
//头插
int list_insert_head(LinkListPtr L, datatype e) 
{ 
//判断逻辑 
if(NULL == L) 
{ 
		printf("所给链表不合法\n"); 
		return 0; 
} 
 
//调用申请结点封装数据 
	LinkListPtr p = node_buy(e); 
if(NULL==p) 
{ 
		return 0; 
} 
 
//结点已经准备好，头插逻辑 
	p->next = L->next; 
	L->next = p; 
 
//表的变化 
	L->len++; 
 
printf("插入成功\n"); 
return 1; 
} 
 
 
//遍历
void list_show(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L)) 
{ 
		printf("遍历失败\n"); 
		return ; 
} 
 
//遍历逻辑 
printf("当前链表元素分别是："); 
//1、定义遍历指针从第一个结点开始 
	LinkListPtr q = L->next; 
while(q != NULL)     //2、只要当前结点存在 
{ 
		//3、输出数据域 
		printf("%c\t", q->data); 
 
		q = q->next;        //4、指针后移 
} 
printf("\n"); 
} 
 
 
//按位置查找返回节点
LinkListPtr list_search_pos(LinkListPtr L, int pos) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L) || pos<0 || pos>L->len) 
{ 
		printf("查找失败\n"); 
		return NULL; 
} 
 
//说明可以进行查找 
//定义遍历指针从头结点开始 
	LinkListPtr q = L; 
for(int i=0; inext; 
} 
 
//将找到的结点返回 
return q; 
} 
 
 
//任意位置插入
int list_insert_post(LinkListPtr L, int pos, datatype e) 
{ 
//判断逻辑 
if(NULL==L || pos<1 || pos>L->len+1) 
{ 
		printf("插入失败\n"); 
		return 0; 
} 
 
//申请结点封装数据函数 
	LinkListPtr p = node_buy(e); 
if(NULL==p) 
{ 
		return 0; 
} 
 
//找到要插入位置的前一个结点 
	LinkListPtr q = list_search_pos(L, pos-1); 
	
//执行插入逻辑 
	p->next = q->next; 
	q->next = p; 
 
//表长变化 
	L->len++; 
 
printf("插入成功\n"); 
return 1; 
} 
 
//尾插
int list_insert_tail(LinkListPtr L, datatype e) 
{ 
//判断逻辑 
if(NULL==L) 
{ 
		printf("所给链表不合法\n"); 
		return 0; 
} 
 
//找到最后一个结点 
//LinkListPtr q = list_search_pos(L, L->len); 
	
//1、定义遍历指针从头结点出发 
	LinkListPtr q = L; 
//2、遍历找到最后一个结点 
while(q->next != NULL) 
{ 
		q = q->next; 
} 
 
//申请结点封装要插入的数据 
	LinkListPtr p =node_buy(e); 
if(NULL==p) 
{ 
		return 0; 
} 
 
//尾插 
//p->next = q->next; 
	q->next = p; 
 
//表长变化 
	L->len++; 
printf("尾插成功\n"); 
return 1; 
} 
 
 
//头删
int list_delete_head(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L)) 
{ 
		printf("删除失败\n"); 
		return 0; 
} 
 
//删除逻辑 
//1、标记要删除的结点 
	LinkListPtr p = L->next; 
//2、孤立要删除的结点 
	L->next = p->next;  //L->next = L->next->next; 
//释放要删除的结点 
free(p); 
	p = NULL; 
 
//表长变化 
	L->len--; 
printf("删除成功\n"); 
return 1; 
} 
 
 
//任意位置删除
int list_delete_pos(LinkListPtr L, int pos) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L) || pos<1 || pos>L->len) 
{ 
		printf("删除失败\n"); 
		return 0; 
} 
 
//找到要删除结点的前驱结点 
	LinkListPtr q = list_search_pos(L, pos-1); 
 
//删除逻辑 
//1、标记要删除的结点 
	LinkListPtr p = q->next; 
//2、孤立要删除的结点 
	q->next = p->next; 
//3、释放要删除的结点 
free(p); 
	p = NULL; 
	q = NULL; 
 
//表长变化 
	L->len--; 
printf("删除成功\n"); 
} 
 
//尾删
int list_delete_tail(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L)) 
{ 
		printf("删除失败\n"); 
		return 0; 
} 
 
//找到倒数第二个结点 
//LinkListPtr q = list_search_pos(L, L->len-1); 
	
	LinkListPtr q = L;     //从头结点出发 
while(q->next->next != NULL) 
{ 
		q = q->next; 
} 
 
//删除逻辑 
free(q->next);        //释放最后一个结点 
	q->next = NULL;     //将新的最后一个结点指针域置空 
 
//表长变化 
	L->len--; 
 
printf("删除成功\n"); 
return 1; 
} 
 
 
//按值查找返回节点位置
int list_search_value(LinkListPtr L, datatype e) 
{ 
//判断逻辑 
if(NULL==L || list_empty(L)) 
{ 
		printf("查找失败\n"); 
		return 0; 
} 
 
//将所有结点进行遍历 
/*
	for(int i=1; i<=L->len; i++)
	{
		//判断第i个结点的数据域是否跟要查找的数据相等
		if( list_search_pos(L,i)->data == e)
		{
			return i;
		}
	}*/
//定义遍历指针从第一个结点开始 
	LinkListPtr q = L; 
int index = 0; 
while((q=q->next) != NULL) 
{ 
		index ++;      //后移一个结点 
		if(q->data == e) 
		{ 
			return index; 
		} 
} 
 
return 0; 
 
 
} 
 
 
 
//链表的反转
void list_reverse(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L || L->len<=1) 
{ 
		printf("反转失败\n"); 
		return ; 
} 
 
//开始反转 
	LinkListPtr H = L->next;    //将链表托管 
	L->next = NULL;             //头结点指针域置空 
 
	LinkListPtr p;         //结点的搬运工 
while(H != NULL) 
{ 
		//标记要搬运的结点 
		p = H; 
		H = H->next;       //指向下一个结点 
 
		//以头插的形式放入到L链表上 
		p->next = L->next; 
		L->next = p; 
} 
 
printf("反转成功\n"); 
} 
 
 
//返回链表长度
int list_length(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L) 
{ 
		printf("所给链表不合法\n"); 
		return -1; 
} 
 
//返回链表的长度 
return L->len; 
} 
 
 
 
//链表的销毁
void list_free(LinkListPtr L) 
{ 
//判断逻辑 
if(NULL==L) 
{ 
		printf("释放失败\n"); 
		return ; 
} 
 
//将所有结点全部释放 
while(!list_empty(L)) 
{ 
		list_delete_head(L); 
} 
 
//将头结点释放 
free(L); 
	L = NULL; 
 
printf("释放成功\n"); 
 
} 
//按位置进行修改
int list_update_pos(LinkListPtr L,int pos,datatype e){
	if(NULL==L || list_empty(L) || pos<0 ||pos>L->len){
		printf("链表或者位置不合法\n");
		return -1;
	}
	LinkListPtr p =list_search_pos(L,pos);
	p->data=e;
	printf("修改成功\n");
	return 1;
}

//按值进行修改
int list_update_value(LinkListPtr L,datatype value,datatype e){
	if(NULL==L || list_empty(L)){
		printf("链表不合法\n");
		return -1;
	}
	LinkListPtr p=list_search_pos(L,list_search_value(L,value));
	p->data=e;
	printf("修改成功\n");
	return 1;
}
//排序
int list_sort(LinkListPtr L,int flag){
	if(NULL==L || list_empty(L))
	 {
		printf("空表无法排序\n");
		return -1;
	 }
	LinkListPtr p,q,t;
	p=L;
	datatype temp;
	int a=L->len;
	for(int i=0;ilen-1;i++){
		a=L->len-i-1;
		q=L->next;
		p=q->next;
		t=L;
		while(a--){
			if(q->data>p->data&&flag==0){
				q->next=p->next;
				p->next=q;
				t->next=p;
			}
			else if(q->datadata&&flag==1){
				q->next=p->next;
				p->next=q;
				t->next=p;
			}
			t=t->next;
			q=t->next;
			p=q->next;
		}
	}
	return 1;
}
//递归反转
LinkListPtr list_reverse_self(LinkListPtr L){
	if(NULL==L || list_empty(L)){
		printf("链表不合法");
		return NULL;
	}
	if(L->next==NULL){
		return L;
	}
	else{
		list_reverse_self(L->next);
		L->next=NULL;
	}
	return L;
}
	
	

测试文件

#include"lian.h" 
 
int main(int argc, const char *argv[]) 
{ 
//调用创建函数创建一个链表 
	LinkListPtr L = list_create(); 
 
//调用头插函数 
list_insert_head(L, 'Q'); 
list_insert_head(L, 'W'); 
list_insert_head(L, 'E'); 
list_insert_head(L, 'R'); 
 
//调用遍历函数 
list_show(L); 
 
//调用任意位置插入函数 
list_insert_post(L, 3,'D'); 
list_show(L); 
 
//调用尾插函数 
list_insert_tail(L, 'F'); 
list_insert_tail(L, 'G'); 
list_show(L); 
 
//调用头删函数 
list_delete_head(L); 
list_delete_head(L); 
list_show(L); 
 
//调用尾删函数 
list_delete_tail(L); 
list_show(L); 
 
//调用反转函数 
list_reverse(L); 
list_show(L); 
//按位置修改
list_update_pos(L,2,48);
list_show(L);
//按值进行修改
list_update_value(L,48,49);
list_show(L);
//链表排序
list_sort(L,0);
list_show(L);
//反转
list_reverse_self(L);
list_show(L);
//销毁链表 
list_free(L); 
 
return 0; 
}