嵌入式学习之数据结构

我智商开挂

已于 2023-10-30 16:11:35 修改

阅读量98

点赞数

文章标签： c语言数据结构算法链表排序算法

于 2023-08-13 15:45:30 首次发布

本文链接：https://blog.csdn.net/weixin_58619060/article/details/132249858

版权

一、顺序表

#define SIZE 100

typedef int data_t; //数据的类型

//顺序表
typedef struct list{
	data_t data[SIZE]; //数组
	int last; //整型变量--表示最后一个元素的下标
}seqlist;

#include "seqlist.h"

//初始化
seqlist *createSeqlist(void)
{
	seqlist *seq = (seqlist *)malloc(sizeof(seqlist));
	if(seq == NULL)
	{
		//printf("malloc filded\n");
		perror("xxxxx"); //出错处理函数 xxxxx:出错原因
		return NULL; //异常结束程序
	}

	memset(seq->data, 0, sizeof(seq->data));  //数组清零
	
	seq->last = -1; 

	return seq;
}


//判空
int seqlist_is_empty(seqlist *seq)
{
	return (seq->last == -1)?1:0;
}


//判满
int seqlist_is_full(seqlist *seq)
{
	return (seq->last == SIZE-1)?1:0;
}

//求表长
int seqlist_length(seqlist *seq)
{
	return seq->last+1;
}

//命名规则：驼峰命名法
//大驼峰：所有单词首字母都大写
//小驼峰：除了第一个单词首字母小写，其他都大写

//按位置进行插入
int seqlistInsertByPos(seqlist *seq, int pos, data_t data)
{
	//1.判满
	if( seqlist_is_full(seq))
	{
		printf("seqlist is full\n");
		return -1;
	}

	int len = seqlist_length(seq);

	//2.判断pos位置是否有效
	if( pos < 0  || pos > len )
	{
		printf("pos 位置不合法\n");
		return -1;
	}

	//3.插入元素
	int i;
	for( i=seq->last ; i>=pos ; i--)
	{
		seq->data[i+1] = seq->data[i];
	}

	seq->data[pos] = data;

	seq->last++;

	return 0;
}


//按位置进行删除
int seqlistDeleteByPos(seqlist *seq, int pos)
{
	//1.判空
	if(seqlist_is_empty(seq))
	{
		printf("seqlist is empty\n");
		return -1;
	}

	//2.判断pos位置是否有效
	if( pos < 0 || pos > seq->last)
	{
		printf("pos 位置不合法\n");
		return -1;
	}


	//3.删除元素
	int i;
	for(i=pos; i<seq->last; i++)
	{
		seq->data[i] = seq->data[i+1];
	}
	
	seq->last--;

	return 0;
}

//按位置进行查找
data_t seqlistFindByPos(seqlist *seq, int pos)
{
	//1.判空
	if(seqlist_is_empty(seq))
	{
		printf("seqlist is empty\n");
		return -1;
	}

	//2.判断pos位置是否有效
	if( pos < 0 || pos > seq->last)
	{
		printf("pos 位置不合法\n");
		return -1;
	}

	return seq->data[pos];
}

//按位置进行修改
int seqlistChangeByPos(seqlist *seq, int pos, data_t data)
{
	//1.判空
	if(seqlist_is_empty(seq))
	{
		printf("seqlist is empty\n");
		return -1;
	}

	//2.判断pos位置是否有效
	if( pos < 0 || pos > seq->last)
	{
		printf("pos 位置不合法\n");
		return -1;
	}

	seq->data[pos] = data;

	return 0;
}

//按值进行查找
int seqlistFindByData(seqlist *seq, data_t data)
{
	if(seqlist_is_empty(seq))
	{
		printf("seqlist is empty\n");
		return -1;
	}

	int i;
	for(i=0; i<=seq->last; i++)
	{
		if(seq->data[i] == data)
		{
			return i;
		}
	}

	printf("no this word:%d\n",data);

	return -1;
}

//按值进行删除
int seqlistDeleteByData(seqlist *seq, data_t data)
{
	int pos = seqlistFindByData(seq,data);

	seqlistDeleteByPos(seq, pos);

	return 0;
}

//按值进行修改
int seqlistChangeByData(seqlist *seq, data_t old, data_t new)
{
	int pos = seqlistFindByData(seq, old);

	seqlistChangeByPos(seq, pos, new);

	return 0;
}

//清空
void seqlist_clear(seqlist *seq)
{
	seq->last = -1;
}

//销毁
void seqlist_destroy(seqlist **seq)
{
	free(*seq);
	*seq = NULL;
}

//打印
void seqlist_display(seqlist *seq)
{
	int i;

	for(i=0; i<=seq->last; i++)
	{
		printf("%d ", seq->data[i]);
	}

	puts(""); //printf("\n");  putchar('\n');
}

二、链表

（一）单链表

typedef int data_t;

typedef struct node{
	data_t data; //数据域：保存数据
	struct node *next; //指针域：保存下一个节点的地址
}linklist;

