单链表的各种操作 笔试 面试

一、链表与数组的 差别

1、逻辑结构 数组必须事先定义固定的长度 不能动态的增减 链表是动态分配内存

2、内存结构 数组从栈中分配空间 链表在堆中

3、数组在内存中顺序存储 链表随机存储 数组訪问效率高 链表插入删除方便

4、数组存在越界问题

定义表头， 为方便操作 表头数据域为空

二、单链表插入 删除

bool insertList(List head, Type x, int index){

Node *p;

p = head;

int j = 1;

while(p->next&& j < index){

p = p->next;

++j;

}

if(p==NULL) return ERROR;

Node *tmp = (Node *)malloc(sizeof(Node));

tmp->data = x;

tmp->next = p->next; //tmp的后继指向原index位置的结点

p-next = tmp; //p的后继为新结点

return OK;

}

bool deleteList(List head, int index){

Node *p = head;

int j = 1;

while(p->next!=NULL&&j < i){

p = p->next;

++j;

}// p->next为第index个

if(p==NULL || p->next==NULL || j > i) return ERROR; //i可能为负值

Node *tmp = p->next; //tmp指向第index个

p->next = tmp->next; //第index+1个取代index

free(tmp);//释放空间

return OK;

}

三、找出单链表中的倒数第k个元素

解题思路

1、先遍历一遍 计算长度， 再找出后k个

2、双路齐下 p1从第一位開始，p2从第k为開始遍历 直到p2走到头

思路2代码：

Node* find(Node* head, int index){

Node *p1,*p2;

p1 = head;

p2 = head;

for(int i = 0; i < index; i++){

p2 = p2->next; //p2向后移k位

}

while(p2!=NULL){

p1 = p1->next;

p2 = p2->next;

}

return p1;

}

四、单链表反转

解题思路：每次操作结点时 标注其前结点 后结点 对其进行操作

Node* reverse(Node *head){

Node *prev = NULL;

Node *pCur = head;

Node *rHead = NULL;

while(pCur!=NULL){

Node *pNext = head->next;

if(pNext == NULL)

rHead = pCur;

pCur->next = prev; //改变顺序 当前结点指向 自己的前一个结点

prev = pCur; //当前结点变为前结点 （为了下一个结点准备）

pCur = pNext; //结点后移

}

}

五、从尾到头输出单链表

1、递归输出

2、非递归输出

非递归操作 ：

1).能够使用 “四” 的代码进行反转 然后输出

2).遍历结点入栈 然后输出

六、寻找单链表的中间结点

1、遍历求长度length 然后再遍历输出

2、双路齐下 p1走一步 p2走两步 p2走到终点时 p1正好到中点

Node* findMiddle(Node *head){

Node *p1 = head;

Node *p2 = head;

while(p2->next->next!=NULL){

p2 = p2->next->next;

p1 = p1->next;

}

return p1;

}

七、单链表排序

与数组排序差别不大。交换元素时 仅仅交换数据域的内容就好。链表的顺序结构不用变化

八、单链表中随意 交换两个元素 （要注意表头）

将2个结点进行交换 要注意 next指针的 交换问题

//将p q结点交换

Node* swap(Node* head,Node* p,Node* q){

if(head==NULL || p==NULL || q==NULL){

Print(ERROR);

return head;

}

if(p==q){

Print(OK);

return head;

}

else if(p->next == q){ //两节点相邻

Node* prev = getPrev(p);

p->next = q->next;

q->next = p;

prev->next = q;

}

else if(q->next == p){

Node* prev = getPrev(q);

q->next = p->next;

p->next = q;

prev->next = p;

}

else if(p!=q){ //两节点不相邻 且不同 交换前后指针域

Node* prev1 = getPrev(p);

Node* prev2 = getPrev(q);

Node* next1 = p->next;

Node* next2 = q->next;

p->next = next2;

prev2->next = p;

q->next = next1;

prev1->next = q;

}

return head;

}

九、检測一个较大的单链表是否有环

双路齐下法 一个走一步一个走2步 看是否会相遇

十、推断两个（无环）单链表是否交叉

推断最后一个结点是否同样

十一、删除单链表中的反复结点

哈希， 建议一hash_map ，遍历链表 若结点出现反复则删除

十二、合并两个有序链表（非交叉）

1、递归

Node* Merge(Node* head1, Node* head2){

if(head1==NULL)

return head2;

if(head2==NULL)

return head1;

Node* head=NULL;

if(head1->data < head2->data){

head = head1;

head->next = Merge(head1, head2);

}else {

head = head2;

head->next = Merge(head1, head2);

}

return head;

}

2、非递归

Node* Merge(Node*head , Node* head1, Node* head2){

Node* tmp = head;

while(head1!=NULL&&head2!=NULL){

if(head1->data < head2->data){

tmp->next = head1;//指向head1当前结点

tmp = head1;//移动tmp的位置

head1 = head1->next;//head1后移

}else {

tmp->next = head2;

tmp = head2;

head2= head2->next;

}

}

if(head1==NULL)

tmp->next = head2;

if(head2==NULL)

tmp->next = head1;

return head;

}