数据结构DAY

 任意位置修改

 按元素查找

 按元素修改 

按元素插入 

 按元素删除

 逆置

头文件

#ifndef __1HEAD_H__
#define __1HEAD_H__



#include <stdio.h>
#include <string.h>
#include <stdlib.h>


typedef int datatype;
//带头节点结构定义
typedef struct Node
{
	//数据域
	union{
		int len;//头节点数据域
		datatype data;//普通节点的数据域
	};
	//指针域：下一个节点的地址
	struct Node *next;
}*Linklist;


Linklist create_node(int flag);
int insert_head(Linklist L,datatype e);
void output(Linklist L);
Linklist insert_rear(Linklist L,datatype e,Linklist rear);
int delete_head(Linklist L);
int delete_rear(Linklist L);
int insert_pos(Linklist L,int pos,datatype e);
int delete_pos(Linklist L,int pos);
int update_pos(Linklist L,int pos,datatype e);
datatype search_pos(Linklist L,int pos);
int search_data(Linklist L,datatype e);
int update_data(Linklist L,datatype e,datatype key);
int insert_data(Linklist L,datatype e,datatype key);
int delete_data(Linklist L,datatype e);
void rev_linklist(Linklist L);

#endif

定义函数

#include "1head.h"

/*
 * function:    创建节点
 * @param [ in] 
 * @param [out] 
 * @return      成功返回首地址，失败返回NULL
 */

Linklist create_node(int flag)
{
	Linklist L = (Linklist)malloc(sizeof(struct Node));
		if(NULL == L)
			return NULL;
	//对L进行初始化
	//对数据域清零
	if(1 == flag)
		L->len = 0;
	else if(0 == flag)
		L->data = 0;
	//对L的指针域指向NULL
	L->next = NULL;
}

/*
 * function:    链表头插
 * @param [ in] 
 * @param [out] 链表头节点，插入的值
 * @return      成功返回0，失败返回-1
 */

int insert_head(Linklist L,datatype e)
{
	//头节点是否创建成功
	if (NULL == L)
	{
		puts("头节点创建失败");
		return -1;
	}
	//创建节点s
	Linklist s = create_node(0);
	if (NULL == s)
	{
		puts("节点创建失败");
		return -1;
	}
	//s的数据域赋值
	s->data = e;
	//s的指针域赋值
	s->next = L->next;
	L->next = s;
	L->len++;
	return 0;
}

/*
 * function:    链表输出
 * @param [ in] 
 * @param [out] 链表
 * @return      无
 */

void output(Linklist L)
{
	//判断头节点是否创建成功
	//判断链表是否为空
	if(NULL == L || L->next == NULL)
		return;
	Linklist p = L;
/*	for (int i = 0; i < L->len; i++)
	{
		p = p->next;
		printf("%d\t",p->data);
	}
*/	while(p->next!=NULL)
	{
		p = p->next;
		printf("%d\t",p->data);
	}
	puts("");
}

/*
 * function:    链表尾插
 * @param [ in] 
 * @param [out] 头节点，插入的值，尾节点地址
 * @return      成功返回尾节点地址
 */

Linklist insert_rear(Linklist L,datatype e,Linklist rear)
{
	//判断头节点是否创建成功
	if (NULL == L)
		return NULL;
	Linklist s = create_node(0);
	if (NULL == s)
		return NULL;
	s->data = e;
	rear->next = s;
	rear = s;
	L->len++;
	return rear;
}

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 链表
 * @return      成功返回0，失败返回-1
 */

int delete_head(Linklist L)
{
	if(NULL == L || NULL == L->next)
		return -1;
	Linklist q = L->next;
	L->next = q->next;
	free(q);
	q = NULL;
	L->len--;
	return 0;
}

/*
 * function:    尾删
 * @param [ in] 
 * @param [out] 链表
 * @return      成功返回0，失败返回-1
 */

int delete_rear(Linklist L)
{
	//判断头节点是否创建成功
	//判断链表是否为空
	if (NULL == L || NULL == L->next)
		return -1;
	Linklist p = L;
	//尾删
	//循环到倒数第二个节点
	while (p->next->next!=NULL)
	{
		p = p->next;
	}
	//删除p->next
	free(p->next);
	p->next = NULL;
	L->len--;
	return 0;
}

/*
 * function:    任意位置插入
 * @param [ in] 
 * @param [out] 链表，位置，值
 * @return      成功返回0，失败返回-1
 */

int insert_pos(Linklist L,int pos,datatype e)
{
	if(NULL == L || pos < 1 || pos > L->len-1)
		return -1;
	Linklist p = L;
	for (int i = 0; i < pos-1; i++)
	{
		p = p->next;
	}
	Linklist s = create_node(0);
	s->data = e;
	s->next = p->next;
	p->next = s;
	L->len++;
	return 0;
}

/*
 * function:    任意位置删除
 * @param [ in] 
 * @param [out] 链表，位置
 * @return      成功返回0，失败返回-1
 */

int delete_pos(Linklist L,int pos)
{
	if (NULL == L || pos < 1 || pos > L->len)
		return -1;
	Linklist p = L;
	for (int i = 0; i < pos-1; i++)
	{
		p = p->next;
	}
	Linklist q = p->next;
	p->next = q->next;
	free(q);
	q = NULL;
	return 0;
}

/*
 * function:    任意位置修改
 * @param [ in] 
 * @param [out] 链表，位置，修改的值
 * @return      成功返回0，失败返回-1
 */