//初始化
linklist *creatLinklist(void)
{
	linklist *head = (linklist *)malloc(sizeof(linklist));
	if(head == NULL)
	{
		perror("malloc");
		return NULL;
	}

	head->next = NULL;  //头节点：辅助工具
	head->data = -1;

	return head;
}


//判空
int linklist_is_empty(linklist *head)
{
	return (head->next == NULL)?1:0;
}

//求表长
int linklist_length(linklist *head)
{
	int len = 0;

	linklist *p = head->next; //p指向第一个有效节点

	while(p != NULL)
	{
		len++;
		p=p->next;
	}
	
	return len;
}


//按位置添加节点
int linklistInsertByPos(linklist *head, int pos, data_t data)
{
	//不需要判满
	
	//判断pos位置是否合法
	int len = linklist_length(head);

	if(pos < 0 || pos > len)
	{
		printf("pos 位置不合法\n");
		return -1;
	}

	//先准备一个新节点
	linklist *new = (linklist *)malloc(sizeof(linklist));

	new->data = data;
	new->next = NULL;

	//开始插入之前，找到pos节点的前一个节点
	linklist *p = head;

	while(pos--)
	{
		p=p->next;
	}


	//先连后断
	new->next = p->next;
	p->next = new;

	return 0;
}


//按位置删除节点
int linklistDeleteByPos(linklist *head, int pos)
{
	//1.判空
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return -1;
	}

	int len = linklist_length(head);

	//2.判断pos位置是否合法
	if( pos < 0 || pos >= len)
	{
		printf("pos 位置不合法\n");
		return -1;
	}

	//3. 找到pos位置的前一个节点
	linklist *p = head; //辅助指针

	while(pos--)
	{
		p=p->next;
	}

	linklist *q = p->next;
	
	p->next = q->next;

	free(q);

	q= NULL;

	return 0;
}

//按位置查找节点
data_t linklistFindByPos(linklist *head, int pos)
{
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return -1;
	}

	linklist *p = head->next; //第一个有效节点

	while(pos--)
	{
		p=p->next;
	}

	return p->data;
}

//按位置修改节点
int linklistChangeByPos(linklist *head, int pos, data_t data)
{
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return -1;
	}

	linklist *p = head->next; //第一个有效节点

	while(pos--)
	{
		p=p->next;
	}

	p->data = data;

	return 0;
}

//按值查找节点
int linklistFindByData(linklist *head, data_t data)
{
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return -1;
	}

	linklist *p = head->next; //第一个有效节点

	int i=0;
	while(p != NULL)
	{
		if(p->data == data)
		{
			return i;	
		}
		i++;
		p=p->next;
	}

	printf("no this word\n");

	return -1;
}

//按值删除节点
int linklistDeleteByData(linklist *head, data_t data)
{
	int pos = linklistFindByData(head, data);

	linklistDeleteByPos(head, pos);

	return 0;
}

//按值修改节点
int linklistChangeByData(linklist *head, data_t old, data_t new)
{
	int pos = linklistFindByData(head, old);

	linklistChangeByPos(head, pos, new);

	return 0;
}

//清空链表
void linklist_clear(linklist *head)
{
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return;
	}

	linklist *p = head;

	linklist *q = NULL;

	while(p->next != NULL)
	{
		q = p->next;

		p->next = q->next;

		free(q);

		q= NULL;
	}


}


//销毁链表
void linklist_destory(linklist **head)
{
	linklist_clear(*head);

	free(*head);

	*head= NULL;
}


//打印
void linklist_display(linklist *head)
{
	linklist *p = head->next;

	while(p!=NULL)
	{
		printf("%d ", p->data);

		p=p->next;
	}

	puts("");
}


//逆序（头插法）
void linklist_nixu(linklist *head)
{
	linklist *p = head->next;

	linklist *q = NULL;
	
	head->next = NULL;

	while(p != NULL)
	{	
		q = p->next;

		p->next = head->next;
	
		head->next = p;

		p = q;
	}

}

（二）双链表

typedef int data_t;

typedef struct node{
	data_t data;
	struct node *next;    //保存下一个结点的地址
	struct node *prior;   //保存上一个结点的地址
}dlinklist;

dlinklist *createDlinklist()
{
	dlinklist *head = (dlinklist *)malloc(sizeof(dlinklist));
	if(NULL == head)
	{
		perror("malloc");
		return NULL;
	}

	head->next = NULL;
	head->prior = NULL;

	return head;
}

int dlinklist_is_empty(dlinklist *head)
{
	return (head->next == head->prior )?1:0;
}

int dlinklist_length(dlinklist *head)
{
	dlinklist *p = head->next;

	int num = 0;
	while(p != NULL)
	{
		num++;
		p=p->next;
	}
	return num;
}

