#include"iostream"
using namespace std;
//====================单链表===================================
//如果不提供“头指针”,则整个链表都无法访问,链表的一个重要特点是插入、删除操作灵活方便.
//插入操作处理顺序:中间节点的逻辑,后节点逻辑,前节点逻辑。按照这个顺序处理可以完成任何链表的插入操作。
//删除操作的处理顺序:前节点逻辑,后节点逻辑,中间节点逻辑。
/*单链表实际上是由节点(Node)组成的,一个链表拥有不定数量的节点。
而向外暴露的只有一个头节点(Head),我们对链表的所有操作,都是通过其头节点(head)来进行的。
节点:数据+地址*/
struct ListNode
{
int val;
struct ListNode *next;
ListNode(int x) :val(x), next(NULL){}
};
//头指针与头结点不同,头结点即第一个结点,头指针是指向第一个结点的指针。链表中可以没有头结点,但不能没有头指针。
/*1.初始化单链表(无头结点),头指针为空*/
// void initList(Node **pNode)
// {
// *pNode = NULL;
// cout << "初始化成功!" << endl;
// }
/*2.创建单链表(头插法):生成的链表中结点的次序和输入的顺序相反
a.先让新节点的next指向头节点之后
b.然后让表头的next指向新节点*/
void CreatListHead(ListNode *pHead,int data)
{
ListNode *p=new ListNode(-1);
p->val = data;
p->next = pHead->next;
pHead->next = p;
}
/*2.创建单链表(尾插法):在表的最后插入结点
a.将表尾终端结点的指针指向新结点
b.将当前的新结点定义为表尾终端结点 */
void CreatListTail(ListNode **Node, int data)
{
if ((*Node)->next == NULL)
{
ListNode *p = new ListNode(-1);
p->val = data;
(*Node)->next = p;
*Node = p;
(*Node)->next = NULL;
}
}
/*单链表的遍历,并返回单链表长度*/
int printList(const ListNode *pHead)
{
int len = 0;
ListNode *p = pHead->next;
if (p== NULL)
cout << "链表为空!" << endl;
else
{
while (p != NULL)
{
len++;
cout << p->val << " ";
p = p->next;
}
cout << endl;
}
return len;
}
/*删除单链表:
1.声明一节点p和q;
2.将第一个结点赋值给p;
3.循环:
a.将下一结点赋值给q;b.释放p;c.将q赋值给p;
*/
bool ClearList(ListNode *pHead)
{
ListNode *p, *q;
p = pHead->next;
while (p)
{
q = p->next;
delete p;
p = q;
}
pHead->next = NULL;
return true;
}
/*查找单链表上指定节点的数据*/
bool GetElem(ListNode *pHead, int i, int &data)
{
ListNode *p = pHead->next;
int j = 0;
while (p && j < i-1)
{
p = p->next;
j++;
}
if (!p)
return false;
else
{
data = p->val;
return true;
}
}
/*单链表指定位置插入数据:
1.找到ai-1存储位置p
2.生成一个数据域为x的新结点*s
3.令结点*p的指针域指向新结点
4.新结点的指针域指向结点ai。*/
bool ListInsert(ListNode *pHead, int i, int data)
{
ListNode *p = pHead;
int j = 0;
while (p && j < i - 1)
{
p = p->next;
j++;
}
if (!p || j>i - 1)
return false;
else
{
ListNode *tmpPtr = new ListNode(-1);
tmpPtr->val = data;
tmpPtr->next = p->next;
p->next = tmpPtr;
return true;
}
}
/*删除单链表指定的某个结点:
1.找到ai-1的存储位置p(因为在单链表中结点ai的存储地址是在其直接前趋结点ai-1的指针域next中)
2.令p->next指向ai的直接后继结点(即把ai从链上摘下)
3.释放结点ai的空间,将其归还给“存储池”。*/
bool ListDelete(ListNode *pHead, int i)
{
int j=1;
ListNode *p, *q;
p= pHead;
while (p && j<i)
{
p = p->next;
j++;
}
if (!p || j>i)
return false;
else
{
q = p->next;
p->next = q->next;
delete q;
return true;
}
}
/*单链表逆序:*/
bool ListReverse(ListNode *PHead)
{
ListNode *current, *pnext, *prev;
current = PHead->next;
pnext = current->next;
current->next = NULL;
while (pnext)
{
prev = pnext->next;
pnext->next = current;
current = pnext;
pnext = prev;
}
PHead->next = current;
return true;
}
/*判断单链表中是否有环:
1.使用p、q两个指针,p总是向前走,但q每次都从头开始走,对于每个节点,看p走的步数是否和q一样*/
bool HasLoop(ListNode *pHead)
{
ListNode *cur1 = pHead;
int pos1 = 0;
while (cur1)
{
ListNode *cur2 = pHead;
int pos2 = 0;
pos1++;
while (cur2)
{
pos2++;
if (cur1 == cur2)
{
if (pos1 == pos2)
break;
else
return true;
}
cur2 = cur2->next;
}
cur1 = cur1->next;
}
return false;
}
/*获取单链表倒数第N个结点值:
建立两个指针,第一个先走n步,然后第2个指针也开始走,两个指针步伐(前进速度)一致。当第一个结点走到链表末尾时,第二个节点的位置就是我们需要的倒数第n个节点的值。*/
bool GetNthNodeFromBack(ListNode *pHead, int n,int &data)
{
int i = 1;
ListNode *firstNode = pHead, *secNode = pHead;
while (firstNode->next != NULL && i < n)
{
firstNode = firstNode->next;
i++;
}
if (firstNode->next == NULL && i < n - 1)
{
cout << "n超出链表长度" << endl;
return false;
}
while (firstNode->next != NULL)
{
secNode = secNode->next;
firstNode = firstNode->next;
}
data = secNode->val;
return true;
}
//=====================================================
//====================双向循环链表=======================
/*双向循环链表的结构:数据、next指针、prior指针
1.链表由头指针head惟一确定的。
2.带头结点的双链表的某些运算变得方便。
3.将头结点和尾结点链接起来,为双(向)循环链表。*/
struct NodeType2
{
int val;
NodeType2 *next, *prior;
NodeType2(int x) :val(x), next(NULL), prior(NULL) {};
};
//创建双向链表
void CreateListtype2(NodeType2 **Node, int data)
{
NodeType2 *tmpPtr = (*Node)->next;
NodeType2 *p = new NodeType2(data);
(*Node)->next = p;
p->prior = *Node;
p->next = tmpPtr;
*Node = p;
}
/*双链表的前插操作*/
bool ListType2Insert1(NodeType2 *pHead, int i, int data)
{
int j = 0;
NodeType2 *p = pHead;
while (p && j<i)
{
p = p->next;
j++;
}
if (!p && j < i - 1)
return false;
else
{
NodeType2 *tmpTpr = new NodeType2(data);
tmpTpr->next = p;
tmpTpr->prior = p->prior;
p->prior->next = tmpTpr;
p->prior = tmpTpr;
return true;
}
}
/*双链表的后插操作*/
bool ListType2Insert2(NodeType2 *pHead, int i, int data)
{
int j = 0;
NodeType2 *p = pHead;
while (p && j<i)
{
p = p->next;
j++;
}
if (!p && j < i - 1)
{
cout << "超出链表长度!" << endl;
return false;
}
else
{
NodeType2 *tmpPtr = new NodeType2(data);
tmpPtr->next = p->next;
p->next->prior = tmpPtr;
p->next = tmpPtr;
tmpPtr->prior = p;
return true;
}
}
/*双链表上删除结点*p*/
bool ListType2Delete(NodeType2 *pHead, int i)
{
int j = 0;
NodeType2 *p = pHead;
while (p && j<i)
{
p = p->next;
j++;
}
if (p && j < i - 1)
{
cout << "超出链表长度!" << endl;
return false;
}
else
{
p->prior->next = p->next;
p->next->prior = p->prior;
delete p;
return true;
}
}
//=============================================
int main()
{
//=========单链表==============
//ListNode *L = new ListNode(-1);
//int n;
//ListNode* tmpPtr = L;
//while (cin >> n)//ctrl+z结束
//{
// //CreatListHead(L, n);
// CreatListTail(&tmpPtr, n);//为什么传指针不行 非得指针的指针
//}
//int len = printList(L);
//int data = 0;
// bool isGetElem = GetElem(L, 2, data);
// bool isInsertElem = ListInsert(L, 2, 4);
// bool isClear = ClearList(L);
//bool isDelete = ListDelete(L, 1);
//bool isReverse = ListReverse(L);
//tmpPtr->next = L;
//bool isloop=HasLoop(L);
//bool IsGet = GetNthNodeFromBack(L, 2, data);
//len = printList(L);
//============双链表==================
NodeType2 *L = new NodeType2(-1);
int n = 0;
NodeType2 *tmpPtr = L;
while (cin >> n)
{
CreateListtype2(&tmpPtr, n);
}
bool isInsert = ListType2Insert2(L, 2, 4);
bool isDelete = ListType2Delete(L, 3);
system("pause");
return 0;
}
单(双向)链表的基本操作 C++
最新推荐文章于 2022-10-12 23:29:34 发布