DS--H22_LinkList_NoHead

测试数据

*建议测试数据直接复制粘贴，不要粘贴多余的符号或者空格*

# 1.链表初始化
初始化成功(#^.^#)
单链表是否为空？是
# 2.创建单链表
### 2.1头插法
需要键盘输入：3 2 1 zj202211681023 #
将会显示：zj202211681023 1 2 3
显示表长为4
### 2.2尾插法
需要键盘输入：4 5 6 7 8 3 #
将会显示整个单链表：zj202211681023 1 2 3 4 5 6 7 8 3
显示表长为10
# 3.遍历（打印）单链表
# 4.按值查找位置
### 4.1 按值查找3的位序
输出为：4
### 4.2 按值查找100的位序
输出为：0
# 5.按位查找值
分别取第1个节点
输出为：zj202211681023
第8个结点
输出为：7
分别取第100个结点和第0个结点，均不合法！！

# 返回指针式查找
（返回指针式）查找找到3
（返回指针式）查找没有找到100
（返回指针式）第一个结点为：zj202211681023
（返回指针式）第8个结点为：7
（返回指针式）查找第100个结点位置不合法

# 6.删除第7个节点
打印该链表如下：
zj202211681023 1 2 3 4 5 7 8 3
此时表长为9
# 7.在第7个结点之前插入6，恢复为初始单链表
打印该链表如下：
zj202211681023 1 2 3 4 5 6 7 8 3
此时表长为10
# 8.置空前后
置空前单链表长度:10
单链表是否为空？否
置空了哈。。。
置空后单链表长度:0
单链表是否为空？是
# 9.释放
终于写到释放了┭┮﹏┭┮
完工！！！！！！！(#^.^#)

。h

#pragma once
#include <iostream>
#include <string>
using namespace std;

typedef string ElemType;
typedef int Status;
typedef struct LNode {
	ElemType data;//字符串类型的
	LNode* next;
} LNode, * LinkList;// 定义指向LNode结构体的指针别名为LinkList

bool InitList(LinkList& L);//初始化单链表
Status CreateList_H(LinkList& L);//头插法
void ListTraverse(LinkList& L);//遍历打印
Status ListLength(const LinkList& L);//求表长
Status CreateList_R(LinkList& L);//尾插法
Status LocateElem(LinkList L, ElemType& e);//按值查找次序
Status GetElem(LinkList L, int i, ElemType& e);//按位序查找值
//弱化位序后的按值和按位查找（返回指针）： LinkList  Find ( L, e ) 、LinkList  Locate (L, i )
LinkList Find(LinkList L, ElemType e);//按值查找
LinkList Locate(LinkList L, int i);//按位查找
Status ListDelete(LinkList& L, int i, ElemType& e);//删除第i个元素
Status ListInsert(LinkList& L, int i, ElemType e);//在第i个元素之前插入元素e
Status ListEmpty(const LinkList& L);//判断是否为空
void DestroyList(LinkList& L);//释放
void ClearList(LinkList& L);//置空
/*
*/

。cpp

#include "LList.h"
//初始化
bool InitList(LinkList& L)//初始化单链表
{
	L = new LNode;
	L = NULL;
	return true;
}
//头插法
Status CreateList_H(LinkList& L) {
	cout << "头插法：\n请输入单链表元素,输入#并按enter结束：";
	while (true) {
		LinkList p1 = new LNode;//创建一个新结点
		cin >> p1->data;
		if (p1->data == "#") {
			delete p1;
			break;
		}
		p1->next = L;//p1指针指向L
		L = p1;//L指针指向p1
	}
	return 0;
}
//遍历并打印
void ListTraverse(LinkList& L) {
	cout << "打印该链表如下：" << endl;
	LinkList p3 = L;//工作指针p3
	while (p3 != NULL) {
		cout << p3->data << ' ';
		p3 = p3->next;
	}
	cout << '\n';
}
//计算表长
Status ListLength(const LinkList& L) {
	int length = 0;//默认表长为0
	if (L == NULL)
		return length;
	LinkList p6 = L;//
	while (p6!=NULL) {
		p6 = p6->next;
		length++;
	}
	return length;
}
//尾插法
Status CreateList_R(LinkList& L) {
	if (L == NULL) {
		cout << "请输入第一个结点的值：";
		L = new LNode;
		cin >> L->data;
		L->next = NULL;//需要初始第一个结点的值
	}
	//cout << "请输入第一个结点的值：";
	//L = new LNode;
	//cin >> L->data;
	//L->next = NULL;//需要初始第一个结点的值
	LinkList t = L;//尾指针t指向了链表头指针L
	cout << "尾插法：\n请输入单链表元素，输入#并按enter结束：";
	while (t->next != NULL) {
		t = t->next;
	}//找到尾部，再从尾部插入
	while (true) {
		LinkList p2 = new LNode;
		cin >> p2->data;
		if (p2->data == "#") {
			delete p2;
			break;
		}
		p2->next = NULL;
		t->next = p2;//将新结点p2链接到链表尾部
		t = p2;//更新尾指针t为当下p2
	}
	return 0;
}
//按值查找位置
Status LocateElem(LinkList L, ElemType& e) {
	if (L == NULL) {
		cout << "链表为空" << endl;
		return 0;
	}
	int i = 1;//从第一个结点开始
	LinkList p4 = L ;//指向第一个结点
	while (p4 && p4->data != e) {//判断当前结点f
		p4 = p4->next;
		i++;//i为计数器
	}
	if (p4 != NULL)
		return i;
	else
		return 0;
}
//按位查值
Status GetElem(LinkList L, int i, ElemType& e) {
	if (L == NULL) {
		cout << "链表为空" << endl;
		return false;
	}
	LinkList p5 = L;
	int count = 1;//工作指针p5指向第一个结点
	while (p5 != NULL && count < i) {//逐个查找，找到第i个结点
		p5 = p5->next;
		count++;
	}
	if (p5==NULL || count > i) {//判断该结点的位置，超过表长或者查找位置在第一位之前
		return false;
	}
	else {
		e = p5->data;//将查找到的第i个元素赋值给e
		return true;
	}
}
//返回指针，按值查找
LinkList Find(LinkList L, ElemType e) {
	if (L == NULL)
		return NULL;
	LinkList p = L;//工作指针指向第一个结点
	while (p && p->data != e) {
		p = p->next;
	}
	return p;
}
//返回指针，按位查找
LinkList Locate(LinkList L, int i) {
	if (L == NULL)
		return NULL;
	LinkList pp = L;
	int j = 1;//
	while (pp && j < i) {
		pp = pp->next;
		j++;//找到第i个结点
	}
	if (pp == NULL || j > i) {
		return NULL;//
	}
	return pp;
}
//删除第i个结点
Status ListDelete(LinkList& L, int i, ElemType& e) {
	LinkList p7 = L;
	int j = 1;//p7指向第j个结点
	//让p7指向第i-1个结点
	while (p7 && j < i - 1) {
		p7 = p7->next;
		j++;
	}
	//i小于1或者大于表长
	if (j > i - 1 || !p7 || !p7->next)
		return false;
	LinkList q = p7->next;//q来接替第i个结点的指针域
	e = q->data;//e用来记录被删除结点的数据域 后面delete
	p7->next = q->next;//
	delete q;
}
//在第i个结点前插入一个新的结点
Status ListInsert(LinkList& L, int i, ElemType e) {
	LinkList p8 = L;
	int j = 1;//p8指向第j个结点
	//让p8指向第i-1个结点
	while (p8 && j < i - 1) {
		p8 = p8->next;
		j++;
	}
	//i小于1或者大于表长
	if (j > i - 1 || !p8)
		return false;
	LinkList s = new LNode;
	if (s == NULL) return false;
	s->data = e;//s拥有数据域
	s->next = p8->next;//倒着往上连进去，s连上第i个结点
	p8->next = s;//第i-1个结点连上s
	return true;
}
//判断是否为空
Status ListEmpty(const LinkList& L) {
	return L==NULL ? true : false;
}
//置空
void ClearList(LinkList& L) {
	L = NULL;
}
//释放啦~
void DestroyList(LinkList& L) {
	//
	while (L) {
		LinkList q = L;//
		L = L->next;
		delete L;//销毁头结点
		L = q;
	}
	L = NULL;
}
	
/*

*/

main

#include "LList.h"
int main() {
	LinkList L;
	if (InitList(L)) {
		cout << "初始化成功(#^.^#)" << endl;
		cout << "单链表是否为空？" << (ListEmpty(L) ? "是" : "否") << endl;
		//创建头插法
		CreateList_H(L);
		ListTraverse(L);
		cout << "此时表长为" << ListLength(L) << endl;
		//尾插法
		CreateList_R(L);
		ListTraverse(L);
		cout << "此时表长为" << ListLength(L) << endl;
		//按值查找位序
		ElemType e_search = "3";
		int res1 = LocateElem(L, e_search);
		cout << "查找第一个3的位序：" << res1 << endl;
		ElemType e_sear = "100";
		int res2 = LocateElem(L, e_sear);
		cout << "查找100的位序：" << res2 << endl;
		//按位查值
		ElemType r1;
		if (GetElem(L, 1, r1)) {
			cout << "单链表第1个结点为：" << r1 << endl;
		}
		else {
			cout << "取值位置不合法！" << endl;
		}
		ElemType r2;
		if (GetElem(L, 8, r2)) {
			cout << "单链表第8个结点为：" << r2 << endl;
		}
		else {
			cout << "取值位置不合法！" << endl;
		}
		ElemType r3;
		if (GetElem(L, 100, r3)) {
			cout << "单链表第100个结点为：" << r3 << endl;
		}
		else {
			cout << "取值位置不合法！" << endl;
		}
		ElemType r4;
		if (GetElem(L, 0, r4)) {
			cout << "单链表第0个结点为：" << r4 << endl;
		}
		else {
			cout << "取值位置不合法！" << endl;
		}
		//返回指针式的查找
		LinkList result1 = Find(L, e_search);
		if (result1)
			cout << "（返回指针式）查找找到" << e_search << endl;
		else
			cout << "（返回指针式）查找没有找到" << e_search << endl;
		LinkList result2 = Find(L, e_sear);
		if (result2)
			cout << "（返回指针式）查找找到" << e_sear << endl;
		else
			cout << "（返回指针式）查找没有找到" << e_sear << endl;
		//返回指针式的查找
		LinkList result3 = Locate(L, 1);
		if (result3)
			cout << "（返回指针式）第一个结点为：" << result3->data << endl;
		else
			cout << "（返回指针式）查找位置不合法" << endl;
		LinkList result4 = Locate(L, 8);
		if (result4)
			cout << "（返回指针式）第8个结点为：" << result4->data << endl;
		else
			cout << "（返回指针式）查找位置不合法" << endl;
		LinkList result5 = Locate(L, 100);
		if (result5)
			cout << "（返回指针式）第100个结点为：" << result5->data << endl;
		else
			cout << "（返回指针式）查找第100个结点位置不合法" << endl;
		//删除
		cout << "删除第7个结点" << endl;
		ElemType e_delete;
		ListDelete(L, 7, e_delete);
		ListTraverse(L);
		cout << "此时表长为" << ListLength(L) << endl;
		//插入
		cout << "在第7个结点之前插入6，恢复为初始单链表" << endl;
		ElemType e_insert = "6";
		ListInsert(L, 7, e_insert);
		ListTraverse(L);
		cout << "此时表长为" << ListLength(L) << endl;
		//打印置空前顺序表长度
		cout << "置空前单链表长度:" << ListLength(L) << endl;
		cout << "单链表是否为空？" << (ListEmpty(L) ? "是" : "否") << endl;
		//置空
		cout << "置空了哈。。。" << endl;
		ClearList(L);
		//打印置空后顺序表长度
		cout << "置空后单链表长度:" << ListLength(L) << endl;
		cout << "单链表是否为空？" << (ListEmpty(L) ? "是" : "否") << endl;
		//释放
		cout << "终于写到释放了┭┮﹏┭┮" << endl;
		DestroyList(L);
		cout << "完工！！！！！！！(#^.^#)" << endl;

		/*
		*/
	}
	else {
		cout << "初始化失败了┭┮﹏┭┮" << endl;
	}
	return 0;
}