数据结构-单链表

数据结构-单链表 2021/8/6 0:10

不带头结点的单链表

#include <iostream>
using namespace std;

typedef int ElemType;

typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode,*LinkList;
/*
* 单链表初始化
*/
bool InitList(LinkList &L)
{
	L = NULL;
	return true;
}
/*
* 单链表判空
*/
bool empty(LinkList L)
{
	return (L == NULL);
}

/*
* 按位序插入结点,头插法
*/

bool ListInsert(LinkList& L, int i, ElemType e)
{
	if (i < 1)
		return false;
	if (i == 1)//不带头结点的单链表，当在第一个位置插入时要特殊处理，因它没有上一个结点
	{
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;
		return true;
	}
	int j = 1;//当前是第几个结点
	LNode* p = L;//当前扫描到的结点
	if (p == NULL)
		return false;
	while (j < i - 1)
	{
		p = p->next;
		j++;
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)
		return false;
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

1.初始化：将链表指针指向NULL
2.判空：判断L是不是指向NULL
3.按位序插入结点：由于没有头结点，故在第一个位置插入的时候情况特殊，要特别列出

带头结点的单链表

#include <iostream>
using namespace std;

typedef int ElemType;

typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, *LinkList;
/*
* 初始化单链表
*/
bool InitList(LinkList& L)
{
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)
		return false;//内存不足分配失败
	L->next = NULL;
	return true;
}
/*
* 判断单链表是否为空
*/
bool Empty(LinkList L)
{
	if (L->next == NULL)
		return true;
	else
		return false;
}
/*
* 按位序查找,通过判断返回值是否为NULL可以知道是否成功
*/
LNode* GetElem(LinkList L, int i)
{
	if (i < 0)
		return NULL;
	LNode* p = L;
	int j = 0;
	while (p != NULL && j < i)
	{
		p = p->next;
		j++;
	}
	return p;
}
/*
* 在给定的结点后插入结点
*/
bool InsertNextNode(LNode* p, ElemType e)
{
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (p == NULL || s == NULL)//防止内存不足，分配失败
		return false;
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
/*
* 按位序插入结点,后插法
*/
bool ListInsert(LinkList& L, int i, ElemType e)
{
	if (i < 1)
		return false;
	LNode* p =GetElem(L,i-1);//找到第i-1个结点
	return InsertNextNode(p, e);
}

/*
* 在给定的结点前插入结点,不找该节点的前驱结点，很妙
*/
bool InsertPriorNode(LNode* p,ElemType e)
{
	if (p == NULL)
		return false;
	ElemType temp = p->data;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)
		return false;
	s->data = temp;
	s->next = p->next;
	p->data = e;
	p->next = s;
	return true;
}
/*
* 按位序删除,删除i位置的结点
*/
bool ListDelete(LinkList &L, int i,ElemType e)
{
	if (i < 1)
		return false;
	LNode* p = GetElem(L,i-1);
	if (p == NULL || p->next == NULL)//i值不合法或者第i位置为空
	{
		return false;
	}
	LNode* q = p->next;
	p->next = q->next;
	e = q->data;
	free(q);
	return true;
}
/*
* 删除指定的结点，偷天换日法(当需要删除的结点是链表最后一个结点时无效，此时需要从头往后找)
*/
bool DeleteNode(LNode* p)
{
	if (p == NULL)
		return false;
	LNode* s= p->next;
	p->data = s->data;
	p->next = s->next;
	free(s);
	return true;
}

/*
* 按值查找
*/
LNode* LocateElem(LinkList L, ElemType e)
{
	LNode* p = L->next;
	while (p != NULL && p->data != e)
	{
		p = p->next;
	}
	return p;
}
/*
* 计算链表长度
*/
int Length(LinkList L)
{
	int len = 0;
	LNode* p=L;
	while (p->next != NULL)
	{
		p = p->next;
		len++;
	}
	return len;
}
/*
* 尾插法建立链表
*/
LinkList List_TailInsert(LinkList& L)
{
	LNode* r;
	r = L;
	ElemType temp;
	scanf_s("%d", &temp);
	while (temp!=9999)
	{
		LNode* s = (LNode*)malloc(sizeof(LNode));
		r->next = s;
		
		
		s->data = temp;
		r = s;
		r->next = NULL;
		scanf_s("%d", &temp);
	}
	return L;
}
/*
* 头插法建立链表
*/
LinkList List_HeadList(LinkList &L)
{
	ElemType temp;
	scanf_s("%d", &temp);
	L->next = NULL;
	while (temp != 9999)
	{
		LNode* p = (LNode*)malloc(sizeof(LNode));
		p->data = temp;
		p->next = L->next;
		L->next = p;
		scanf_s("%d", &temp);
	}
	return L;
}

int main()
{
	int e=0;
	LinkList L;
	InitList(L);
	//List_TailInsert( L);
	List_HeadList(L);
	LNode* p = L->next;
	for (int i = 0; i < Length(L); i++)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
	ListDelete(L, 1, e);
	p = L->next;
	for (int i = 0; i < Length(L); i++)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
	ListInsert(L, 2, 9961);
	ListInsert(L, 2, 9962);
	ListInsert(L, 2, 9963);
	p=L->next;
	for (int i = 0; i < Length(L); i++)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
	return 0;
}

1.初始化：声明头结点，将头结点的next指空
2.判空：判断头结点的next是否为空
3.按照位序查找：从头结点逐个往后找，声明int变量每往后移一次加一。
4.给定的结点后插入结点：声明一个结点，将需要插入的值赋给这个结点，完善结点之间的指向链接关系
5.按照位序插入结点（后插法）：首先按照位序找到第i-1个结点（3中函数），然后再在该结点后插入所要插入的结点（4中函数）
6.在给定的结点前插入结点：不用找该结点的前驱结点！！！直接偷天换日，用新节点保存当前结点的值，同时将当前结点的值换成需要插入的值即可
7.按位序删除结点：首先找到第i-1个结点（注意i值是否合法），改变结点减的链接关系然后删除。
8.删除指定的结点：将当前结点的下一个结点的值赋给当前结点，同时将当前结点的next指向下下个结点，偷天换日！！（注意此方法在删除最后一个结点的时候无效，此时仍需老实从头开始找）
9.按值查找：从头往后一个一个看，比对结点值，返回那个要找的结点
10.计算链表长度：从头往后遍历，移动一位就加一
11.尾插法建立链表：注意细节，设置指向链表末尾的指针，尾插后将最后一个元素的next指空
12.头插法建立链表：一开始要将头结点的next指空，每插入一个都要讲头结点的next指向该结点

考研加油！！！