2024-8-2数据结构周末练习

a18323785395

已于 2024-08-05 10:31:11 修改

阅读量171

点赞数 3

文章标签：数据结构

于 2024-08-05 02:09:27 首次发布

本文链接：https://blog.csdn.net/a18323785395/article/details/140913724

版权

1.链表

//头文件
#ifndef __FUNC__
#define __FUNC__
typedef int datatype;
typedef struct lklist
{
	union
	{
		int len;
		datatype data;
	}text;
	struct lklist*next;
}Linklist;
Linklist*create_linklist(void);
void insert_linklistbyhead(Linklist*head,datatype num);
void insert_linklistbyTail(Linklist*head,datatype num);
datatype delete_linklistByhead(Linklist*head);
void delete_linklistByTali(Linklist*head);
void insert_linklistByposition(Linklist*headi,datatype num,int n);
void show_linklist(Linklist*head);
void insert_linklistSort(Linklist*head,int num);
void insert_linklistSort2(Linklist*head,int num);
void recycle_linklist(Linklist*head);
datatype millddle_Node_linklist(Linklist*head);
void free_linklist(Linklist**phead);
void delete_linklistByposition(Linklist*head,int n);
#endif

链表.c

//创建一个空的单链表
#include <stdio.h>
#include <stdlib.h>
#include "./01_func.h"
Linklist*create_linklist(void)
{
	Linklist*head=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==head)
	{
		printf("创建空链表失败");
		return NULL;
	}
	head->next=NULL;
	head->text.len=0;
	return head;
}

//头插法－插入数据
void insert_linklistbyhead(Linklist*head,datatype num)
{
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==temp)
	{
		printf("创建节点失败，插入失败");	
	}
	temp->text.data=num;
	temp->next=NULL;
	temp->next=head->next;
	head->next=temp;
	head->text.len++;
	return;
}

//从头部开始删除数据
datatype delete_linklistByhead(Linklist*head)
{
	if(head->next==NULL)
	{
		printf("链表为空，删除失败");
		return (datatype)-1;
	}
	Linklist*temp=head->next;
	head->next=temp->next;
	datatype num=temp->text.data;
	free(temp);
	temp=NULL;
	head->text.len--;
	return num;
}


//从尾部插入数据
void insert_linklistbyTail(Linklist*head,datatype num)
{
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==temp)
	{
		printf("创建节点失败，插入失败");
	}	
	temp->text.data=num;
	temp->next=NULL;
	Linklist*p=head;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	temp->next=p->next;
	p->next=temp;
	head->text.len++;
	return;
}

//从尾部开始删除数据
void delete_linklistByTali(Linklist*head)
{
	if(NULL==head->next)
	{
		printf("链表为空，删除失败");
	}
//找倒数第二个节点
	Linklist*p=head;
	while(p->next->next!=NULL)
	{
		p=p->next;
	}
	free(p->next);
	p->next=NULL;
	head->text.len--;
	return;
}

//按位置插入数据
void insert_linklistByposition(Linklist*head,datatype num,int n)
{
	if(n<1)
	{
		printf("插入位置非法");
		return;
	}
	Linklist*p=head;
	for(int i=0;i<n-1;i++)
	{
		p=p->next;
		if(NULL==p)
		{
			printf("插入位置非法");
			return;
		}
	}
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==temp)
	{
		printf("创建节点失败，插入失败");
		return;
	}
	temp->text.data=num;
	temp->next=NULL;
	temp->next=p->next;
	p->next=temp;
	head->text.len++;
	return;
}

//按位置删除数据
void delete_linklistByposition(Linklist*head,int n)
{
	//判断列表是佛为空
	if(NULL==head->next)
	{
		printf("列表为空，删除失败\n");
		return;
	}
	if(n<1)
	{
		printf("删除位置非法\n");
		return;
	}
	Linklist*p=head;
	for(int i=0;i<n-1;i++)
	{
		p=p->next;
		if(p->next==NULL)
		{
			printf("删除位置非法\n");
			return;
		}
	}
	Linklist*temp=p->next;
	p->next=temp->next;
	free(temp);
	head->text.len--;
	return;
}