//按位置插入
int dlinklistInsertByPos(dlinklist *head, int pos, data_t data)
{
	int len = dlinklist_length(head);
	if(pos < 0 || pos > len)
		return -1;

	dlinklist *new = (dlinklist *)malloc(sizeof(dlinklist));
	if(NULL == new)
	{
		perror("malloc");
		return -1;
	}

	new->data = data;
	new->next = NULL;
	new->prior = NULL;

	//找到pos位置的前一个结点
	dlinklist *p = head;
	while(pos--)
	{
		p=p->next;
	}

	if(p->next != NULL) //中间
	{
		new->next = p->next;
		new->prior = p;
	
		p->next = new;
		new->next->prior = new; 
	}
	else{ //末尾

		p->next = new;
		new->prior = p;	
	}

	return 0;
}

//按位置删除
int dlinklistDeleteByPos(dlinklist *head, int pos)
{
	if(dlinklist_is_empty(head))
		return -1;

	int len = dlinklist_length(head);
	if(pos < 0 || pos > len-1)
		return -1;

	//找到pos位置的前一个结点
	dlinklist *p = head;
	while(pos--)
	{
		p=p->next;
	}

	dlinklist *q = p->next;

	if(q->next != NULL) //中间
	{
		p->next = q->next;

		q->next->prior = p;

		free(q);
	
		q = NULL;

	}
	else{ //末尾
	
		p->next = NULL;
	
		free(q);

		q = NULL;
	}

}

//按位置查找节点
data_t dlinklistFindByPos(dlinklist *head, int pos)
{
	if(dlinklist_is_empty(head))
		return -1;

	int len = dlinklist_length(head);
	if(pos < 0|| pos > len-1)
		return -1;

	dlinklist *p = head->next;

	while(pos--)
	{
		p=p->next;
	}

	return p->data;
}


//按位置修改节点
int dlinklistChangeByPos(dlinklist *head, int pos , data_t data)
{
	if(dlinklist_is_empty(head))
		return -1;

	int len = dlinklist_length(head);
	if(pos < 0|| pos > len-1)
		return -1;

	dlinklist *p = head->next;

	while(pos--)
	{
		p=p->next;
	}

	p->data = data;

	return 0;
}


//按值查找节点
int dlinklistFindByData(dlinklist *head, data_t data)
{
	if(dlinklist_is_empty(head))
		return -1;

	dlinklist *p = head->next;

	int i = 0;

	while(p != NULL)
	{
		if(p->data == data)
		{
			return i;
		}
		i++;
		p=p->next;
	}

	printf("没有这个值!\n");

	return -1;
}


//按值删除节点
int dlinklistDeleteByData(dlinklist *head, data_t data)
{
	int pos = dlinklistFindByData(head, data);

	dlinklistDeleteByPos(head, pos);

	return 0;
}

//按值修改节点
int dlinklistChangeByData(dlinklist *head, data_t old, data_t new)
{
	int pos = dlinklistFindByData(head, old);
	
	dlinklistChangeByPos(head, pos, new);

	return 0;
}

//清空链表
int dlinklistClear(dlinklist *head)
{
	if(dlinklist_is_empty(head))
		return -1;

	dlinklist *p = head->next;

	head->next = NULL;

	dlinklist *q = NULL;

	while(p != NULL)
	{
		q = p->next;
	
		free(p);

		p=NULL;

		p = q;
	}

	return 0;
}



//销毁链表
void dlinklistDestory(dlinklist **head)
{
	dlinklistClear(*head);

	free(*head);

	*head = NULL;
}


//链表逆序（头插法）
void dlinklistNixu(dlinklist *head)
{
	dlinklist *p = head->next;

	head->next = NULL;

	dlinklist *q = NULL;

	while(p != NULL)
	{
		q = p->next;

		p->next = head->next;

		if(p->next != NULL) //第一次循环的时候，没有这根线
			p->next->prior = p;

		head->next = p;

		p->prior = head;

		p = q;
	}
}


//打印
void dlinklist_display(dlinklist *head)
{
	if(dlinklist_is_empty(head))
		return;

	dlinklist *p = head->next;
	while(p != NULL)
	{
		printf("%d ", p->data);
		p=p->next;
	}

	puts("");
}

（三）循环单链表

//规律
//1. head->next = head;
//2. p->next != head;
//3. 插入的时候：pos位置是否合法 pos = pos%(len+1);
//4. 删除的时候：pos位置是否合法 pos = pos%len;


typedef int data_t;

typedef struct node{
	data_t data; //数据域：保存数据
	struct node *next; //指针域：保存下一个节点的地址
}linklist;

//初始化
linklist *creatLinklist(void)
{
	linklist *head = (linklist *)malloc(sizeof(linklist));
	if(head == NULL)
	{
		perror("malloc");
		return NULL;
	}

	//----------------------------------------------
	head->next = head;  //头节点：辅助工具
	head->data = -1;

	return head;
}


//判空
int linklist_is_empty(linklist *head)
{
	//------------------------------------------
	return (head->next == head)?1:0;
}

