递归实现链表数据互换，纯不会，明天再说
1、链表实现以下功能
链表，创建链表，申请节点，判空，头插，遍历输出，通过位置查找节点，任意位置插入，头删，任意位置删除，安置查找返回位置，按位置进行修改，按值进行修改，翻转链表，释放链表，链表的排序，反转链表（递归实现）
cs
//link_list.h
#ifndef LINK_LIST_H
#define LINK_LIST_H
#include <myhead.h>
typedef int datatype;
typedef struct Node
{
union
{
int len;
datatype data;
};
struct Node *next;
}Node,*NodePtr;
//创建链表
NodePtr list_create();
//申请结点封装数据的函数
NodePtr apply_node(datatype e);
//链表判空
int list_empty(NodePtr L);
//头插
int list_insert_head(NodePtr L,datatype e);
//链表遍历函数
int list_show(NodePtr L);
//通过位置查找结点
NodePtr list_search_pos(NodePtr L,int pos);
//任意位置插入
int list_insert_pos(NodePtr L,int pos,datatype e);
//链表头删
int list_delete_head(NodePtr L);
//链表任意位置删除
int list_delete_pos(NodePtr L,int pos);
//链表按值查找返回位置
int list_search_retval(NodePtr L,datatype e);
//链表按位置进行修改
int list_updata_pos(NodePtr L,int pos,datatype e);
//按值进行修改
int list_updata_data(NodePtr L,datatype old_e,datatype new_e);
//将链表进行翻转
int list_reserve(NodePtr L);
//释放链表
void list_destroy(NodePtr L);
//链表的排序
int list_sort(NodePtr L);
//链表的翻转（递归函数实现）
NodePtr list_reserve1(NodePtr L);
#endif
cs
//link_list.c
#include "link_list.h"
//创建链表
NodePtr list_create()
{
NodePtr L = (NodePtr)malloc(sizeof(Node));
if(NULL == L)
{
printf("链表创建失败\n");
return NULL;
}
L->len = 0;
L->next = NULL;
printf("链表创建成功\n");
return L;
}
//申请结点封装数据的函数
NodePtr apply_node(datatype e)
{
NodePtr p = (NodePtr)malloc(sizeof(Node));
if(NULL == p)
{
printf("创建结点失败\n");
return NULL;
}
p->data = e;
p->next = NULL;
return p;
}
//链表判空
int list_empty(NodePtr L)
{
return L->next == NULL;
}
//头插
int list_insert_head(NodePtr L,datatype e)
{
if(NULL == L)
{
printf("头插失败\n");
}
NodePtr p = apply_node(e);
p->next = L->next;
L->next = p;
L->len++;
printf("头插成功\n");
return 0;
}
//链表遍历函数
int list_show(NodePtr L)
{
if(NULL == L || list_empty(L))
{
printf("遍历失败\n");
return -1;
}
printf("链表中的元素是:");
NodePtr q = L->next;
while(q)
{
printf("%d->",q->data);
q = q->next;
}
printf("NULL\n");
}
//通过位置查找结点
NodePtr list_search_pos(NodePtr L,int pos)
{
if(NULL == L || list_empty(L) || pos < 0 || pos > L->len)
{
printf("查找失败\n");
return NULL;
}
NodePtr q = L;
for(int i = 0;i < pos;i++)
{
q = q->next;
}
return q;
}
//任意位置插入
int list_insert_pos(NodePtr L,int pos,datatype e)
{
if(NULL == L || pos < 1 || pos > L->len+1)
{
printf("插入失败\n");
return -1;
}
NodePtr p = apply_node(e);
if(p == NULL)
{
return -1;
}
NodePtr q = list_search_pos(L,pos-1);
p->next = q->next;
q->next = p;
L->len++;
printf("插入成功\n");
return 0;
}
//链表头删
int list_delete_head(NodePtr L)
{
if(NULL == L || list_empty(L))
{
printf("头删失败\n");
return -1;
}
NodePtr q = L->next;
L->next = q->next;
free(q);
q = NULL;
L->len--;
return 0;
}
//链表任意位置删除
int list_delete_pos(NodePtr L,int pos)
{
if(NULL == L || list_empty(L) || pos < 1 || pos > L->len)
{
printf("删除失败\n");
return -1;
}
NodePtr q = list_search_pos(L,pos-1);
NodePtr p = q->next;
q->next = p->next;
free(p);
p = NULL;
L->len--;
printf("成功删除第%d个元素\n",pos);
return 0;
}
//链表按值查找返回位置
int list_search_retval(NodePtr L,datatype e)
{
if(NULL == L || list_empty(L))
{
printf("查找失败\n");
return -1;
}
NodePtr q = L->next;
for(int i = 1;i <= L->len;i++)
{
if(q->data == e)
{
return i;
}
q = q->next;
}
printf("没有找到该元素\n");
return -1;
}
//链表按位置进行修改
int list_updata_pos(NodePtr L,int pos,datatype e)
{
if(NULL == L || list_empty(L) || pos < 1 || pos > L->len)
{
printf("修改失败\n");
return -1;
}
NodePtr q = list_search_pos(L,pos);
q->data = e;
printf("按位置修改成功\n");
return 0;
}
//按值进行修改
int list_updata_data(NodePtr L,datatype old_e,datatype new_e)
{
if(NULL == L || list_empty(L))
{
printf("修改失败\n");
return -1;
}
NodePtr q = L->next;
while(q)
{
if(q->data == old_e)
{
q->data = new_e;
return 0;
}
q = q->next;
}
printf("没有该元素\n");
return -1;
}
//将链表进行翻转
int list_reserve(NodePtr L)
{
if(NULL == L || list_empty(L) || L->len == 1)
{
printf("翻转失败\n");
return 0;
}
NodePtr H = L->next;
L->next = NULL;
while(H)
{
NodePtr q = H;
H = H->next;
q->next = L->next;
L->next = q;
}
printf("翻转成功\n");
return 0;
}
//释放链表
void list_destroy(NodePtr L)
{
if(NULL == L)
{
return ;
}
while(!list_empty(L))
{
list_delete_head(L);
}
free(L);
L = NULL;
printf("释放链表成功\n");
}
//链表的排序
int list_sort(NodePtr L)
{
if(NULL == L || list_empty(L) || L->len ==1)
{
printf("排序失败\n");
return -1;
}
for (int i = 1; i < L->len; i++)
{
NodePtr p = L->next;
for (int j = 0; j < L->len - i; j++) {
if (p->data > p->next->data)
{
int temp = p->data;
p->data = p->next->data;
p->next->data = temp;
}
p = p->next;
}
}
printf("排序成功\n");
return 0;
}
//链表的翻转（递归函数实现）
NodePtr list_reserve1(NodePtr L)
{
if(NULL == L || L->len == 1)
{
printf("翻转失败\n");
return L;
}
NodePtr q = list_reserve1(L->next);
L->next->next = L;
L->next = NULL;
return q;
}
cs
//main.c
#include "link_list.h"
int main(int argc, const char *argv[])
{
NodePtr L = list_create();
int retem = list_empty(L);
list_insert_head(L,520);
list_insert_head(L,1314);
list_insert_head(L,123);
list_insert_head(L,456);
list_insert_head(L,789);
list_show(L);
list_insert_pos(L,2,200);
list_show(L);
list_delete_head(L);
list_show(L);
list_delete_pos(L,3);
list_show(L);
int retval = list_search_retval(L,200);
if(retval != -1)
{
printf("该元素在第%d个位置\n",retval);
}
retval = list_search_retval(L,232);
list_updata_pos(L,3,520);
list_show(L);
list_updata_data(L,456,997);
list_show(L);
list_reserve(L);
list_show(L);
list_sort(L);
list_show(L);
NodePtr retPtr = list_reserve1(L);
list_show(retPtr);
list_destroy(L);
L = NULL;
list_show(L);
return 0;
}输出结果如下：
