【笔试面试】链表相关操作

/***************链表各类操作*********************
*** 1 链表的基本操作：建立、销毁、插入、删除(两种删除方法)
*** 2 链表的访问操作：遍历，反向遍历，逆置，链表的查找
*** 3 环形链表--约瑟夫环问题
*** 4 环形链表的各种形式，判断是否是环形链表，环形链表的入口地址
*** 5 链表是否相交，相交的位置
*** 6 链表的查找：倒数第k个元素，中间的元素
*** 7 两个有序链表的合二为一
***
***
***
***
***
*************************************************/

//=========使用模板编写????===============

#include <iostream>
#include <string>
#include <vector>
#include <stack>

using namespace std;

struct Node
{
	int m_data;
	Node * next;
};
typedef Node* list;

//链表的初始化 创建表头
list initList()
{
	list head = new Node;
	head->next = NULL;
	return head;
}

//链表的销毁
void destroyList(list &head)//此处需要引用，把每个结点销毁 指向NULL
{
	 //temp= head->next;
	while(head)
	{
		list temp = head->next;
		delete head;
		head = NULL;
		head = temp;
	}

}

//链表的长度
int lenthList(list head)
{
	int length=0;
	while(head->next)
	{
		length++;
		head = head->next;
	}
	return length;
}

//顺序遍历一个链表
void traverseList(list head)
{
	list curr = head->next;
	while(curr)
	{
		cout<<curr->m_data<<" ";
		curr = curr->next;
	}
	cout<<endl;
}

//逆序遍历一个链表  --类似于中序遍历和后续遍历
void reTraverseList(list head)
{
	if(!head)
		return;
	reTraverseList(head->next);
	if (head->next)
	{
		cout<<head->next->m_data<<" ";
	}
	
}

//建立一个链表--头插法
list buildListHead()
{
	list head = initList();
	for (int i =0;i<10;++i)
	{
		list temp = new Node;
		temp->m_data = i;
		temp->next = head->next;
		head->next = temp;
	}
	//traverseList(head);
	cout<<endl;
	return head;
}

//建立一个链表--尾插法
list buildListTail()
{
	list head = initList();
	list curr = head;
	for (int i=0;i<10;++i)
	{
		list temp = new Node;
		temp->m_data = i;
		temp->next = curr->next;
		curr->next = temp;
		curr = temp;
	}
	//traverseList(head);
	//cout<<endl;
	return head;
}

// 插入一个结点
list insertNode(list & head,int pos,int value)//有可能影响第一个结点 若是没有头结点，则需要使用引用变量
{
	int k = pos;
	int lenth = lenthList(head);
	if (pos < 1 || pos > lenth+1)
	{
		cout<<"插入位置越界！！Error!!"<<endl;
		return head;
	}
	//尾插 找到前一个位置，往它的后面插
	list temp = new Node;
	temp->m_data = value;

	list curr = head;
	while(pos-1)
	{
		curr = curr->next;
		pos--;
	}
		
	temp->next = curr->next;
	curr->next = temp;
	cout<<"在位置"<<k<<"处插入节点之后的链表："<<ends;
	traverseList(head);
	cout<<endl;
	return head;
}


//删除一个结点--普通做法，找到其前面一个位置 干掉他
list deleteNode(list head,int pos)
{
	int k = pos;
	int length = lenthList(head);
	if (pos<1 || pos >length)
	{
		cout<<"删除的位置越界咯！！Error!!"<<endl;
		return head;
	}
	list curr = head;
	while(pos-1)
	{
		pos--;
		curr = curr->next;
	}
	list temp = curr->next;
	curr->next = temp->next;
	delete temp;
	temp = NULL;
	cout<<"删除位置为"<<k<<"的结点之后的链表："<<ends;
	traverseList(head);
	cout<<endl;
	return head;
}

