一、头文件linklist.h
//带头节点的链表的基本操作
#ifndef _LINKLIST_H
#define _LINKLIST_H
#define TRUE 1
#define FALSE 0
typedef int ElemType;
/*
*定义单向链表节点数据结构
*此处要修改
*/
typedef struct node
{
ElemType data;
struct node *next;
}linknode, *linklist;
/*对链表操作的接口*/
/*****************单向带头节点的链表操作API********************/
/*创建链表头,返回一个链表指针*/
linklist create_linklist_head(void);
/*清除链表所以数据,并释放内存,传参:链表头*/
void clear_linklist(linklist head);
/*计算返回链表的节点数,传参:链表头,不计算链表头*/
int length_linklist(linklist head);
/*判断链表是否为空链表,传参:链表头,返回TRUE为空*/
int is_empty(linklist head);
/*返回这条数据在链表中节点的位置*/
int locate_linklist(linklist head, ElemType xdata);
/*获取第i个节点的数据,到*ret中*/
int get_linklist(linklist head, int i, ElemType *ret);
/*向链表中的i个节点后面插入linknode结构体的一条数据*/
int insert_linklist(linklist head, ElemType xdata, int i);
/*头插法使链表倒置*/
void reverse_linklist(linklist head);
/*带入两个链表头,合并为一个链表,头1为新链表头,释放头2,flag = 0 遇到相同元素,插入一个即可*/
int merge_linklist(linklist head1,linklist head2,int flag);
/*按照元素大小进行排序,head1为排序后的链表头,head2为要排序的链表头*/
int sort_linklist(linklist head1,linklist head2 );
/*合并两个有序链表组成一个新的有序链表(从小到大),头1为新链表头,释放头2,flag = 0 遇到相同元素,插入一个即可*/
/*head1为排序后的链表头,head2为要排序的链表头1,head2为要排序的链表头1*/
int sort_merge_linklist(linklist head1,linklist head2,linklist head3,int flag);
/*删除第i个节点的数据,传参 :链表头,节点i,返回true成功删除*/
int delete_linklist(linklist head, int i);
/*在链表中查找数据为xdata的结构体,并删除,返回删除的节点最后位置,*i中保存删除的条数*/
int delete_linklist_value(linklist head, ElemType xdata , int *i);
/*显示整条链表的数据,传参:链表头*/
void display_linklist(linklist head);
/*显示第i个节点的数据*/
int display_onelinklist(linklist head , int i);
/*显示第i个节点到第j个节点的数据*/
int display_betweenlinklist(linklist head , int i , int j);
/*******判断是否为循环链表及单链表转换成循环链表******************/
/*判断是否为循环链表,返回true是*/
int is_cyclelinklist(linklist head);
/*将单向链表转换成循环链表*/
int switch_is_cyclelinklist(linklist head);
/******单向循环链表操作******************************************/
/*调用上面switch_is_cyclelist()函数可将单向链表转化为单向循环链表*/
linklist create_cyclelinklist_head(void);
/*清除循环链表所有数据,并释放内存,传参:链表头指针*/
void clear_cyclelinklist(linklist head);
/*计算返回循环链表的节点数,传参:链表头*/
int length_cyclelinklist(linklist head);
/*判断循环链表是否为空链表,传参:链表头,返回TRUE为空*/
int cyclelinklistempty(linklist head);
/*返回这条数据在循环链表中节点的位置*/
int locate_cyclelinklist(linklist head, ElemType xdata);
/*获取第i个节点的数据,到*ret中*/
int get_cyclelinklist(linklist head, int i, ElemType *ret);
/*向链表中的i个节点后面插入linknode结构体的一条数据*/
int insert_cyclelinklist(linklist head, ElemType xdata, int i); //插在第i个节点后面
/*删除第i个节点的数据,传参 :链表头,节点i,返回true成功删除*/
int delete_cyclelinklist(linklist head, int i);
/*头插法使链表倒置*/
void reverse_cyclelinklist(linklist head); //头插法使循环链表倒置
/*显示整条链表的数据,传参:链表头*/
void display_cyclelinklist(linklist head);
/*将循环链表转换成单向链表*/
int switch_is_linklist(linklist head);
#endif
/* _LINKLIST_H */
二、函数实现C文件linklist.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include "linklist.h"
/*创建链表头,返回一个链表指针*/
linklist create_linklist_head(void)
{
linklist head = (linklist)malloc(sizeof(linknode));
if (head == NULL)
{
return NULL;
}
/*根据数据结构不同,这里需要修改*/
head->data = -1;
head->next = NULL;
return head;
}
/*清除链表所以数据,并释放内存,传参:链表头*/
void clear_linklist(linklist head)
{
linklist q = head->next;
while (q)
{
head->next = q->next;
free(q);
q = head->next;
}
free(head);//释放掉头
head = NULL;
}
/*计算返回链表的节点数,传参:链表头,不计算链表头*/
int length_linklist(linklist head)
{
int count = 0;
linklist p = head->next;
while (p)
{
count++;
p = p->next;
}
return count;
}
/*判断链表是否为空链表,传参:链表头,返回TRUE为空*/
int is_empty(linklist head)
{
return head->next == NULL ? TRUE : FALSE;
}
/*返回这条数据在链表中节点的位置*/
int locate_linklist(linklist head, ElemType xdata)
{
int count = 0;
linklist p = head->next;
while (p)
{
/*根据数据结构不同,这里需要修改*/
if (p->data == xdata)
{
return count+1;
}
p = p->next;
count++;
}
return 0;
}
/*获取第i个节点的数据,到*ret中*/
int get_linklist(linklist head, int i, ElemType *ret)
{
if (i < 0 || i > length_linklist(head))
{
printf("get_linklist failed,node less %d is wrong!\n", i);
return FALSE;
}
linklist p = head;
int j;
for (j = 0; j < i; j++)
{
p = p->next;
}
*ret = p->data;
return TRUE;
}
/*向链表中的i个节点后面插入linknode结构体的一条数据*/
int insert_linklist(linklist head, ElemType xdata, int i) //插在第i个节点后面
{
if (i < 0 || i > length_linklist(head)+1)
{
printf("insert_linklist failed,node under %d \n", i);
return FALSE;
}
linklist q = (linklist)malloc(sizeof(linknode));
q->data = xdata;
q->next = NULL;
int j;
linklist p = head;
for (j = 0; j < i; j++)
{
p = p->next;
}
q->next = p->next;
p->next = q;
return TRUE;
}
/*删除第i个节点的数据,传参 :链表头,节点i,返回true成功删除*/
int delete_linklist(linklist head, int i)
{
if (i < 0 || i > length_linklist(head))
{
printf("delete_linklist failed,node under %d\n", i);
return FALSE;
}
linklist p = head, q = head;
int j;
for (j = 0; j < i-1; j++)
{
p = p->next;
}
q = p->next;
p->next = q->next;
free(q);
q = NULL;
return TRUE;
}
/*在链表中查找数据为xdata的结构体,并删除,返回删除的节点到i中*/
int delete_linklist_value(linklist head, ElemType xdata,int *i)
{
int count = 0;
linklist p = head, q = head;
while (p)
{
/*根据数据结构不同,这里需要修改*/
if (p->data == xdata)
{
int j;
for (j = 0; j < count-1; j++)
{
q = q->next;
}
q->next = p->next;
free(p);
(*i)++;
}
p = p->next;
count++;
}
return count;
}
/*头插法使链表倒置*/
void reverse_linklist(linklist head) //头插法使链表倒置
{
linklist q, p = head->next;
head->next = NULL;
while (p)
{
q = p->next;
p->next = head->next;
head->next = p;
p = q;
}
}
/*带入两个链表头,合并为一个链表,头1为新链表头,释放头2,flag = 0 遇到相同元素,插入一个即可*/
int merge_linklist(linklist head1,linklist head2,int flag)
{
int x = length_linklist(head1);
int y = length_linklist(head2);
if((x<=0) | (y<=0)) return -1;
if(flag == 1){
linklist p = head1->next;
while (p->next)
{
p = p->next;
}
p->next = head2->next;
free(head2);
return 1;
}else{
int i;
ElemType e;
for(i = 1;i <= y ;i++){
get_linklist(head2,i,&e);
if(!locate_linklist(head1,e))
insert_linklist(head1,e,x++);
}
clear_linklist(head2);
return 1;
}
}
/*合并两个有序链表组成一个新的有序链表(从小到大),头1为新链表头,释放头2,flag = 0 遇到相同元素,插入一个即可*/
/*head1为排序后的链表头,head2为要排序的链表头1,head2为要排序的链表头1*/
int sort_merge_linklist(linklist head1,linklist head2,linklist head3,int flag)
{
int x = length_linklist(head2);
int y = length_linklist(head3);
if((x<=0) | (y<=0)) return -1;
int i = 1, j = 1, k = 0;
ElemType e1,e2;
while((i <= x) && (j <= y)){
get_linklist(head2,i,&e1);
get_linklist(head3,j,&e2);
if(e1 <= e2){
if(flag == 1){
insert_linklist(head1,e1,k++);
i++;
}else{
if(e1 == e2){
insert_linklist(head1,e1,k++);
i++;
j++;
}
}
}else{
insert_linklist(head1,e2,k++);
j++;
}
}
while( i<= x){
get_linklist(head2,i++,&e1);
insert_linklist(head1,e1,k++);
}
while( j<= y){
get_linklist(head3,j++,&e1);
insert_linklist(head1,e1,k++);
}
clear_linklist(head2);
clear_linklist(head3);
return 1;
}
/*按照元素大小进行排序,head1为排序后的链表头,head2为要排序的链表头*/
int sort_linklist(linklist head1,linklist head2 )
{
int x;
int i,j,z,dest = 0;
ElemType max,min,e;
while(!is_empty(head2)){
x = length_linklist(head2);
get_linklist(head2,1,&max);
for(i = 2 ; i <= x ; i++){
get_linklist(head2,i,&min);
if(max < min)
{
e = min;
min = max;
max = e;
}
}
insert_linklist(head1,max,dest++);
delete_linklist_value(head2,max,&z);
}
free(head2);
return 1;
}
/*显示整个链表*/
void display_linklist(linklist head)
{
linklist p = head->next;
printf("display_linklist :");
while (p)
{
/*根据数据结构不同,这里需要修改*/
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
/*显示第i个节点的数据*/
int display_onelinklist(linklist head , int i)
{
if (i < 0 || i > length_linklist(head))
{
printf("display_onelinklist failed,node under %d\n", i);
return FALSE;
}
int j;
linklist p = head;
printf("display_onelinklist %d :",i);
for (j = 0; j < i; j++)
{
p = p->next;
}
/*根据数据结构不同,这里需要修改*/
printf(" %d \n", p->data);
return TRUE;
}
/*显示第i个节点到第j个节点的数据*/
int display_betweenlinklist(linklist head , int i , int j)
{
if (i < 0 || i > length_linklist(head))
{
printf("display_betweenlinklist failed,node under %d\n", i);
return FALSE;
}
if (j < 0 || j > length_linklist(head))
{
printf("display_betweenlinklist failed,node under %d\n", j);
return FALSE;
}
int x;
linklist p = head;
printf("display_betweenlinklist %d to %d :",i,j);
for (x = 0; x < i; x++)
{
p = p->next;
}
for(;x <= j ; x++)
{
/*根据数据结构不同,这里需要修改*/
printf("%d ", p->data);
p = p->next;
}
printf("\n");
return TRUE;
}
/****************判断是否为循环链表及单链表转换成循环链表**********/
/*判断是否为循环链表,*/
int is_cyclelinklist(linklist head)
{
linklist p1, p2;
p1 = p2 = head->next;
while(p2)
{
p2 = p2->next;
if(p1 == p2)
{
printf("There is a cyclelinklist!\n");
return TRUE;
}
}
return FALSE;
}
/*将单向链表转换成循环链表*/
int switch_is_cyclelinklist(linklist head)
{
linklist p = head->next;
while (p->next)
{
p = p->next;
}
p->next = head->next ;
return TRUE;
}
/******单向循环链表操作******************************************/
/*调用上面switch_is_cyclelist()函数可将单向链表转化为单向循环链表*/
linklist create_cyclelinklist_head(void)
{
linklist head = (linklist)malloc(sizeof(linknode));
if (head == NULL)
{
return NULL;
}
/*根据数据结构不同,这里需要修改*/
head->data = -1;
head->next = NULL;
return head;
}
/*清除循环链表所有数据,并释放内存,传参:链表头指针*/
void clear_cyclelinklist(linklist head)
{
linklist q = head->next;
linklist p;
if(head->next == NULL){
printf("clear_cyclelinklist fail : cyclelinklist empty\n");
return ;
}
do{
p = q->next;
free(q);
q = p;
}while (q != head->next);
free(head);
}
/*计算返回循环链表的节点数,传参:链表头*/
int length_cyclelinklist(linklist head)
{
int count = 0;
linklist p = head->next;
if(head->next == NULL){
printf("length_cyclelinklist fail : cyclelinklist empty\n");
return -1;
}
do{
p = p->next;
count++;
}while (p != head->next);
return count;
}
/*判断循环链表是否为空链表,传参:链表头,返回TRUE为空*/
int cyclelinklistempty(linklist head)
{
return head->next == NULL ? TRUE : FALSE;
}
/*返回这条数据在循环链表中节点的位置*/
int locate_cyclelinklist(linklist head, ElemType xdata)
{
int count = 1;
linklist p = head->next;
if(head->next == NULL){
printf("locate_cyclelinklist fail : cyclelinklist empty\n");
return -1;
}
do{
if (p->data == xdata)
{
return count;
}
p = p->next;
count++;
}while(p != head->next);
return 0;
}
/*获取第i个节点的数据,到*ret中*/
int get_cyclelinklist(linklist head, int i, ElemType *ret)
{
if (i < 0 || i > length_cyclelinklist(head))
{
printf("i=%d is wrong!\n", i);
return FALSE;
}
linklist p = head->next;
int j;
for (j = 1; j < i; j++)
{
p = p->next;
}
*ret = p->data;
return TRUE;
}
/*向链表中的i个节点后面插入linknode结构体的一条数据*/
int insert_cyclelinklist(linklist head, ElemType xdata, int i) //插在第i个节点后面
{
if (i < 0 || i > length_cyclelinklist(head)+1)
{
printf("i=%d is wrong!\n", i);
return FALSE;
}
linklist q = (linklist)malloc(sizeof(linknode));
q->data = xdata;
q->next = NULL;
if (head->next == NULL)
{
head->next = q;
q->next = q;
}
else
{
if (i == 0)//插在第一个结点前面
{
linklist p = head->next;
while(p->next != head->next)
{
p = p->next;
}
q->next = head->next;
p->next = q;
head->next = q;
}
else
{
int j;
linklist p = head->next;
for (j = 0; j < i; j++)
{
p = p->next;
}
q->next = p->next;
p->next = q;
}
}
return TRUE;
}
/*删除第i个节点的数据,传参 :链表头,节点i,返回true成功删除*/
int delete_cyclelinklist(linklist head, int i)
{
if (i < 0 || i > length_cyclelinklist(head))
{
printf("i=%d is wrong!\n", i);
return FALSE;
}
linklist p = head->next;
linklist q = head->next;//q指向待删除节点,p找位置
if (i == 1)
{
while(p->next != head->next)//指向最后一个节点
{
p = p->next;
}
p->next = q->next;
head->next = q->next;
free(q);
q = NULL;
}
else
{
int j;
for (j = 1; j < i-1; j++)
{
p = p->next;
}
q = p->next;
p->next = q->next;
free(q);
q = NULL;
}
return TRUE;
}
/*头插法使链表倒置*/
void reverse_cyclelinklist(linklist head) //头插法使循环链表倒置
{
linklist q = head->next; //q指向待插入的节点,p遍历
linklist p = head->next;
if(head->next == NULL){
printf("reverse_cyclelinklist fail : cyclelinklist empty\n");
return ;
}
while (q->next != q)
{
q->next = head->next;
head->next = q;
q = p;
p = p->next;
}
p->next = head->next;
}
/*显示整条链表的数据,传参:链表头*/
void display_cyclelinklist(linklist head)
{
linklist p = head->next;
if(head->next == NULL){
printf("display_cyclelinklist fail : cyclelinklist empty\n");
return ;
}
printf("display_cyclelinklist:");
do{
printf("%d ", p->data);
p = p->next;
}while (p != head->next);
printf("\n");
}
/*将循环链表转换成单向链表*/
int switch_is_linklist(linklist head)
{
if(is_cyclelinklist(head))
printf("switch_is_linklist--------------\n");
if(head->next == NULL){
printf("switch_is_linklist fail : cyclelinklist empty\n");
return 0;
}
linklist p = head->next;
while(p->next != head->next)
p = p->next;
p->next = NULL;
return TRUE;
}
int main(int argc, const char *argv[])
{
linklist head = create_linklist_head();
int i;
for (i = 5; i <=10; i++)
{
insert_linklist(head, i, 0);
}
insert_linklist(head, 12, 6);
insert_linklist(head, 13, 7);
printf("lenght:%d\n",length_linklist(head));
display_linklist(head);
linklist w = create_linklist_head();
sort_linklist(w,head);
reverse_linklist(w);
printf("lenght:%d\n",length_linklist(w));
display_linklist(w);
linklist h = create_linklist_head();
for (i = 2; i <=10; i++)
{
insert_linklist(h, i, 0);
}
reverse_linklist(h);
printf("lenght:%d\n",length_linklist(h));
display_linklist(h);
linklist z = create_linklist_head();
sort_merge_linklist(z,w,h,1);
//merge_linklist(w,h,0);
printf("lenght:%d\n",length_linklist(z));
display_linklist(z);
if(!is_cyclelinklist(z))
{
printf(" no cycle\n");
}
display_onelinklist( z , 2);
display_betweenlinklist(z,2,4);
switch_is_cyclelinklist( z);
if(!is_cyclelinklist(z))
{
printf("no cycle\n");
}
else
{
printf("cycle\n");
}
display_cyclelinklist(z);
printf("length:%d\n",length_cyclelinklist(z));
insert_cyclelinklist(z, 1, 0);
insert_cyclelinklist(z, 120, 1);
printf("length:%d\n",length_cyclelinklist(z));
display_cyclelinklist(z);
//reverse_cyclelinklist(z);
delete_cyclelinklist(z,1);
display_cyclelinklist(z);
ElemType a;
get_cyclelinklist(z,1,&a);
printf("a:%d\n",a);
display_cyclelinklist(z);
printf("13 ==%d\n",locate_cyclelinklist(z,13));
switch_is_linklist(z);
display_linklist(z);
/*
printf("return 5 locate %d\n",locate_linklist( head, 5));
ElemType p;
get_linklist(head, 3, &p);
printf("get %d node:%d\n",3,p);
int c;
delete_linklist_value(head, p ,&c);
display_linklist(head);
delete_linklist(head, 2);
display_linklist(head);
reverse_linklist(head);
display_linklist(head);
reverse_linklist(head);
display_linklist(head);
if(!is_cyclelist(head))
{
printf(" no cycle\n");
}
display_onelinklist( head , 2);
display_betweenlinklist(head,2,4);
switch_is_cyclelist( head);
if(!is_cyclelist(head))
{
printf("no cycle\n");
}
else
{
printf("cycle\n");
}
//clear_linklist(head);
printf("clear:");
// display_linklist(head);
return 0;*/
}