单链表-C语言

// 单链表

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef int ElemType;

/*定义单链表结点类型*/
typedef struct LNode
{
	ElemType data;  // 数据域
	struct LNode* next;  // 指针域。next这个指针指向的结构体类型的结点
}lnode;

/*函数声明*/
// 创建
lnode* createList();  
// 输出
void outputList(lnode* lp); 
// getElemByIndex 按下标查找结点值
lnode* getElemByIndex(lnode* lp, int i);
// getIndexByElem 按值查找下标
int getIndexByElem(lnode* lp, int e);
// insertElem(lp, index, e) // 插入结点
lnode* insertElem(lnode* lp, int index, ElemType e);	
//  根据下标获取结点
lnode* getElem(lnode* lp, int index);
//  根据下标获取结点
lnode* delElem(lnode* lp, int index);
//  求表长
int lenList(lnode* lp);

int main(int argc, char** argv)
{
	// code
	int a;
	int index;  // 插入/删除的位置
	ElemType e;  // 要插入/删除的元素
	lnode* lp = NULL;

	// 初始化操作
	while (1)
	{
		printf("\n");
		printf("\n**************************\n");
		printf("==========================\n");
		printf("1. 创建单链表（尾插法）\n");
		printf("2. 查看单链表\n");
		printf("3. 按下标查找结点值\n");
		printf("4. 按值查找下标\n");
		printf("5. 插入结点操作\n");
		printf("6. 删除结点操作\n");
		printf("7. 求表长操作\n");
		printf("0. 退出\n");
		printf("请选择操作：");
		scanf("%d", &a);
		printf("\n==========================\n");
		printf("**************************\n");

		if (a == 0)
		{
			printf("=====程序结束=====\n");
			break;
		}

		switch (a)
		{
		case 1:
			lp = createList();
			break;
		case 2:
			outputList(lp);
			break;
		case 3:
			printf("请输入要查询元素的下标：");
			scanf("%d", &index);
			lnode* temp_lp = getElemByIndex(lp, index);
			if (temp_lp)
			{
				printf("下标为%d的元素为%d ", index, temp_lp->data);
			}
			else
			{
				printf("操作失败，请重新查询...");
			}
			break;
		case 4:
			printf("请输入要查询的元素：");
			scanf("%d", &e);
			index = getIndexByElem(lp, e);
			if (index || index == 0)
			{
				printf("元素为%d的下标为%d ", e, index);
			}
			else
			{
				printf("操作失败，请重新查询...");
			}
			break;
		case 5:
			printf("请输入要插入的结点下标：");
			scanf("%d", &index);
			printf("请输入要插入的结点元素：");
			scanf("%d", &e);
			lp = insertElem(lp, index, e);
			if (lp)
			{
				outputList(lp);
			}
			else
			{
				printf("操作失败，请重新查询...");
			}
			break;
		case 6:
			printf("请输入要删除的结点下标：");
			scanf("%d", &index);
			lp = delElem(lp, index);
			if (lp)
			{
				outputList(lp);
			}
			else
			{
				printf("操作失败...");
			}
			break;
		case 7:
			index = lenList(lp);
			printf("表长为：%d\n	", index);
			break;
		default:
			break;
		}
	}
	
	system("pause");
	return 0;
}

lnode* createList()
{
	int x, l;  // int类型的元素
	lnode* lp = (lnode*)malloc(sizeof(lnode));  // 创建头结点
	lnode* sp = NULL;
	lnode* rp = lp;  // r为表尾指针 声明一个指针指向头结点，用于遍历链表

	printf("请输入创建单链表的值（以回车间隔）：\n");
	for (int i = 0; i < 5; i++)
	{
		scanf("%d", &x);  // 输入结点的值

		/*由系统生成一个LNode型的结点，同时将该结点的起始位置赋给指针变量s*/
		sp = (lnode*)malloc(sizeof(lnode));  // 创建新的结点
		sp->data = x;  // 新结点的数据
		rp->next = sp;  // 每次将s所指的结点插在最末端
		rp = sp;  // r指向新的表尾结点
	}
	rp->next = NULL;  // 未结点指针置空
	return lp;
}

void outputList(lnode* lp)
{
	lnode* temp = lp->next;  // 将头结点的next赋给temp
	printf("单链表为：");
	while (temp)
	{
		printf("%d  ", temp->data);
		temp = temp->next;
	}
}

lnode* getElem(lnode* lp, int index)
{
	lnode* temp = lp->next;
	if (index == -1)  // 数据部分从0开始，则头结点为-1
	{
		return lp;
	}
	if (index < 0)
	{
		return NULL;  // 下标无效
	}
	for (int i = 0; i < index; i++)
	{
		if (temp)
		{
			temp = temp->next;
		}
		else
		{
			return NULL;
		}
	}
	return temp;
}

lnode* getElemByIndex(lnode* lp, int i)
{	
	lnode* temp = lp->next;  // temp 指向头结点的next，用于遍历
	if (i < 0)  // 下标无效
	{
		return NULL;
	}
	for (int j = 0; j < i; j++)
	{
		if (temp)
		{
			temp = temp->next;
		}
		else  // 下标无效， 溢出
		{
			return NULL;
		}
	}
	return temp;
}

lnode* insertElem(lnode* lp, int index, ElemType e)
{
	// 查找插入下标的前驱结点
	lnode* temp = getElem(lp, index - 1);

	if (!temp)
	{
		return NULL;  // 查找插入下标的前驱结点失败
	}

	// 插入操作
	lnode* s = (lnode*)malloc(sizeof(lnode));  // 新结点的存储空间
	s->data = e;  // 新结点的值
	s->next = temp->next;  // 新结点指向插入下标的下一结点
	temp->next = s;  // 插入下标的前驱结点指向新结点

	return lp;
}

int getIndexByElem(lnode* lp, ElemType e)
{
	int j = 0;
	lnode* temp = lp->next;  // temp 指向头指针的next，用于遍历
	while (temp && temp->data != e)
	{
		temp = temp->next;
		j++;
	}
	if (temp)
	{
		return j;
	}
	else
	{
		return NULL;  // 没有查到
	}
}

lnode* delElem(lnode* lp, int index)
{
	lnode* temp = getElem(lp, index - 1);  // 被删除结点下标的前驱结点
	lnode* delElemP = temp->next;  // 被删除的结点

	temp->next = delElemP->next;  // delElep的前驱结点指向后继结点，跳过delElemP结点
	free(delElemP);  // 释放结点的存储空间

	return lp;
}

int lenList(lnode* lp)
{
	int j = 0;
	lnode* temp = lp->next;
	while (temp)
	{
		temp = temp->next;
		j++;
	}
	return j;
}