常见算法面试链表


算法总结——链表

算法总结——链表:

数组建立链表
打印链表
插入节点(头插)
查找节点
删除节点
反转链表
找出单链表的倒数第k个元素
两个单链表相交，计算相交点
找出中间节点
单链表排序,时间复杂度O(n2)
单链表排序，时间复杂度O(nlogn)——归并排序，详见leetcode sort list
合并两个有序链表，虚拟节点法——详见归并排序的merge
判断链表是否有环，如果有环，计算环的长度;如果无环，则返回-1
删除单链表中重复的元素，借助map实现
用链表模仿大整数加法，leetcode有类似题目，当时用的是循环，此次试试递归
二级链表，每个节点指向一个链表，将其转为单链表
 

#include <iostream>
#include <map>
#include <vector>
using namespace std;

struct ListNode{
int val;
ListNode* next;
ListNode(int x):val(x),next(NULL){};
};

//数组建立链表
ListNode* ConstructLinkedList(vector<int> List){
if(List.size()==0)
return NULL;
ListNode* head = new ListNode(List[0]);
ListNode* p=head;
for(int i=1;i<List.size();i++){
p->next=new ListNode(List[i]);
p=p->next;
}
p->next=NULL;
return head;
}

//打印链表
void PrintList(ListNode* head){
if(head==NULL)
return;
ListNode *p=head;
while(p!=NULL){
cout<<p->val<<"->";
p=p->next;
}
return;
}

//插入节点(头插)
ListNode* InsertNode(ListNode* head,int val){
ListNode* p= new ListNode(val);
p->next=head;
head=p;
return head;
}
//查找节点
ListNode* FindNode(ListNode* head,int val){
if(head==NULL)
return NULL;
ListNode* p=head;
while(p!=NULL){
if(p->val==val)
return p;
p=p->next;
}
return NULL;
}
//删除节点
ListNode* DeleteNode(ListNode* head,int val){
if(head==NULL){
cout<<"List is empty!"<<endl;
exit(1);
}
//delete the head node
ListNode* p=head;
if(head->val==val){
head=head->next;
delete(p);
return head;
}
ListNode* q=p;
while(p!=NULL){
if(p->val==val){
//delete the tail node
if(p->next==NULL){
q->next=NULL;
delete(p);
}
else{
q->next=p->next;
delete(p);
}
}
p=p->next;
q=p;
}
return head;
}
//反转链表
ListNode* ReverseList(ListNode* head){
if(head==NULL||head->next==NULL)
return head;
ListNode* p=head->next,*q=head,*l=head;
while(p->next!=NULL){
l=p->next;
p->next=q;
q=p;
p=l;
}
p->next=q;
head->next=NULL;
return p;
}
//找出单链表的倒数第k个元素
ListNode* FindTheNode(ListNode* head,int k){
if(head==NULL||k==0)
return NULL;
ListNode* p=head,*q=head;
int len=abs(k);
while(len>0){
p=p->next;
--len;
}
if(k<0)
return p;
while(p!=NULL){
p=p->next;
q=q->next;
}
return q;
}
//两个单链表相交，计算相交点
//解法1：对齐长度后再循环判断
//解法2：链表A的尾巴指向链表B的头部，判断环入口点
ListNode* FindInsectNode(ListNode* l1,ListNode* l2){
ListNode* p=l1;
ListNode* q=l2;
int len1=0,len2=0;
while(p!=NULL)
len1++;
while(q!=NULL)
len2++;

for(int i=0;i<len1-len2;i++)
p=p->next;
for(int j=0;j<len2-len1;j++)
q=q->next;
while(q!=NULL&&p!=NULL&&q->val!=p->val){
p=p->next;
q=q->next;
}
return q;
}
//找出中间节点
ListNode* FindMiddleNode(ListNode* head){
if(head==NULL||head->next==NULL)
return head;
ListNode* p=head,*q=head;
while(p&&p->next!=NULL){
p=p->next->next;
q=q->next;
}
return q;
}
//单链表冒泡排序,时间复杂度O(n2)
ListNode* SortList1(ListNode* head){
if(head==NULL||head->next==NULL)
return head;
ListNode* p=head;
int length;
while(p!=NULL){
length++;
p=p->next;
}
while(length>0){
ListNode* j=head;
ListNode* k=j->next;
if(j->val>k->val){
int tmp=j->val;
j->val=k->val;
k->val=tmp;
}
}
}
//单链表插入排序

