一、比较顺序表和链表的优缺点，说说他们分别在什么场景下应用
空间上的比较（Space）
a. 空间的开辟：
顺序表的实现一般是实现连续开辟一段空间（或根据需求动态连续开辟空间），然后在进行数据的增删查改（静态顺序表），所以顺序表一般是固定空间大小的；
单链表则是一次只开辟一个结点的空间，用来存储当前要保存的数据及指向下一个结点或NULL的指针，所以单链表的空间大小时动态变化的。
b. 空间的使用：
当我们不知道要存储多少数据时，用顺序表来开辟的空间如果太大，就会造成一定程度上的浪费。
用单链表是实现时，因为是每需要存储一个数据时，才开辟一个空间，虽然有非数据项的指针占空间，但相比顺序表来说，浪费不是那么明显。(因为链表每次都是开辟的位置都是随机的，那么可能会把这块空间搞得七零八碎，出现很多小的一般使用不到的碎片空间)
c. 对CPU高速缓存的影响：
顺序表的空间一般是连续开辟的，而且一次会开辟存储多个元素的空间，所以在使用顺序表时，可以一次把多个数据写入高速缓存，再写入主存，顺序表的CPU高速缓存效率更高，且CPU流水线也不会总是被打断；
单链表是每需要存储一个数据才开辟一次空间，所以每个数据存储时都要单独的写入高速缓存区，再写入主存，这样就造成了，单链表CPU高速缓存效率低，且CPU流水线会经常被打断。
时间上的比较（Time）
a. 访问随机元素的时间复杂度：
顺序表访问随机元素的时间复杂度是O（1），而单链表访问随机元素的平均时间复杂度是O（n）。
b. 随机位置插入、删除元素的时间复杂度：
顺序表在插入随机位置插入、删除元素的平均时间复杂度是O（n），
单链表在插入随机位置插入、删除元素的时间复杂度是O（1）。
应用场景：
在查询操作使用的比较频繁时，使用顺序表会好一些；
在插入、删除操作使用的比较频繁时，使用单链表会好一些。
二、如何从头到尾打印单链表（使用递归的思想，我们便很容易有思路）
void PrintHeadtoTail(ListNode* plist)
{
if(plist == NULL)
{
printf("NULL");
return;
}
PrintHeadtoTail(plist->next);
printf("<-%d",plist->data);
}
三、删除一个无头单链表的非尾节点
实现思路：无头单链表我们是无法找到非尾节点的前一个节点的，只能通过把目标节点的下一个节点的信息复制给自己，然后删除下个节点，达到删除自己的目的（即自己所报的信息不存在了）。
void EraseNonTail(ListNode* pos)//删除无头链表指定非尾节点
{
if ((pos==NULL)&&(pos->next==NULL))
{
return;
}
else
{
ListNode* sur = pos->next;
pos->next = sur->next;
pos->data = sur->data;
free(sur);
sur = NULL;
}
}
四、非头节点前插入节点
void AddNoHeadTail(ListNode*pos, DataType x)//非头节点前插入节点
{
ListNode* tmp = NULL;
assert(pos);
tmp = BuyList(x);
tmp->next = pos->next;
pos->next = tmp;
tmp->data = pos->data;
pos->data = x;
}
四、单链表实现约瑟夫环
ListNode* JosephRing(ListNode*list, DataType k)//单链表实现约瑟夫环
{
ListNode* cur = list;
ListNode* pos = list;
if (list==NULL)
{
return NULL;
}
//首尾相连成环
while(pos->next)
{
pos = pos->next;
}
pos->next = list;
while (cur->next!=cur)//终止条件为只剩一个节点
{
DataType n = k;
while (n--)
{
pos = cur;
cur = cur->next;
}
pos->next = cur->next;
free(cur);
cur = pos->next;
}
return cur;
}
5.逆置、翻转单链表
ListNode* Reverse(ListNode* list)//逆置反转单链表
{
ListNode* newhead = NULL;
ListNode* pos = list;
ListNode* cur = pos;
while (cur)
{
pos = cur;
cur = cur->next;
pos->next = newhead;
newhead = pos;
}
return newhead;
}
6.排序单链表
void Bubblesort(ListNode* list) //排序单链表
{
ListNode* tail = NULL;
ListNode* next = NULL;
ListNode* pos = NULL;
if ((list==NULL)||(list->next == NULL))
{
return;
}
while (list->next != tail)
{
pos = list;
next = pos->next;
while (tail != next)
{
if (pos->data > next->data)
{
DataType tmp = pos->data;
pos->data = next->data;
next->data = tmp;
}
pos = pos->next;
next = next->next;
}
tail = pos;
}
}
7.合并有序单链表，合并后依然有序
ListNode* Conbine(ListNode* list1, ListNode* list2)
{
ListNode* head = NULL;
ListNode* tail = NULL;
if (list1 == NULL)
{
return list2;
}
if (list2 == NULL)
{
return list1;
}
//先找出两个链表中的一个小的节点，把他摘下来做新链表的头结点
if(list1->data > list2->data)
{
head = list2;
list2 = list2->next;
}
else
{
head = list1;
list1 = list1->next;
}
tail = head;
while (list1 && list2)
{
if (list1->data > list2->data)
{
tail->next = list2;
list2 = list2->next;
}
else
{
tail->next = list1;
list1 = list1->next;
}
tail = tail->next;
}
if (list1 == NULL)
{
tail->next = list2;
}
else
{
tail->next = list1;
}
return head;
}
8.查找单链中间节点（只遍历一次链表）
ListNode* FindMidTail(ListNode* list)
{
ListNode* fast = list;
ListNode* slow = NULL;
while ((fast!=NULL)&&(fast->next != NULL))
{
fast = fast->next->next;
slow = slow->next;
}
return slow;
}
9.查找单链表中的倒数第k个节点
ListNode* FindTail_k_Node(ListNode* list, int k)
{
ListNode* fast = list;
ListNode* slow = list;
while (--k)
{
if(fast == NULL)//说明k的值大于链长
{
return NULL;
}
fast = fast->next;
}
while (fast->next)
{
fast = fast->next;
slow = slow->next;
}
return slow;
}
10.判断一个链表是否带环，若带环求环入口点，环长
//判断是否带环,带环返回入口点，不带环返回空
ListNode* JudgeLoop(ListNode* list)
{
ListNode* fast = list;
ListNode* slow = list;
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
if (fast == slow)
{
//printf("该单链表有环\n");
return fast;
}
}
//printf("该链表无环\n");
return NULL;
}
ListNode* GetCyclen(ListNode* list)//若带环求环的节点环长
{
ListNode* meetnode = JudgeLoop(list);
ListNode* fast = NULL;
ListNode* slow = NULL;
ListNode* loopnode = NULL;//环内相遇点
ListNode* listnode = NULL;
int count = 1;//声明计数器，记录环长
if (meetnode == NULL)
{
return NULL;
}
fast = meetnode->next->next;
slow = meetnode->next;
listnode = list;//起始点
loopnode = meetnode;//环内相遇点
while (fast != slow)
{
fast = fast->next->next;
slow = slow->next;
count++;
}
printf("环长为：%d\n", count);
while (listnode != loopnode)
{
listnode = listnode->next;
loopnode = loopnode->next;
}
printf("环的入口点为：%d\n", loopnode->data);
return loopnode; //环的入口点
}
11.判断两条链表是否相交，若相交返回相交点（假设不带环）
//判断两个链表是否相交,假设不带环（链表长度相减法）
ListNode* CheckIsMeet(ListNode* plist1, ListNode* plist2)
{
int len1 = 0;
int len2 = 0;
int len = 0;
ListNode* pos1 = plist1;
ListNode* pos2 = plist2;
if ((plist1 == NULL)||(plist2 == NULL))
{
return NULL;
}
while (pos1->next)
{
pos1 = pos1->next;
len1++;
}
while (pos2->next)
{
pos2 = pos2->next;
len2++;
}
len =len1 - len2;
pos1 = plist1;
pos2 = plist2;
if(len>0)
{
while (len--)
{
pos1 = pos1->next;
}
}
else
{
len = abs(len); //对len求绝对值
while (len--)
{
pos2 = pos2->next;
}
}
while (pos1)
{
if (pos1 == pos2)
{
return pos1;
}
pos1 = pos1->next;
pos2 = pos2->next;
}
return NULL;
}
12.链表相交问题升级版（可能带环）
//判断链表是否相交（可能带环）
ListNode* CheckMeet_All(ListNode* list1, ListNode* list2)
{
ListNode *cur1 = JudgeLoop(list1);
ListNode *cur2 = JudgeLoop(list2);
ListNode *ent1 = NULL;
//1.两个链表都不带环
if ((cur1 == NULL) && (cur2 == NULL))
{
return CheckIsMeet(list1, list2);
}
//2.一个带环，一个不带环(不可能相交)
else if (((cur1==NULL)&&(cur2!=NULL))||((cur1!=NULL)&&(cur2==NULL)))
{
return NULL;
}
//3.两个链表都带环，分两种情况
else
{
//1.入口点相同则尾交,去掉环转换成不带环链表相交问题
if (cur1 == cur2)
{
cur1->next = NULL;
return CheckIsMeet(list1,list2);
}
//2.同环两个入口点
//让一个入口点遍历一遍看是否有另一个入口点
else
{
ent1 = cur1->next;
while(ent1 != cur1)
{
if (ent1 == cur2)
{
return ent1;
}
ent1 = ent1->next;
}
return NULL;
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