//删除结点-- O(1)时间  适用于删除非最后一个结点的结点
// list deleteNodeFast(list head,int pos)
// {
// 	int length = lenthList(head);
// 	if (pos<1 || pos>length)
// 	{
// 		cout<<"删除位置过界："<<endl;
// 		return head;
// 	}
// 	if (pos == length)
// 	{
// 		list curr = head;
// 		while(pos-1)
// 		{
// 			pos--;
// 			curr  = curr->next;
// 		}
// 		list temp = curr->next;
// 		curr->next = temp->next;
// 		delete temp;
// 		temp = NULL;
// 		return head;
// 	}
// 	//hah 参数写错了
// }
//删除结点--按结点删除
list deleteNodeFast(list head,list node)
{
	cout<<"按结点删除结点："<<endl;
	if (!node)
	{
		return head;
	}
	if (! node->next)
	{
		list pre = head;
		list curr = head->next;
		while(curr->next)
		{
			pre = curr;
			curr = curr->next;
		}
		pre->next = curr->next;
		delete node;
		node = NULL;
		traverseList(head);
		cout<<endl;
		return head;
	}
	list temp = node->next;
	node->m_data = temp->m_data;
	node->next = temp->next;
	delete temp;
	temp = NULL;
	traverseList(head);
	cout<<endl;
	return head;
}

//查找链表中某一结点
list searchList(list head,int data)
{
	list curr = head->next;
	while(curr && curr->m_data!= data)
	{
		curr = curr->next;
	}
	if (!curr)
	{
		return NULL;
	}
	else
		return curr;
}

//判断是否是循环链表
bool isCycleList(list head)
{
	list fast = head;
	list slow = head;
	while(fast->next && fast->next->next)
	{
		fast = fast->next->next;
		slow = slow->next;
		if (slow == fast)
		{
			return true;
		}
	}
	return false;
}

//创建循环链表
list buildCycleList()
{
	list head = buildListTail();
	list curr = head;
	while(curr->next)
		curr = curr->next;
	curr->next = curr;
	list root = curr;
	//头插
// 	for (int i=10;i<20;++i)
// 	{
// 		list node = new Node;
// 		node ->m_data = i;
// 		node -> next = curr->next;
// 		curr->next = node;
// 	}
	//屁股插
	for (int i=10;i<20;++i)
	{
		list node = new Node;
		node ->m_data = i;
		node->next = curr->next;
		curr->next = node;
		curr = node;
	}
	curr= head->next;
	cout<<"创建循环链表："<<endl;
	while(curr!=root)
	{
		cout<<curr->m_data<<" ";
		curr = curr->next;
	}
	cout<<curr->m_data<<" ";
	curr = curr->next;
	while(curr!=root)
	{
		cout<<curr->m_data<<" ";
		curr = curr->next;
	}
	cout<<endl;
	return head;
}

//循环链表的入口结点
list enterNode(list head)
{
	list fast = head;
	list slow = head;
	list middle ;
	while(fast->next && fast->next->next)
	{
		fast = fast->next->next;
		slow = slow->next;
		if (slow == fast)
		{
			middle = fast;
			break;
		}
	}
	list temp = head;
	while(temp != slow)
	{
		temp = temp->next;
		slow = slow->next;
	}
	cout<<"循环链表的入口结点的数据为："<<temp->m_data<<endl;
	//cout<<endl;
	return temp;
}

//判断两个单链表是否相交
bool isCross(list head1,list head2)
{
	if (!head1 || !head2)
		return false;
	while(head1->next)
		head1 = head1->next;
	while(head2->next)
		head2 = head2->next;
	if (head2==head1)
		return true;
	else return false;
}

//构造两个相交的单链表
void build2Crosslist(list &head1,list &head2)
{
	head1 = buildListHead();
	list cross = head1->next->next->next;
	head2 = buildListHead();
	list tail = head2;
	while(tail->next)
		tail = tail->next;
	tail->next = cross;
}

