线性表--单链表

#define _CRT_SECURE_NO_DEPRECATE
//#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1

#include<iostream>

using namespace std;

typedef struct Node
{
	int data;
	Node *next;
}Node;

Node *headPointer;//头指针
int listLength;//链表长度


/*将头指针加入到参数列表中*/
/* 1.初始化链表，输入数据，数据小于0结束输入。*/
void initList1()
{
	listLength = 0;
	headPointer = new Node;//头指针指向头节点
	if (!headPointer) { cout << "头节点内存分配失败！\n"; exit(0); }
	headPointer->next = nullptr;
	Node *temp = headPointer;//头节点的地址赋给接下来使用的中间变量
	cout << "请输入链表数据(小于0结束输入):\n";
	while (1)//链表赋值
	{
		Node *p = new Node;
		if (!p) { cout << "内存分配失败！\n"; exit(0); }
		cin >> p->data;
		if (p->data < 0) 
		{ 
			delete p; 
			cout << "链表完成！\n";
			return; //结束
		}//数据小于0不可用，需要释放内存
		temp->next = p;
		temp = p;
		temp->next = nullptr;//相当于p->next=nullptr;赋值为空指针，是个好习惯
		listLength++;
	}
	cout << endl;
}

/* 2.在链表的第i个位置之 前 插入数据e */
void insertBefore(int i, int e)
{
	cout << "在链表第" << i << "个位置前插入数据" << e << endl;
	if (i<1 || i>listLength) { cout << "数据插入位置错误！\n"; return; }
	Node *p = headPointer;
	Node *temp = new Node;//申请新内存
	if (!temp) { cout << "内存分配失败！\n"; exit(0); }
	while (--i) 
		p = p->next;//找到第i-1个位置
	temp->data = e;
	temp->next = p->next;
	p->next = temp;
	listLength++;
	cout << "链表长度为:" << listLength << "  数据插入成功！\n";
}

/*在链表第i个位置之 后 插入数据e*/
void insertAfter(int i, int e)
{
	cout << "在链表第" << i << "个位置之后插入数据" << e << endl;
	if (i<1 || i>listLength) { cout << "数据插入位置错误！\n"; exit(0); }
	Node *p = headPointer;
	Node *temp = new Node;//申请新内存
	if (!temp) { cout << "内存分配失败！\n"; exit(0); }
	while (i--) 
		p = p->next;
	temp->data = e;
	temp->next = p->next;
	p->next = temp;
	listLength++;
	cout << "链表长度为:" << listLength << "  数据插入成功！\n";
}

/* 4. 删除链表的第i个位置的数据 */
bool deleteList(int i)
{
	cout << "删除链表第" << i << "个位置的数据\n";
	Node *p = headPointer;
	while (--i) p = p->next;//找到第i-1个位置
	Node *deleteTemp = p->next;//为第i个位置的内存释放做准备
	p->next = p->next->next;
	delete deleteTemp;
	listLength--;
	cout << "链表长度为：" << listLength << "  数据删除成功！\n";
	return true;
}

/* 5.打印链表所有数据 */
bool printList()
{
	if (headPointer->next == nullptr)
	{
		cout << "链表为空！\n";
		return false;
	}
	cout << "链表长度为：" << listLength << "打印链表：\n";
	Node *p = headPointer;
	while (p->next != nullptr)
	{
		cout << p->next->data << " ";
		p = p->next;
	}
	cout << "链表打印成功！\n\n";
	return true;
}

/* 6. 清除链表*/
bool clearList()
{
	if (headPointer->next == nullptr)
	{
		cout << "链表为空，无法再清除！\n";
		return false;
	}
	Node *p = headPointer;
	Node *temp;
	while (p != nullptr)
	{
		temp = p->next;
		delete p;
		p = temp;
		listLength--;
	}
	cout << "链表清除成功！\n" << "链表长度为" << listLength + 1 << endl;//头节点不计入链表长度，而清除链表时，头节点也被清除
	return true;
}

/* 7.返回链表中第i个结点中的数据的地址*/
int* getData(int i)
{
	if (i<1 || i>listLength) { cout << i << "值超出链表范围！\n"; return false; }
	Node *p = headPointer;
	while (i--) p = p->next;
	return &(p->data);
}

/* 8. 给定数值，判断链表中是否存在该数值，如果存在返回数值相同的第一个结点的地址*/
Node* findList(int e)
{
	Node *p = headPointer;
	while (p->next != nullptr)
	{
		p = p->next;
		if (p->data == e) return p;
	}
	return nullptr;
}

/* 9. 修改链表中第i个结点的数据*/
bool modifyList(int i, int e)
{
	if (i<1 || i>listLength) { cout << "修改的结点位置错误！\n"; return false; }
	Node *p = headPointer;
	while (i--) p = p->next;
	p->data = e;
	return true;
}