//升序插入
void insert_linklistSort(Linklist*head,int num)
{
	Linklist*p=head;
	while(p->next!=NULL)
	{
		if(num<p->next->text.data)
		{
			break;
		}
		p=p->next;
	}
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==temp)
	{
		printf("创建节点失败,插入失败");
	}
	temp->text.data=num;
	temp->next=NULL;
	temp->next=p->next;
	p->next=temp;
	head->text.len++;
	return;
}	

//降序插入
void insert_linklistSort2(Linklist*head,int num)
{
	Linklist*p=head;
	while(p->next!=NULL)
	{
		if(num>p->next->text.data)
		{
			break;
		}
		p=p->next;
	}
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==temp)
	{
		printf("创建节点失败,插入失败");
	}
	temp->text.data=num;
	temp->next=NULL;
	temp->next=p->next;
	p->next=temp;
	head->text.len++;
	return;
}	

//翻转链表(不借助新链表)
void recycle_linklist(Linklist*head)
{
	Linklist*p,*q;
	p=head->next;
	head->next=NULL;
	while(p!=NULL)
	{
		q=p->next;
		p->next=head->next;
		head->next=p;
		p=q;
	}
	return;
}

//遍历一次,找中间节点
datatype millddle_Node_linklist(Linklist*head)
{
	if(head->next==NULL)
	{
		printf("链表为空，没有中间节点");
		return (datatype)-1;
	}
	Linklist*low,*fast;
	fast=low=head->next;
	while(fast!=NULL&&fast->next!=NULL)
	{
		low=low->next;
		fast=fast->next->next;
	}
	return low->text.data;
}


//释放链表
void free_linklist(Linklist**phead)
{
	Linklist*temp=NULL;
	while((*phead)->next!=NULL)
	{
		temp=(*phead)->next;
		(*phead)->next=temp->next;
		free(temp);
		(*phead)->text.len--;
	}
	free(*phead);
	*phead=NULL;
	return;
}

//遍历链表
void show_linklist(Linklist*head)
{
	Linklist*p=head;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%d ",p->text.data);
	}
	putchar(10);
	return;
}


//函数调试 main.c
#include <stdio.h>
#include "./01_func.h"
int main(int argc, const char *argv[])
{
	Linklist*head;
	head=create_linklist();

	insert_linklistSort2(head,60);
	insert_linklistSort2(head,120);
	insert_linklistSort2(head,90);
	insert_linklistSort2(head,30);

	show_linklist(head);
	datatype num;
	num=millddle_Node_linklist(head);
	printf("millddle=%d是链表中间节点\n",num);

	delete_linklistByposition(head,2);
	show_linklist(head);
	return 0;
}

2.单项循环链表

头文件

#ifndef __FUNC__
#define __FUNC__
typedef int datatype;
typedef struct lklist
{
	union
	{
		int len;
		datatype data;
	}text;
	struct lklist*next;
}Linklist;
Linklist*create_looplinklist(void);
void insert_looplinklistbyhead(Linklist*head,datatype num);
void show_looplinklist(Linklist*head);
datatype delete_looplinklistByhead(Linklist*head);
void insert_looplinklistbyTail(Linklist*head,datatype num);
void delete_looplinklistByTali(Linklist*head); 
void insert_looplinklistByposition(Linklist*head,datatype num,int n);
void delete_looplinklistByposition(Linklist*head,int n);
#endif


02_looplinklist.c

//创建一个空的单项循环链表
#include <stdio.h>
#include <stdlib.h>                                    
#include "./01_func.h"
Linklist*create_looplinklist(void)
{
    Linklist*head=(Linklist*)malloc(sizeof(Linklist));
    if(NULL==head)
    {
        printf("创建空链表失败");
        return NULL;
    }
    head->next=head;
    head->text.len=0;
    return head;
}

//头插法－插入数据
void insert_looplinklistbyhead(Linklist*head,datatype num)
{
    //创建新节点
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
    if(NULL==temp)
    {
        printf("创建节点失败，插入失败");                   
    }
    temp->text.data=num;
    temp->next=NULL;
    temp->next=head->next;
    head->next=temp;
    head->text.len++;
    return;
}

//从头部开始删除数据
datatype delete_looplinklistByhead(Linklist*head)
{
	if(head->next==NULL)
	{
		printf("链表为空，删除失败");
		return (datatype)-1;
	}
	Linklist*temp=head->next;
	head->next=temp->next;
	datatype num=temp->text.data;
	free(temp);
	temp=NULL;
	head->text.len--;
	return num;
}

