周末作业

工控菜鸟转嵌入式

已于 2023-06-18 22:59:06 修改

阅读量90

点赞数

文章标签：链表数据结构

于 2023-06-18 22:40:57 首次发布

本文链接：https://blog.csdn.net/qq_62504624/article/details/131276165

版权

这篇文章包含C语言代码实现的数据结构操作，包括顺序表的创建、插入、删除和输出，单链表的创建、插入、反转、排序等，双向链表的创建和插入，以及循环队列的创建和入队、出队操作。代码详细展示了这些基本数据结构的操作函数。

摘要由CSDN通过智能技术生成

#ifndef __HEAD_H_
#define __HEAD_H_
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#if 0
#define MAXSIZE 6
typedef int datatype;
typedef struct
{
	datatype data[MAXSIZE];
	datatype len;
}seqlist;
seqlist*create();
void insert(seqlist*list,datatype e);
int Delete(seqlist*list);
void dev(seqlist*list);
void delete_sub(seqlist*list,datatype sub);
void output(seqlist*list);
#endif
//---------------链表-------------------
#if 0
typedef int datatype;
typedef struct Node
{
	//数据域
	union
	{
		datatype len;
		datatype data;
	};
	//指针域
	struct Node*next;

}*linklist;
linklist create_Node(int flag);
void insert_head(linklist L,int e);
void output(linklist L);
linklist insert_rear(linklist L,int e,linklist rear);
void delete_head(linklist L);
void delete_rear(linklist L);
void rev_linklist(linklist L);
void Bubble_sort(linklist L);
void Selection_sort(linklist L);
#endif
//-----------------------------------------双向链表--------------------------------------
#if 0
typedef int datatype;
typedef struct Node
{
	//数据域
	union
	{
		datatype len;
		datatype data;
	};
	//指针域
	struct Node*next;
	struct Node*prev;
}*double_linklist;
double_linklist create_double(int flag);
void insert_head(double_linklist L,int e);
void output(double_linklist L);
//void insert_rear(double_linklist )
double_linklist insert_rear(double_linklist ,int e,double_linklist rear);
void delete_head(double_linklist L);
void delete_rear(double_linklist L);
#endif
//-------------------------------循环队列---------------------------------
#if 0
#define MAXSIZE 5
typedef int datatype;
typedef struct
{
	int data[MAXSIZE];
	int front;
	int rear;
}Quenelist;
Quenelist*create_quene();
int enquene(Quenelist*quene,int e);
void output( Quenelist*quene);
int outquene(Quenelist*quene);
#endif

#endif

head.h