//两个相交的链表的首个相交的结点
list firstCrossNode(list head1,list head2)
{
	cout<<"反序遍历两个链表："<<endl;
	reTraverseList(head1);
	cout<<endl;
	reTraverseList(head2);
	stack<list> stackTemp1;
	stack<list> stackTemp2;
	head1 = head1->next;
	while(head1)
	{
		stackTemp1.push(head1);
		head1 = head1 ->next;
	}
	head2 = head2->next;
	while(head2)
	{
		stackTemp2.push(head2);
		head2 = head2 ->next;
	}
	list cross = stackTemp2.top();
	//list curr = stackTemp2.top();
	while(stackTemp2.top()==stackTemp1.top())
	{
		cross = stackTemp1.top();
		stackTemp1.pop();
		stackTemp2.pop();
	}
	cout<<"相交的第一个结点信息是："<<cross->m_data<<endl;
	return cross;
}

//两个有序链表的合二为一
list mergeList(list head1,list head2)
{
	if (!head1)
		return head2;
	if(!head2)
		return head1;
	list head = head1;
	list curr = head;
	head1 = head1->next;
	head2 = head2->next;
	while(head1 && head2)
	{
		if (head1->m_data < head2->m_data)
		{
			curr->next = head1;
			head1 = head1->next;
			curr = curr->next;
		}
		else
		{
			curr->next = head2;
			head2 = head2->next;
			curr = curr->next;
		}
	}
	while(head1)
	{
		curr->next = head1;
		head1 = head1->next;
		curr = curr->next;
	}
	while(head2)
	{
		curr->next = head2;
		head2 = head2->next;
		curr = curr->next;
	}
	curr->next = NULL;
	traverseList(head);
	return head;
}

//链表的查找
//链表的倒数第K个元素
list lastKNumber(list head,int k)
{
	int n = k;
	int length = lenthList(head);
	if (k > length)
	{
		return NULL;
	}
	list firs=head->next;
	list second = head->next;
	while(--k)
	{
		firs = firs->next;
	}
	while(firs->next)
	{
		firs = firs->next;
		second = second->next;
	}
	cout<<"倒数第"<<n<<"个元素对应的成员为："<<second->m_data<<endl;
	return second;
}

//链表的中间那个元素
list middleElement(list head)
{
	list fast = head->next;
	list slow = head->next;
	while(fast->next && fast->next->next)
	{
		fast = fast->next->next;
		slow = slow->next;
	}
	if (!fast->next)
	{
		cout<<"链表的中间元素对应的数据为："<<slow->m_data<<endl;
		return slow;
	}
	else
	{
		cout<<"链表的中间元素对应的数据为："<<slow->m_data<<ends<<slow->next->m_data<<endl;
		return slow;
	}
}

//O字型环形链表 约瑟夫环问题
//求环的长度 ---没用上
int lenJoseph(list head)
{
	int len =1;
	list curr = head->next;
	while(curr != head)
	{
		len++;
		curr = curr->next;
	}
	return len;
}

void joseph(list &head,int k)
{
	if (head->next == head)
	{
		return;
	}
	int n =k;
	list pre;
	while(--n)
	{
		pre = head;
		head = head->next;
	}
	
	pre->next = head->next;
	delete head;
	head = NULL;
	head = pre->next;
	joseph(head,k);
}

void joseph(int m,int k)
{
	list head = new Node;
	head->m_data = 1;
	head->next = head;
	list curr = head;
	for (int i=1;i<m;++i)
	{
		list node = new Node;
		node->m_data = i+1;
		node->next = curr->next;
		curr->next = node;
		curr = node;
	}
	//测试
// 	curr = head;
// 	cout<<curr->m_data<<" ";
// 	curr = curr->next;
// 	while(curr!=head)
// 	{
// 		cout<<curr->m_data<<" ";
// 		curr = curr->next;
// 	}
	

	//法一：非递归
// 	list pre;
// 	while(head->next != head)
// 	{
// 		while(--k)
// 		{
// 			pre = head;
// 			head = head->next;
// 		}
// 		k = 3;
// 		pre->next = head->next;
// 		delete head;
// 		head = pre->next;
// 	}
	//法二：
	joseph(head,k);
	cout<<"约瑟夫环最后剩下的元素是："<<head->m_data<<endl;
}

//链表的逆置操作
list reverseList(list head)
{
	list curr = head->next;
	head->next = NULL;
	while(curr)
	{
		list temp = curr->next;
		curr->next = head->next;
		head->next = curr;
		curr = temp;
	}
	return head;
}