//求表长
int linklist_length(linklist *head)
{
	int len = 0;

	linklist *p = head->next; //p指向第一个有效节点

	//---------------------------------------
	while(p != head)
	{
		len++;
		p=p->next;
	}
	
	return len;
}


//按位置添加节点
int linklistInsertByPos(linklist *head, int pos, data_t data)
{
	//不需要判满
	
	//判断pos位置是否合法
	int len = linklist_length(head);

	//------------------------------------------
	if(pos < 0)
	{
		printf("pos 位置不合法\n");
		return -1;
	}

	//---------------------------------------------
	pos = pos%(len+1);

	//先准备一个新节点
	linklist *new = (linklist *)malloc(sizeof(linklist));

	new->data = data;
	new->next = NULL;

	//开始插入之前，找到pos节点的前一个节点
	linklist *p = head;

	while(pos--)
	{
		p=p->next;
	}


	//先连后断
	new->next = p->next;
	p->next = new;

	return 0;
}


//按位置删除节点
int linklistDeleteByPos(linklist *head, int pos)
{
	//1.判空
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return -1;
	}

	int len = linklist_length(head);

	//--------------------------------------
	//2.判断pos位置是否合法
	if( pos < 0)
	{
		printf("pos 位置不合法\n");
		return -1;
	}
	//-----------------------------------------
	pos = pos%len;

	//3. 找到pos位置的前一个节点
	linklist *p = head; //辅助指针

	while(pos--)
	{
		p=p->next;
	}

	linklist *q = p->next;
	
	p->next = q->next;

	free(q);

	q= NULL;

	return 0;
}

//按位置查找节点
data_t linklistFindByPos(linklist *head, int pos)
{
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return -1;
	}

	linklist *p = head->next; //第一个有效节点

	while(pos--)
	{
		p=p->next;
	}

	return p->data;
}

//按位置修改节点
int linklistChangeByPos(linklist *head, int pos, data_t data)
{
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return -1;
	}

	linklist *p = head->next; //第一个有效节点

	while(pos--)
	{
		p=p->next;
	}

	p->data = data;

	return 0;
}

//按值查找节点
int linklistFindByData(linklist *head, data_t data)
{
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return -1;
	}

	linklist *p = head->next; //第一个有效节点

	//-----------------------------------------------
	int i=0;
	while(p != head)
	{
		if(p->data == data)
		{
			return i;	
		}
		i++;
		p=p->next;
	}

	printf("no this word\n");

	return -1;
}

//按值删除节点
int linklistDeleteByData(linklist *head, data_t data)
{
	int pos = linklistFindByData(head, data);

	linklistDeleteByPos(head, pos);

	return 0;
}

//按值修改节点
int linklistChangeByData(linklist *head, data_t old, data_t new)
{
	int pos = linklistFindByData(head, old);

	linklistChangeByPos(head, pos, new);

	return 0;
}

//清空链表
void linklist_clear(linklist *head)
{
	if(linklist_is_empty(head))
	{
		printf("linklist is empty\n");
		return;
	}

	linklist *p = head;

	linklist *q = NULL;

	//---------------------------------
	while(p->next != head)
	{
		q = p->next;

		p->next = q->next;

		free(q);

		q= NULL;
	}


}


//销毁链表
void linklist_destory(linklist **head)
{
	linklist_clear(*head);

	free(*head);

	*head= NULL;
}


//打印
void linklist_display(linklist *head)
{
	linklist *p = head->next;

	//----------------------------------------
	while(p!=head)
	{
		printf("%d ", p->data);

		p=p->next;
	}

	puts("");
}


//逆序（头插法）
void linklist_nixu(linklist *head)
{
	linklist *p = head->next;

	linklist *q = NULL;
	
	//-------------------------------
	head->next = head;

	//-------------------------------
	while(p != head)
	{	
		q = p->next;

		p->next = head->next;
	
		head->next = p;

		p = q;
	}

}

（四）循环双链表

typedef int data_t;

typedef struct node{
	data_t data;
	struct node *next;    //保存下一个结点的地址
	struct node *prior;   //保存上一个结点的地址
}dlinklist;

dlinklist *createDlinklist()
{
	dlinklist *head = (dlinklist *)malloc(sizeof(dlinklist));
	if(NULL == head)
	{
		perror("malloc");
		return NULL;
	}

	//-----------------------------------------
	head->next = head;
	head->prior = head;

	return head;
}

int dlinklist_is_empty(dlinklist *head)
{
	return (head->next == head->prior )?1:0;
}

int dlinklist_length(dlinklist *head)
{
	dlinklist *p = head->next;

	int num = 0;
	//--------------------------------
	while(p != head)
	{
		num++;
		p=p->next;
	}
	return num;
}