#include "head.h"
//-------------------------顺序表----------------------------------------
#if 0
seqlist*create()
{
	seqlist*list = (seqlist*)malloc(sizeof(seqlist));
	if (NULL == list)
	{
		return NULL;
	}
	list->len = 0;
	return list;
}
void insert(seqlist*list,datatype e)
{
	if (NULL == list )
	{
		return;
	}
	list->data[list->len] = e;
	list->len++; 
}
void output(seqlist*list)
{
	if (NULL == list || list->len == 0)
	{
		printf("表空\n");
		return;
	}
	for (datatype i=0; i < list->len; i++)
	{
		printf("%d\t",list->data[i]);
	}
	puts("");
}
int Delete(seqlist*list)
{
	if (NULL == list)
	{
		return -1;
	}
	list->len--;
	return 0;
}
void delete_sub(seqlist*list,datatype sub)
{
	if (NULL == list || list->len == 0)
	{
		return;
	}
void output(double_linklist L)
	if (sub < 0 || sub >= list->len)
	{
		return;
	}
	for (datatype i = sub; i < list->len; i++)
	{
		list->data[i] = list->data[i+1];
	}
	list->len--;
}
void dev(seqlist*list)
{
	if ( NULL == list || list->len == 0 )
	{
		return ;
	}
	for (datatype i = 0; i < list->len-1;i++)
	{
		for (datatype j = i+1; j < list->len; j++)
		{
			if (list->data[i] == list->data[j])
			{
				delete_sub(list,j);
			}
		}
	}
}
#endif
//---------------------------------链表---------------------------------
#if 0
linklist create_Node(int flag)
{
	linklist L = (linklist)malloc(sizeof(struct Node));
	if ( NULL ==L )
	{
		return NULL;
	}
	if (flag == 0)
	{
	L->len = 0;
	}
	else if (flag == 1)
	{
	L->next = NULL;
	L->len = 0;
	}
	return L;
}
void insert_head(linklist L,int e)
{
	if (NULL == L)
	{
		return;
	}
	linklist s = create_Node(0);
	s->data = e;
	s->next = L->next;
	L->next = s;
	L->len++;
}
void output(linklist L)
{
	if ( NULL == L )
	{
		return;
	}
	linklist p = L;
	while (p->next != NULL)
	{
		p = p->next;
		printf("%d\t",p->data);
	}
	L->len++;
	puts("");
}
linklist insert_rear(linklist L,int e,linklist rear)
{
	if (NULL == L)
	{
		return NULL;
	}
	linklist s = create_Node(0);
	s->data = e;
	rear->next = s;
	rear = s;
	L->len++;
	return rear;
}
void delete_head(linklist L)
{
	if (NULL == L)
	{
		return ;
	}
	linklist q = L->next;
	L->next = q->next;
	free(q);
	q = NULL;
	L->len--;
	puts("");
}
void delete_rear(linklist L)
{
	if ( NULL == L || L->next == NULL)
	{
		return;
	}
	linklist p = L->next;
	while ( p->next->next != NULL )
	{
		p = p->next;
	}
	free(p->next);
	p->next = NULL;
	L->len--;
	puts("");
}
void rev_linklist(linklist L)
{
	linklist p = L->next;
	L->next = NULL;
	while (p != NULL )
	{
	linklist t = p;
	p = p->next;
	t->next = L->next;
	L->next = t;
	}
}
void Bubble_sort(linklist L)
{
	for ( linklist i = L->next; i->next != NULL ; i = i->next )
	{
		for ( linklist j = L->next; j->next != NULL; j = j->next )
		{
			if (j->data > j->next->data)
			{
				int t = j->data;
				j->data = j->next->data;
				j->next->data = t;
			}
		}
	}
}
void Selection_sort(linklist L)
{
	for ( linklist i = L->next; i->next != NULL; i = i->next )
	{
		linklist min = i;
		for (linklist j = i->next; j != NULL; j = j->next)
		{
			if ( j->data > min->data )
			{
				min = j;
			}
		}
		if (min != i)
		{
			int t = min->data;
			min->data = i->data;
			i->data = t;
		}
	}
}
#endif
//---------------------------------双向链表-------------
#if 0
double_linklist create_double(int flag)
{
	double_linklist L = (double_linklist)malloc(sizeof(struct Node));
	if(NULL == L)
	{
		return NULL;
	}
	if (flag == 0)
	{
		L->len = 0;
	}
	if (flag == 1)
	{
		L->next = NULL;
		L->prev = NULL;
		L->len = 0;
	}
	return L;
}
void insert_head(double_linklist L,int e)
{
	if (L == NULL )
	{
		return;
	}
	double_linklist s = create_double(0);
	s->data = e;
	s->next = L->next;
	s->prev = L;
	if (L->next != NULL)
	{
		L->next->prev = s;
	}
	L->next = s;
	L->len++;
}
void output(double_linklist L)
{
	double_linklist p = L;
	while (p->next != NULL)
	{
		p = p->next;
		printf("%d\t",p->data);
	}
	puts("");
}
double_linklist insert_rear(double_linklist L ,int e,double_linklist rear)
{
	if (NULL == L)
	{
		return NULL;
	}
	double_linklist s = create_double(0);
	if (s == NULL)
	{
		printf("该点创建失败\n");
		return NULL;
	}
	s->data = e;
	rear->next = s;
	s->prev = rear;
	rear = s;
	L->len++;
	return rear;
}
void delete_head(double_linklist L)
{
	if (NULL == L || NULL == L->next)
	{
		printf("666\n");
		return ;
	}
	double_linklist p = L->next;
	L->next = p->next;
	p->next->prev = L;
	free(p);
	p=NULL;
	L->len--;
}
void delete_rear(double_linklist L)
{
	if ( NULL == L || NULL == L->next )
	{
		return ;
	}
	double_linklist p = L;
	while ( p->next != NULL )
	{
		p = p->next;
	}
	p->prev->next = NULL;
	free(p);
	p = NULL;
	L->len--;
}
#endif
//-------------------------------循环队列---------------------------
#if 0
Quenelist*create_quene()
{
	Quenelist*quene = (Quenelist*)malloc(sizeof(Quenelist));
	if ( NULL ==  quene)
	{
		return NULL;
	}
	quene->front = 0;
	quene->rear = 0;
	return quene;
}
int enquene(Quenelist*quene,int e)
{
	if (quene == NULL || quene->front == (quene->rear+1)%MAXSIZE)
	{
		return -1;
	}
		quene->data[quene->rear] = e;
		quene->rear = (quene->rear+1)%MAXSIZE;
		return 0;
}
void output( Quenelist*quene)
{
	if ( NULL == quene || quene->front == quene->rear)
	{
		return ;
	}
	for ( int i = quene->front; i != quene->rear; i = (i+1)%MAXSIZE )
	{
		printf("%d\t",quene->data[i]);
	}
}
int outquene(Quenelist*quene)
{
	if (NULL == quene || quene->front == quene->rear)
	{
		printf("666\n");
		return -1;
	}
	int e = quene->data[quene->front];
	quene->front = (quene->front+1)%MAXSIZE;
	return e;
}
int Number(Quenelist*quene)
{
	int num = (MAXSIZE-quene->front+quene->rear)%MAXSIZE;
	return num;
}
#endif