/* 10. 逆位序输入n个元素的值*/
void initList2(int n)
{
	headPointer = new Node;//头指针指向头节点
	headPointer->next = nullptr;
	while (n--)
	{
		Node *p = new Node;
		if (!p) { cout << "内存分配失败！\n"; exit(0); }
		cin >> p->data;
		p->next = headPointer->next;
		headPointer->next = p;
	}
}

/* 11. 按顺序归并两个链表*/
bool mergeList(Node*  &a, Node*  &b, Node*  &c)
{
	Node *pa = a->next;
	Node *pb = b->next;
	Node *pc = c = a;//把a的头节点给c，最后要删除b的头节点
	while (pa&&pb)
	{
		if (pa->data <= pb->data)
		{
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else
		{
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
	}
	pc->next = pa ? pa : pb;
	delete b;
	return true;
}

/*12.交换两个节点的data*/
void swapList(Node *i,Node *j)
{
	int temp = i->data;
	i->data = j->data;
	j->data = temp;
}

/* 13. 链表排序*/
//pStart指向首个元素的节点，不是头节点；pEnd是null，也就是最后一个节点的next
void sortList(Node *pStart,Node *pEnd)
{
	if (pStart == pEnd||pStart->next==pEnd)
		return;
	//这里的第一个节点不是头节点，而是头节点的下一个节点，依次类推
	int dataBase = pStart->data;

	Node *firstNode = pStart;//保存第一个节点（也就是头节点的下一个节点）
	Node *i = pStart;
	Node *j = pStart->next;//指向第二个节点

	while (j != pEnd)
	{
		if (j->data < dataBase)
		{
			i = i->next;
			swapList(i, j);
		}
		j = j->next;
	}
	swapList(firstNode, i);
	sortList(pStart, i);
	sortList(i->next, pEnd);
}

/*14.已知线性表数据递增有序，删除表中所有值大于mink且小于maxk的数据，并释放被删除的结点*/
bool deleteYouWant1(int mink, int maxk)
{
	Node *p = headPointer;
	while (p->next != nullptr)//先判断
	{
		if (p->next->data>mink)//先找到满足条件的点然后删除，而不是指针已指向满足条件的点才去删除
		{
			if (p->next->data >= maxk)
				return true;
			Node *willDelete = p->next;
			p->next = p->next->next;
			delete willDelete;
			listLength--;
		}
		else
			p = p->next;
	}
	return false;
}

/*15.已知线性表数据递增无序，删除表中所有值大于mink且小于maxk的数据，并释放被删除的结点*/
void deleteYouWant2(int mink, int maxk)
{
	Node *p = headPointer;
	while (p->next != nullptr)
// p->next != nullptr 先判断,而不是 p!= nullptr,因为你下面是提前判断数据data，如果
//不提前判断是不是nullptr，下面的数据判断可能造成非法访问data的错误
	{
		if (p->next->data > mink && p->next->data < maxk)
		{
			Node *willDelete = p->next;
			p->next = p->next->next;
			delete willDelete;
			listLength--;
		}
		else
			p = p->next;
	}
}

/*16.删除数据相同的节点，仅只保留一个*/
void uniqueList1()
{
	Node *p = headPointer->next;
	while (p != nullptr)
	{
		Node *temp = p->next;
		Node *frontNode = p;//保留我要删除的节点的上一个节点，以便删除节点时，将前后两个节点相接
		while (temp!=nullptr)
		{
			if (temp->data == p->data)
			{
				Node *willDelete = temp;

				frontNode->next = temp->next;
				temp = temp->next;

				delete willDelete;
				listLength--;
			}
			else
			{
				frontNode = temp;
				temp = temp->next;
			}
		}
		p = p -> next;
	}
}

/*17.删除数据相同的节点，仅只保留一个*/
void uniqueList2()//和上面的版本不一样之处就是，没有frontNode指针保留前一个结点，而是采用先判断再去删除的办法
{
	Node *p = headPointer;
	while (p != nullptr)
	{
		Node *temp = p;
		while (temp->next != nullptr)//temp->next != nullptr采用先判断再去删除的办法,而不是temp!=nullptr
//进行删除操作时，我们是肯定是要知道删除节点的上一个节点，要不我们每走一步，保留上一个节点，
//要不在删除节点的前面停下来uniqueList2采用的是后者
		{
			if (temp->next->data == p->data)
			{
				Node *willDelete = temp->next;
				temp->next = temp->next->next;
				delete willDelete;
				listLength--;
			}
			else
				temp = temp->next;
		}
		p = p->next;
	}
}


int main()
{
	
	return 0;
}