//按位置插入
int dlinklistInsertByPos(dlinklist *head, int pos, data_t data)
{
	int len = dlinklist_length(head);

	if(pos < 0)
		return -1;
	//-------------------------------------
	pos=pos%(len+1);

	dlinklist *new = (dlinklist *)malloc(sizeof(dlinklist));
	if(NULL == new)
	{
		perror("malloc");
		return -1;
	}

	new->data = data;
	new->next = NULL;
	new->prior = NULL;

	//找到pos位置的前一个结点
	dlinklist *p = head;
	while(pos--)
	{
		p=p->next;
	}

	//------------------------------------
	new->next = p->next;
	new->prior = p;
	
	p->next = new;
	new->next->prior = new; 
	

	return 0;
}

//按位置删除
int dlinklistDeleteByPos(dlinklist *head, int pos)
{
	if(dlinklist_is_empty(head))
		return -1;

	int len = dlinklist_length(head);
	if(pos < 0)
		return -1;
	
	pos = pos%len;

	//找到pos位置的前一个结点
	dlinklist *p = head;
	while(pos--)
	{
		p=p->next;
	}

	dlinklist *q = p->next;

	
	p->next = q->next;

	q->next->prior = p;

	free(q);
	
	q = NULL;

}

//按位置查找节点
data_t dlinklistFindByPos(dlinklist *head, int pos)
{

	if(dlinklist_is_empty(head))
		return -1;

	int len = dlinklist_length(head);
	if(pos < 0)
		return -1;
	
	pos = pos%len;
	dlinklist *p = head->next;

	while(pos--)
	{
		p=p->next;
	}

	return p->data;
}


//按位置修改节点
int dlinklistChangeByPos(dlinklist *head, int pos , data_t data)
{
	if(dlinklist_is_empty(head))
		return -1;

	int len = dlinklist_length(head);
	if(pos < 0)
		return -1;
	
	pos = pos%len;


	dlinklist *p = head->next;

	while(pos--)
	{
		p=p->next;
	}

	p->data = data;

	return 0;
}


//按值查找节点
int dlinklistFindByData(dlinklist *head, data_t data)
{
	if(dlinklist_is_empty(head))
		return -1;

	dlinklist *p = head->next;

	int i = 0;

	//-----------------------------------
	while(p != head)
	{
		if(p->data == data)
		{
			return i;
		}
		i++;
		p=p->next;
	}

	printf("没有这个值!\n");

	return -1;
}


//按值删除节点
int dlinklistDeleteByData(dlinklist *head, data_t data)
{
	int pos = dlinklistFindByData(head, data);

	dlinklistDeleteByPos(head, pos);

	return 0;
}

//按值修改节点
int dlinklistChangeByData(dlinklist *head, data_t old, data_t new)
{
	int pos = dlinklistFindByData(head, old);
	
	dlinklistChangeByPos(head, pos, new);

	return 0;
}

//清空链表
int dlinklistClear(dlinklist *head)
{
	if(dlinklist_is_empty(head))
		return -1;

	dlinklist *p = head->next;

	//----------------------------
	head->next = head;

	dlinklist *q = NULL;

	//-----------------------------
	while(p != head)
	{
		q = p->next;
	
		free(p);

		p=NULL;

		p = q;
	}

	return 0;
}



//销毁链表
void dlinklistDestory(dlinklist **head)
{
	dlinklistClear(*head);

	free(*head);

	*head = NULL;
}


//链表逆序（头插法）
void dlinklistNixu(dlinklist *head)
{
	dlinklist *p = head->next;

	//-----------------------------
	head->next = head;

	dlinklist *q = NULL;

	//-------------------------------
	while(p != head)
	{
		q = p->next;

		p->next = head->next;

		//----------------------------------
		//if(p->next != head) //第一次循环的时候，没有这根线
		p->next->prior = p;

		head->next = p;

		p->prior = head;

		p = q;
	}
}


//打印
void dlinklist_display(dlinklist *head)
{
	if(dlinklist_is_empty(head))
		return;

	dlinklist *p = head->next;

	//-----------------------
	while(p != head)
	{
		printf("%d ", p->data);
		p=p->next;
	}

	puts("");
}

（五）无头单链表