//从尾部插入数据
void insert_looplinklistbyTail(Linklist*head,datatype num)
{
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==temp)
	{
		printf("创建节点失败，插入失败");
	}	
	temp->text.data=num;
	temp->next=NULL;
	Linklist*p=head;
	while(p->next!=head)
	{
		p=p->next;
	}
	temp->next=head;
	p->next=temp;
	head->text.len++;
	return;
}

//从尾部开始删除数据
void delete_looplinklistByTali(Linklist*head)
{
	if(NULL==head->next)
	{
		printf("链表为空，删除失败");
	}
//找倒数第二个节点
	Linklist*p=head;
	while(p->next->next!=head)
	{
		p=p->next;
	}
	free(p->next);
	p->next=head;
	head->text.len--;
	return;
}

//按位置插入数据
void insert_looplinklistByposition(Linklist*head,datatype num,int n)
{
	if(n<1)
	{
		printf("插入位置非法");
		return;
	}
	Linklist*p=head;
	for(int i=0;i<n-1;i++)
	{
		p=p->next;
		if(NULL==p)
		{
			printf("插入位置非法");
			return;
		}
	}
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==temp)
	{
		printf("创建节点失败，插入失败");
		return;
	}
	temp->text.data=num;
	temp->next=NULL;
	temp->next=p->next;
	p->next=temp;
	head->text.len++;
	return;
}


//按位置删除数据
void delete_looplinklistByposition(Linklist*head,int n)
{
	//判断列表是是否为空
	if(NULL==head->next)
	{
		printf("列表为空，删除失败\n");
		return;
	}
	if(n<1)
	{
		printf("删除位置非法\n");
		return;
	}
	Linklist*p=head;
	for(int i=0;i<n-1;i++)
	{
		p=p->next;
		if(p->next==head)
		{
			printf("删除位置非法\n");
			return;
		}
	}
	Linklist*temp=p->next;
	p->next=temp->next;
	free(temp);
	head->text.len--;
	return;
}


//遍历单项循环链表
void show_looplinklist(Linklist*head)
{
	Linklist*p=head;
	while(p->next!=head)
	{
		p=p->next;
		printf("%d ",p->text.data);
	}
	putchar(10);
	return;
}


03_main.c

#include <stdio.h>
#include <stdlib.h>
#include "01_func.h"
int main(int argc, const char *argv[])
{
	Linklist*head=create_looplinklist();
	insert_looplinklistbyhead(head,60);
	insert_looplinklistbyhead(head,70);
	insert_looplinklistbyhead(head,80);
	insert_looplinklistbyhead(head,90);

	delete_looplinklistByhead(head);

	insert_looplinklistbyTail(head,50);
	insert_looplinklistbyTail(head,40);
	insert_looplinklistbyTail(head,30);

	delete_looplinklistByTali(head);

	show_looplinklist(head);

	insert_looplinklistByposition(head,85,1);

	delete_looplinklistByposition(head,1);

	show_looplinklist(head);

	return 0;
}

3.双向链表

头文件
#ifndef __FUNC__
#define __FUNC__
typedef int datatype;
typedef struct lklist
{
	union
	{
		int len;
		datatype data;
	}text;
	struct lklist*next;
	struct lklist*prev;
}Linklist;
Linklist*creat_Bilooplinklist();
void insert_Bilooplinklistbyhead(Linklist*head,datatype num);
void show_Bilooplinklist(Linklist*head);
void insert_BilooplinklistbyTail(Linklist*head,datatype num);
datatype delete_BilooplinklistByhead(Linklist*head);
void delete_BilooplinklistByTali(Linklist*head);
void insert_BilooplinklistByposition(Linklist*head,datatype num,int n);
void delete_BilooplinklistByposition(Linklist*head,int n);
#endif


02_Bilooplinklist.c
#include <stdio.h>
#include <stdlib.h>
#include "./01_func.h"

//创建一个空的双向链表
Linklist*creat_Bilooplinklist()
{
    Linklist*head=(Linklist*)malloc(sizeof(Linklist));
    if(NULL==head)
    {
        printf("创建空链表失败");
        return NULL;
    }
    head->next=NULL;
	head->prev=NULL;
    head->text.len=0;
    return head;
}