homework.c

#include "head.h"
int main(int argc, const char *argv[])
{
#if 0
	seqlist*list = create();
	datatype e;
	datatype n;
	printf("请输入需要插入的尾插个数：");
	scanf("%d",&n);
	for ( datatype i = 0; i < n; i++ )
	{
		printf("请输入需要插入的值：");
		scanf(" %d",&e);
		insert(list,e);
	}
	output(list);
	Delete(list);
	Delete(list);
	output(list);
	printf("请输入需要删除的下标：");
	datatype sub;
	scanf(" %d",&sub);
	delete_sub(list,sub);
	output(list);
	dev(list);
	output(list);
#endif
//---------------------------------链表---------------------------
#if 0
	linklist L = create_Node(1);
	int n;
	linklist rear = L;
	printf("请输入需要插入的个数：");
	scanf("%d",&n);
	int e;
	for (int i = 0; i < n; i++ )
	{
		printf("请输入需要插入的第%d个数字：",i+1);
		scanf("%d",&e);
	//	insert_head(L,e);
		rear = insert_rear(L,e,rear);
	}
//	output(L);
//	delete_head(L);
//	delete_rear(L);
//	delete_rear(L);
	output(L);
	rev_linklist(L);
	output(L);
	Bubble_sort(L);
	output(L);
	Selection_sort(L);
	output(L);
#endif
//--------------------------------------双向链表------------------------
#if 0

	double_linklist L = create_double(1);
	int e;
	printf("请输入需要插入的个数：");
	int n;
	double_linklist rear = L;
	scanf("%d",&n);
	for (int i = 0; i < n; i++)
	{
		printf("请输入第%d个元素：",i+1);
		scanf("%d",&e);
	//	insert_head(L,e);
		rear=insert_rear(L,e,rear);
	}
	output(L);
//	delete_head(L);
	delete_rear(L);
	output(L);
#endif
//-----------------------------------循环队列------------------------
#if 0
	Quenelist*quene = create_quene();
	int e;
	char ch;
	do
	{
		printf("请输入需要入队的元素：");
		scanf(" %d",&e);
		enquene(quene,e);
		printf("请问还继续入队吗？yes/no：");
		scanf(" %c",&ch);
	}
	while ( ch == 'Y' || ch == 'y');
	output(quene);
	do
	{
		e = outquene(quene);
		printf("出队的元素为%d",e);
		printf("请问还继续出队吗：yes/no");
		scanf(" %c",&ch);
	}
	while (ch == 'Y' || ch == 'y');
	output(quene);
	return 0;
}
#endif

main.c

#include <stdio.h>
#include<string.h>
#include<stdlib.h>
typedef char datatype;
typedef struct Node
{
	//数据域表达式的意思是
	datatype data;
	//左孩子右孩子
	struct Node*lchild;
	struct Node*rchild;
}*Btree;
Btree create()
{
	datatype e;
	printf("请输入数据元素：");
	scanf(" %c",&e);
	if (e == '#')
	{
		return NULL; 
	}
	Btree T = (Btree)malloc(sizeof(struct Node));
	if (NULL == T)
	{
		return NULL;
	}
	//数据域赋值
	T->data = e;
	//创建左孩子
	puts("左孩子");
	T->lchild = create();
	//创建右孩子
	puts("右孩子");
	T->rchild = create();
	return T;
}
void first(Btree T )
{
	if (NULL == T)
	{
		return;
	}
	printf("%c ", T->data);
	first(T->lchild);
	first(T->rchild);
}
void mid(Btree T )
{
	if (NULL == T)
	{
		return;
	}
	mid(T->lchild);
	printf("%c ", T->data);
	mid(T->rchild);
}
void last(Btree T )
{
	if (NULL == T)
	{
		return;
	}
	last(T->lchild);
	last(T->rchild);
	printf("%c ", T->data);
}
int main(int argc, const char *argv[])
{
	Btree T =create();
	first( T );
	puts("");
	mid(T );
	puts("");
	last(T );
	puts("");
	
	
	return 0;
}

二叉树创建与遍历