typedef struct node{
    int data;
    struct node *next;
}nhlinklist;
//初始化
nhlinklist *nhlinklist_create(void){
    nhlinklist *p = (nhlinklist *)malloc(sizeof(nhlinklist));
    if(p == NULL){
        printf("malloc fail\n");
        return NULL;
    }
    printf("input the firstdata:");
    scanf("%d",&p->data);
    p->next = NULL;
    return p;
}
//判空
int nhlinklist_ifnull(nhlinklist *phead){
    return (phead == NULL)?-1:0;
}
//求表长
int nhlinklist_length(nhlinklist *phead){
    int i = 0;
    while(phead != NULL){
        phead = phead->next;
        i++;
    }
    return i;
}
//判断位置是否合法
int pos_iferror(nhlinklist *phead,int pos){
    int len = nhlinklist_length(phead);
    if(pos < 0 || pos >= len){
        printf("pos error\n");
        return -1;
    }
    return 0;
}
//按位置查找节点位置
nhlinklist *nhlinklist_findbypos(nhlinklist *phead,int pos){
    if(nhlinklist_ifnull(phead) == -1 || pos_iferror(phead,pos) == -1){
        return NULL;
    }
    nhlinklist *p = phead;
    while(pos--){
        p = p->next;
    }
    return p;
}
//按位置添加节点
int nhlinklist_addbypos(nhlinklist **phead,int pos,int data){
    if(pos != nhlinklist_length(*phead)){
        if(pos_iferror(*phead,pos) == -1){
            return -1;
        }
    }
    nhlinklist *p = *phead;
    nhlinklist *new = (nhlinklist *)malloc(sizeof(nhlinklist));
    new->data = data;
    //在头部添加节点
    if(pos == 0){
        new->next = *phead;
        *phead = new;
        return 0;
    }
    //在其他位置添加节点，找前一节点位置
    pos--;
    while(pos--){
        p = p->next;
    }
    new->next = p->next;
    p->next = new;
    return 0;
}
//按位置删除节点
int nhlinklist_delbypos(nhlinklist **phead,int pos){
    if(nhlinklist_ifnull(*phead) == -1 || pos_iferror(*phead,pos) == -1){
        return -1;
    }
    nhlinklist *p = *phead;
    //删除头部节点
    if(pos == 0){
        nhlinklist *del = *phead;
        *phead = del->next;
        free(del);
        del = NULL;
        return 0;
    }
    //在其他位置删除节点
    pos--;
    while(pos--){
        p = p->next;
    }
    nhlinklist *q = p->next;
    p->next = q->next;
    free(q);
    q = NULL;
    return 0;
}
//按位置修改节点
int nhlinklist_changebypos(nhlinklist *phead,int pos,int data_ch){
    nhlinklist *p = nhlinklist_findbypos(phead,pos);
    if(p == NULL){
        return -1;
    }
    p->data = data_ch;
    return 0;
}
//按值查找节点
nhlinklist *nhlinklist_findbydata(nhlinklist *phead,int data){
    if(nhlinklist_ifnull(phead) == -1){
        return NULL;
    }
    nhlinklist *p = phead;
    while(p != NULL && p->data != data){
        p = p->next;
    }
    if(p == NULL){
        printf("data error\n");
        return NULL;
    }
    return p;
}
//按值添加节点
int nhlinklist_addbydata(nhlinklist **phead,int data,int data_ch){
    nhlinklist *p = *phead;
    //在头部添加节点
    if(p->data == data){
        nhlinklist *new = (nhlinklist *)malloc(sizeof(nhlinklist));
        new->data = data_ch;
        new->next = p;
        *phead = new;
        return 0;
    }
    //在其他位置添加节点
    nhlinklist *q = p->next;
    while(q != NULL && q->data != data){
        q = q->next;
        p = p->next;
    }
    if(q == NULL){
        printf("data error\n");
        return -1;
    }
    nhlinklist *new = (nhlinklist *)malloc(sizeof(nhlinklist));
    new->data = data_ch;
    new->next = p->next;
    p->next = new;
    return 0;
}
//按值删除节点
int nhlinklist_delbydata(nhlinklist **phead,int data){
    if(nhlinklist_ifnull(*phead) == -1){
        return -1;
    }
    nhlinklist *p = *phead;
    //删除头节点
    if(p->data == data){
        *phead = p->next;
        free(p);
        p = NULL;
        return 0;
    }
    //删除其他位置节点
    nhlinklist *q = p->next;
    while(q != NULL && q->data != data){
        q = q->next;
        p = p->next;
    }
    if(q == NULL){
        printf("data error\n");
        return -1;
    }
    p->next = q->next;
    free(q);
    q = NULL;
    return 0;
}
//按值修改节点
int nhlinklist_changebydata(nhlinklist *phead,int data,int data_ch){
    nhlinklist *p = nhlinklist_findbydata(phead,data);
    if(p == NULL){
        return -1;
    }
    p->data = data_ch;
    return 0;
}
//清空链表（销毁）
void nhlinklist_clear(nhlinklist **phead){
    nhlinklist *p = *phead;
    nhlinklist *q = NULL;
    while(p->next != NULL){
        q = p->next;
        p->next = q->next;
        free(q);
        q = NULL;
    }
    free(*phead);
    *phead = NULL;
}
//打印链表
void nhlinklist_show(nhlinklist *phead){
    nhlinklist *p = phead;
    while(p != NULL){
        printf("%d ",p->data);
        p = p->next;
    }
    puts("");
}
//逆序
void nhlinklist_nixu(nhlinklist **phead){
    if(nhlinklist_length(*phead)<=1){
        return;
    }
    nhlinklist *e = *phead;
    nhlinklist *p = e->next;
    nhlinklist *q = p->next;
    p->next = e;
    e->next = NULL;
    while(q != NULL){
        e->next = q->next;
        q->next = p;
        p = q;
        q = e->next;
    }
    *phead = p;
}

三、栈

（一）顺序栈

#define SIZE 100

typedef int data_t;