//头插法插入数据
void insert_Bilooplinklistbyhead(Linklist*head,datatype num)
{
    //创建新节点
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
    if(NULL==temp)
    {
        printf("创建节点失败，插入失败");                   
    }
    temp->text.data=num;
    temp->next=NULL;
	temp->prev=NULL;

    temp->next=head->next;
    head->next=temp;

	if(temp->next!=NULL)
	{
		temp->next->prev=temp;
	}
	temp->prev=head;
    head->text.len++;
    return;
}


//遍历单项循环链表
void show_Bilooplinklist(Linklist*head)
{
	Linklist*p=head;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%d ",p->text.data);
	}
	putchar(10);
	return;
}

//从头部开始删除数据
datatype delete_BilooplinklistByhead(Linklist*head)
{
	if(head->next==NULL)
	{
		printf("链表为空，删除失败");
		return (datatype)-1;
	}
	Linklist*temp=head->next;
	head->next=temp->next;
    if(head->next==NULL)
	{    
    temp->next->prev=head;    
    }
	datatype num=temp->text.data;
	free(temp);
	temp=NULL;
	head->text.len--;
	return num;
}



//从尾部插入数据
void insert_BilooplinklistbyTail(Linklist*head,datatype num)
{
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==temp)
	{
		printf("创建节点失败，插入失败");
	}	
	temp->text.data=num;
	temp->next=NULL;
	temp->prev=NULL;
	Linklist*p=head;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	temp->next=p->next;
	p->next=temp;
	temp->prev=p;
	head->text.len++;
	return;
}

//从尾部开始删除数据
void delete_BilooplinklistByTali(Linklist*head)
{
	if(NULL==head->next)
	{
		printf("链表为空，删除失败");
	}
//找倒数第二个节点
	Linklist*p=head;
	while(p->next->next!=NULL)
	{
		p=p->next;
	}
	free(p->next);
	p->next=NULL;
	head->text.len--;
	return;
}

//按位置插入数据
void insert_BilooplinklistByposition(Linklist*head,datatype num,int n)
{
	if(n<1)
	{
		printf("插入位置非法");
		return;
	}
	Linklist*p=head;
	for(int i=0;i<n-1;i++)
	{
		p=p->next;
		if(NULL==p)
		{
			printf("插入位置非法");
			return;
		}
	}
	Linklist*temp=(Linklist*)malloc(sizeof(Linklist));
	if(NULL==temp)
	{
		printf("创建节点失败，插入失败");
		return;
	}
	temp->text.data=num;
	temp->next=NULL;
	temp->prev=NULL;

	temp->next=p->next;
	p->next=temp;

	temp->prev=p;
	if(p->next==NULL)
	{
		temp->next->prev=temp;
	}
	
	head->text.len++;
	return;
}


//按位置删除数据
void delete_BilooplinklistByposition(Linklist*head,int n)
{
	//判断列表是是否为空
	if(NULL==head->next)
	{
		printf("列表为空，删除失败\n");
		return;
	}
	if(n<1)
	{
		printf("删除位置非法\n");
		return;
	}
	Linklist*p=head;
	for(int i=0;i<n-1;i++)
	{
		p=p->next;
		if(p->next==NULL)
		{
			printf("删除位置非法\n");
			return;
		}
	}
	Linklist*temp=p->next;
	p->next=temp->next;
	
	if(p->next!=NULL)
	{
		temp->next->prev=p;
	}

	free(temp);
	head->text.len--;
    retunrn;
}


03_main.c

#include <stdio.h>
#include <stdlib.h>
#include "01_func.h"
int main(int argc, const char *argv[])
{

Linklist*head=creat_Bilooplinklist();
insert_Bilooplinklistbyhead(head,5);
insert_Bilooplinklistbyhead(head,10);
insert_Bilooplinklistbyhead(head,15);
insert_Bilooplinklistbyhead(head,20);
insert_Bilooplinklistbyhead(head,25);

show_Bilooplinklist(head);

insert_BilooplinklistbyTail(head,0);

delete_BilooplinklistByhead(head);

show_Bilooplinklist(head);

delete_BilooplinklistByTali(head);

show_Bilooplinklist(head);

insert_BilooplinklistByposition(head,100,2);
show_Bilooplinklist(head);
	
	
delete_BilooplinklistByposition(head,3);	
show_Bilooplinklist(head);
	

	return 0;
}