int update_pos(Linklist L,int pos,datatype e)
{
	if (NULL == L || pos < 1 || pos > L->len)
		return -1;
	Linklist p = L;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	p->data = e;
	return 0;
}

/*
 * function:    按位置查找
 * @param [ in] 
 * @param [out] 链表，位置
 * @return      成功返回查找位置的值，失败返回-1
 */

datatype search_pos(Linklist L,int pos)
{
	if (NULL == L || pos < 1 || pos > L->len)
		return -1;
	Linklist p = L;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	datatype e = p->data;
	return e;

}

/*
 * function:    按元素查找
 * @param [ in] 
 * @param [out] 链表，元素
 * @return      成功返回查找元素的位置
 */

int search_data(Linklist L,datatype e)
{
	if(NULL == L || NULL == L->next)
		return -1;
	Linklist p = L;
	int pos = 0;
	while (p->next!=NULL)
	{
		p = p->next;
		pos++;
		if(e == p->data)
			return pos;
	}
	return -1;
}

/*
 * function:    按元素修改
 * @param [ in] 
 * @param [out] 链表，查找元素，修改的值
 * @return      
 */

int update_data(Linklist L,datatype e,datatype key)
{
	if (NULL == L || NULL == L->next)
	{ 	puts("输入错误");
		return -1;
	}
	Linklist p = L;
	while (p->next!=NULL)
	{
		p = p->next;
		if(e == p->data)
			p->data = key;
	}
	return -1;
}

/*
 * function:    按元素插入
 * @param [ in] 
 * @param [out] 链表，查找元素，插入的元素
 * @return      
 */

int insert_data(Linklist L,datatype e,datatype key)
{
	int pos = search_data(L,e);
	if (pos == -1)
	{
		puts("修改错误");
		return -1;
	}
	else
		insert_pos(L,pos,key);
	return 0;
}

/*
 * function:    按元素删除
 * @param [ in] 
 * @param [out] 链表，要删除的元素
 * @return      
 */

int delete_data(Linklist L,datatype e)
{
	int pos = search_data(L,e);
	if (pos == -1)
	{
		puts("错误");
		return -1;
	}
	else
		delete_pos(L,pos);
	return 0;
}

/*
 * function:    单链表逆置
 * @param [ in] 
 * @param [out] 链表
 * @return      
 */

void rev_linklist(Linklist L)
{
	if(NULL == L || NULL == L->next)
		return;
	Linklist p = L->next;
	L->next = NULL;
	while(p!=NULL)
	{
		Linklist t = p;
		p = p->next;
		t->next = L->next;
		L->next = t;
	}
}

 主函数

#include "1head.h"

int main(int argc, const char *argv[])
{
	//1表示头节点，0表示普通节点
	Linklist L = create_node(1);
	int n;
	datatype e;
	Linklist rear = L;
	printf("请输入n的值：");
	scanf("%d",&n);
/*	for (int i = 0; i < n; i++)
	{
		printf("请输入插入的值：");
		scanf("%d",&e);
		insert_head(L,e);
	}

	//尾插
*/	for (int i = 0; i < n; i++)
	{
		printf("请输入插入的值：");
		scanf("%d",&e);
		rear = insert_rear(L,e,rear);
	}
	output(L);
	//头删
/*	delete_head(L);
	delete_head(L);
	delete_head(L);
	puts("头删");
	output(L);
*/
	//尾删
/*	delete_rear(L);
	delete_rear(L);
	delete_rear(L);
	output(L);
*/
	//按位置插入
#if 0
	int pos;
	printf("请输入插入的位置：");
	scanf("%d",&pos);
	printf("请输入插入的值：");
	scanf("%d",&e);
	insert_pos(L,pos,e);
	output(L);
#endif
#if 0
	//按任意位置删除
	int pos;
	printf("请输入删除的位置：");
	scanf("%d",&pos);
	delete_pos(L,pos);
	output(L);

#endif
#if 0
	//按任意位置修改
	int pos;
	printf("请输入修改的位置：");
	scanf("%d",&pos);
	printf("请输入修改的值：");
	scanf("%d",&e);
	update_pos(L,pos,e);
	output(L);
#endif	
#if 0
	//按任意位置查找
	int pos;
	printf("请输入查找的位置：");
	scanf("%d",&pos);
	e = search_pos(L,pos);
	printf("查找的位置对应的元素为：%d\n",e);
#endif	

#if 0
	//按元素查找
	printf("请输入查找的元素：");
	scanf("%d",&e);
	int pos = search_data(L,e);
	if(pos == -1)
		printf("查找失败\n");
	else
		printf("查找的元素对应的位置为：%d\n",pos);
#endif	
#if 0
	//按元素修改
	datatype key = 0;
	printf("请输入查找的元素：");
	scanf("%d",&e);
	printf("请输入修改的元素：");
	scanf("%d",&key);
	update_data(L,e,key);
	output(L);
#endif
#if 0
	//按元素插入
	datatype key = 0;
	printf("请输入查找的元素：");
	scanf("%d",&e);
	printf("请输入插入的元素：");
	scanf("%d",&key);
	insert_data(L,e,key);
	output(L);
#endif	
#if 0
	//按元素删除
	printf("请输入删除的元素：");
	scanf("%d",&e);
	delete_data(L,e);
	output(L);
#endif	
#if 1
	//单链表逆置
	rev_linklist(L);
	printf("逆置后链表为：\n");
	output(L);
#endif	
	return 0;
}