typedef struct list{
	data_t data[SIZE];
	int top; //栈顶的下标
}seqstack;

//创建
seqstack *createSeqstack()
{
	seqstack *seq = (seqstack *)malloc(sizeof(seqstack));
	if(seq == NULL)
	{
		perror("malloc");
		return NULL;
	}

	memset(seq->data, 0, sizeof(data_t)*SIZE);
	//bzero(seq->data, sizeof(data_t)*SIZE);

	seq->top = -1;

	return seq;
}

//判空
int seqstack_is_empty(seqstack *seq)
{
	return (seq->top == -1)?1:0;
}

//判满
int seqstack_is_full(seqstack *seq)
{
	return (seq->top == SIZE-1)?1:0;
}


//求长度
int seqstack_length(seqstack *seq)
{
	return seq->top+1;
}

//入栈
int seqstack_in(seqstack *seq, data_t data)
{
	if(seqstack_is_full(seq))
		return -1;

	seq->data[seq->top+1] = data;

	seq->top++;

	return 0;
}

//出栈
data_t seqstack_out(seqstack *seq)
{
	if(seqstack_is_empty(seq))
		return -1;

	data_t temp = seq->data[seq->top];

	seq->top--;

	return temp;
}

//清空
void seqstack_clear(seqstack *seq)
{
	seq->top = -1;
}

//销毁
void seqstack_destory(seqstack **seq)
{
	free(*seq);
	*seq = NULL;
}

//打印
void seqstack_display(seqstack *seq)
{
	int i;
	for(i=0; i<=seq->top; i++)
	{
		printf("%d ", seq->data[i]);
	}
	puts("");
}

（二）链栈

typedef int data_t;

typedef struct node{
	data_t data;
	struct node *next;
}lstack;

//创建
lstack *createLstack()
{
	lstack *head = (lstack *)malloc(sizeof(lstack));
	if(head == NULL)
	{
		perror("malloc");
		return NULL;
	}
	
	head->next = NULL;

	return head;
}


//判空
int lstack_is_empty(lstack *head)
{
	return (head->next == NULL)?1:0;
}

//表长
int lstack_length(lstack *head)
{
	lstack *p = head->next;

	int len = 0;
	while(p!=NULL)
	{
		len++;

		p=p->next;
	}
	return len;
}

//入栈 - 头插
int lstack_in(lstack *head, data_t data)
{
	lstack *new = (lstack *)malloc(sizeof(lstack)) ;
	if(new == NULL)
	{
		perror("malloc new");
		return -1;
	}

	new->data = data;
	new->next = NULL;
	
	new->next = head->next;

	head->next = new;

	return 0;
}


//出栈
data_t lstack_out(lstack *head)
{
	if(lstack_is_empty(head))
		return -1;

	lstack *p = head->next;

	data_t m = p->data;

	head->next = p->next;

	free(p);

	p=NULL;

	return m;
}



//清空
void lstack_clear(lstack *head)
{
	lstack *p = head->next;

	lstack *q = NULL;

	head->next = NULL;

	while(p!=NULL)
	{
		q = p->next;

		free(p);

		p= NULL;

		p=q;
	}
}

//销毁
void lstack_destory(lstack **head)
{
	lstack_clear(*head);

	free(*head);
	*head=NULL;
}


//打印
void lstack_dispaly(lstack *head)
{
	lstack *p = head->next;

	while(p!=NULL)
	{
		printf("%d ", p->data);

		p=p->next;
	}

	puts("");
}

四、队列

（一）顺序队列

//顺序循环队列

#define SIZE 100

typedef int data_t;

typedef struct list{
	data_t data[SIZE];
	int front; //队头元素的下标
	int rear;  //队尾元素的下一个位置的下标
}squeue;


//创建
squeue *createSqueue()
{
	squeue *sq = (squeue *)malloc(sizeof(squeue));
	if(sq == NULL)
	{
		perror("malloc squeue");
		return NULL;
	}

	memset(sq->data, 0, sizeof(data_t)*SIZE);

	sq->front = sq->rear = 0;

	return sq;
}

//判空
int squeue_is_empty(squeue *sq)
{
	return (sq->front == sq->rear)?1:0;
}

//判满
int squeue_is_full(squeue *sq)
{
	return ((sq->rear+1)%SIZE == sq->front)?1:0;
}


//表长
int squeue_length(squeue *sq)
{
	if(squeue_is_empty(sq))
		return 0;
	
	return (sq->rear-sq->front+SIZE)%SIZE;
}

//入队
int squeue_in(squeue *sq,data_t data)
{
	if(squeue_is_full(sq))	
		return -1;

	sq->data[sq->rear] = data;

	sq->rear = (sq->rear+1)%SIZE;

	return 0;
}

//出队
data_t squeue_out(squeue *sq)
{
	if(squeue_is_empty(sq))	
		return -1;

	data_t m =  sq->data[sq->front];

	sq->front = (sq->front+1)%SIZE;

	return m;
}