ListNode* insertionSortList(ListNode* head) {
if(head==NULL||head->next==NULL)
return head;
ListNode* newhead = new ListNode(-2147483648);
newhead->next=head;
ListNode* q=head;
ListNode* p=head->next;
while(p!=NULL){
ListNode* s1=newhead;
ListNode* s2=s1->next;
while(s2!=p&&s2->val<=p->val){
s1=s2;
s2=s2->next;
}
if(s2!=p){
s1->next=p;
q->next=p->next;
p->next=s2;

p=q->next;}
else{
q=p;
p=p->next;
}
}
return newhead->next;
}
//单链表排序，时间复杂度O(nlogn)——归并排序，详见leetcode sort list
//合并两个有序链表，虚拟节点法——详见归并排序的merge
//判断链表是否有环

bool hasCycle(ListNode *head) {
if(head==NULL||head->next==NULL||head->next->next==NULL)
return false;
if(head->next==head||head->next->next==head)
return true;
ListNode* quick=head->next->next;
ListNode* slow=head->next;
while((quick!=NULL&&quick->next!=NULL)&&slow!=quick){
quick=quick->next->next;
slow=slow->next;
}
if(quick==NULL||quick->next==NULL)
return false;
return true;
}

//判断链表是否有环，如果有环，计算环的长度;如果无环，则返回-1
bool CalCircle(ListNode* head,ListNode* intersect,int& cirlen){
intersect=NULL;
cirlen=-1;
int step=0;
if(head==NULL||head->next==NULL||head->next->next==NULL)
return false;
if(head->next==head){
intersect=head;
cirlen=0;
return true;

}
if(head->next->next==head){
intersect=head;
cirlen=1;
　　　　 return true;
}
ListNode* quick=head->next->next,*slow=head;
while((quick!=NULL&&quick->next!=NULL)||slow!=quick){
quick=quick->next->next;
slow=slow->next;
step++;
}
if(quick==NULL||quick->next==NULL)
return false;
if(slow==quick){
intersect=slow;
cirlen=step/2;
}
return true;
}

//删除单链表中重复的元素，借助map实现
ListNode* DeleteCopy(ListNode* head){
if(head==NULL||head->next==NULL)
return head;
map<int,int> List;
ListNode* p=head,*q=head;
while(p!=NULL){
if(List.find(p->val)==List.end()){
List[p->val]=1;
q=p;
p=p->next;
}
else{
q->next=p->next;
delete(p);
p=q->next;
}
}
return head;
}

//用链表模仿大整数加法，leetcode有类似题目，当时用的是循环，此次试试递归
ListNode* AddNumber(ListNode* l1,ListNode* l2,int& carry)
{
if(!l1&&!l2){
if(carry>0)
return new ListNode(carry);
else return NULL;
}
ListNode* tmp=l1;
if(l1==NULL||l2==NULL){
if(l1==NULL){
tmp=l2;
carry+=tmp->val;
tmp->val=carry%10;
carry/=10;
tmp->next=AddNumber(l1,l2->next,carry);
}
else {
tmp=l1;
carry+=tmp->val;
tmp->val=carry%10;
carry/=10;
tmp->next=AddNumber(l1->next,l2,carry);
}
return tmp;
}

carry+=(l1->val+l2->val);
tmp->val=carry%10;
carry/=10;
tmp->next=AddNumber(l1->next,l2->next,carry);
return tmp;
}

struct ListofList{
ListNode* head;
ListofList* next;
};
//二级链表，每个节点指向一个链表，将其转为单链表
ListNode* GenerateList(ListofList* HList){
if(HList==NULL)
return NULL;
ListofList *p=HList;
ListNode *ret=HList->head;
while(p->next!=NULL)
{
ListNode *q=p->head;
while(q->next!=NULL)
q=q->next;
q->next=p->next->head;
p=p->next;
}
return ret;
}