//清空
void squeue_clear(squeue *sq)
{
	sq->front = sq->rear;
}

//销毁
void squeue_destory(squeue **sq)
{
	free(*sq);

	*sq = NULL;
}

//打印
void squeue_display(squeue *sq)
{
	int temp = sq->front;

	while(temp < sq->rear)
	{
		printf("%d ", sq->data[temp]);

		temp = (temp+1)%SIZE;
	}

	puts("");
}

（二）链式队列

typedef int data_t;

//节点的结构体
typedef struct node{
	data_t data;
	struct node *next;
}linklist;

//管理节点的结构体
typedef struct queue{
	linklist *front; //指向队头节点的前一个位置
	linklist *rear;  //指向队尾节点的位置
}lqueue;

//创建
lqueue *createLqueue()
{
	lqueue *lq = (lqueue *)malloc(sizeof(lqueue));
	if(lq == NULL)
	{
		perror("malloc lqueue");
		return NULL;
	}

	//lq->front 相当于 head
    lq->front = (linklist *)malloc(sizeof(linklist));

	lq->rear = lq->front;

	lq->front->next = NULL;
	
	return lq;
}


//判空
int lqueue_is_empty(lqueue *lq)
{
	return (lq->front == lq->rear)?1:0;
}

//表长
int lqueue_length(lqueue *lq)
{
	linklist *p = lq->front->next;

	int len = 0;
	while(p!=NULL)
	{
		len++;

		p=p->next;
	}

	return len;
}


//入队
int lqueue_in(lqueue *lq, data_t data)
{
	linklist *new = (linklist *)malloc(sizeof(linklist));
	if(new ==NULL)
	{
		perror("malloc new");
		return -1;
	}

	new->data = data;
	new->next = NULL;


	lq->rear->next = new;

	lq->rear = new;

	return 0;
}



//出队
data_t lqueue_out(lqueue *lq)
{
	if(lqueue_is_empty(lq))
		return NULL;
	
	linklist *p = lq->front->next;

	data_t m = p->data;

	lq->front->next = p->next;
	
	if(lq->front->next == NULL)
		lq->rear = lq->front;

	free(p);

	p=NULL;
	

	return m;
}


//清空
void lqueue_clear(lqueue *lq)
{
	if(lqueue_is_empty(lq))
		return ;

	linklist *p = lq->front->next;

	lq->front->next = NULL;

	lq->rear = lq->front;

	linklist *q = NULL;

	while(p!=NULL)
	{
		q= p->next;

		free(p);

		p=NULL;

		p = q;
	}
}

//销毁
void lqueue_destory(lqueue **lq)
{
	lqueue_clear(*lq);

	free((*lq)->front);

	//*lq->front = NULL;

	free(*lq);

	*lq=NULL;
}

//打印
/*
void lqueue_display(lqueue *lq)
{
	linklist *p = lq->front->next;

	while(p!=NULL)
	{
		printf("%d ", p->data);

		p=p->next;
	}
	
	puts("");
}

五、树

完全二叉树

typedef int data_t;

typedef struct Tree{
	data_t data;
	struct Tree *lchild;
	struct Tree *rchild;
}tree;

//节点的编号i， 节点的个数n
tree *createTree(int i, int n)
{
	tree *root = (tree *)malloc(sizeof(tree));
	if(root == NULL)
	{
		perror("malloc tree");
		return NULL;
	}

	root->data = i;

	//2*i <= n  左孩子
	if(2*i <= n)
	{
		root->lchild = createTree(2*i, n);
	}
	else{
		root->lchild = NULL;
	}

	//2*i+1 <= n 右孩子
	if(2*i+1 <= n)
	{
		root->rchild = createTree(2*i+1, n);
	}
	else{
		root->rchild = NULL;
	}

	return root;
}

//先序遍历
void xianxu(tree *root)
{
	if(root == NULL)
		return;
	
	printf("%d ", root->data);
	xianxu(root->lchild);
	xianxu(root->rchild);
}


//中序遍历
void zhongxu(tree *root)
{
	if(root == NULL)
		return;
	
	zhongxu(root->lchild);
	printf("%d ", root->data);
	zhongxu(root->rchild);
}


//后序遍历
void houxu(tree *root)
{
	if(root == NULL)
		return;
	
	houxu(root->lchild);
	houxu(root->rchild);
	printf("%d ", root->data);
}

//层次遍历
void level(tree *root)
{
	if(root == NULL)
		return;

	//定义队列：静态分配 指针数组
	tree *queue[100] = {NULL};

	//初始化 front = rear = 0
	int front,rear;
	front = rear = 0;

	//根节点入队
	queue[rear++] = root;

	while(rear != front)
	{
		//节点出队
		tree *p = queue[front++];

		//访问该节点
		printf("%d ", p->data);

		//其左右儿子入队
		if(p->lchild != NULL)
		{
			queue[rear++] = p->lchild;
		}
		
		if(p->rchild != NULL)
		{
			queue[rear++] = p->rchild;
		}
	}
}