链表各种操作

最简单的操作无非是以下几点：create　　search　　insert　　delete

1.创建一个列表并且遍历它，打印出各节点的值

struct node{    int data;    node* next;};node* init_node(int value){    node* head = new node();    head->data = value;    head->next = NULL;    return head;}void create_list(node* head,int value){    node* current_node = head;    node* new_node = init_node(value);    while(current_node->next!=NULL)    {        current_node = current_node->next;    }    current_node->next = new_node;}node* init_list(int* arr,int len){    node* head = init_node(0);    for(int i=0;i<len;i++)    {        create_list(head,arr[i]);    }    return head;}void list_traversal(node* head){    node* current_node = head;    while(current_node->next!=NULL)    {        current_node = current_node->next;        cout<<current_node->data<<" ";    }}

关于初始化过程，不要放在main函数中进行。

2.查找一个结点

void search_node(node* head,int value){    node* current_node = head;    while(current_node->data!=value && current_node->next!=NULL){        current_node = current_node->next;    }    if(current_node->data==value){        cout<<endl<<"search node data is "<<current_node->data<<endl;    }else{        cout<<endl<<value<<" is not in the list"<<endl;    }}

3.插入结点

当插入一个结点时，可以选择插入到当前结点的前面或者后面。

void insert_node_beforeVar(node* head,int var,int value){    node* current_node = head;    node* pre_node;    node* new_node = init_node(value);    while(current_node->data!=var && current_node->next!=NULL){        pre_node = current_node;        current_node = current_node->next;    }    if(current_node->data==var){        pre_node->next = new_node;        new_node->next = current_node;    }}void insert_node_behindVar(node* head,int var,int value){    node* current_node = head;    node* new_node = init_node(value);    while(current_node->data!=var && current_node->next!=NULL){        current_node = current_node->next;    }    if(current_node->data==var){        node* next_node = current_node->next;        current_node->next = new_node;        new_node->next = next_node;    }}

4.删除一个结点

void delete_node(node* head,int value){    node* current_node = head;    node* pre_node;     while(current_node->data!=value && current_node->next!=NULL){        pre_node = current_node;        current_node = current_node->next;    }    if(current_node->data==value){        node* next_node = current_node->next; //删除结点导致链表断开，因此要保存下一个结点        pre_node->next = next_node;        delete(current_node);    }}

下面总结下关于链表的各种算法，都是在平时做题时遇到的，参考了网上很多DS的杰作，在此感谢各位DS。

1.递归实现单链表逆置

tips：

（1）逆置不是指将原有链表逆序打印，逆置破坏了原有链表的结构；

（2）既然需要用递归实现，那首先要明白递归的本质。

　　我在接触递归时，常常纠结与递归的实现过程，根本没有理解递归的本质，我现在觉得，递归只需要关注以下几点：

• 算法是否可以用递归实现。感觉递归类似于循环，条件允许范围内一直做某事；
• 递归时，函数做了哪些操作
• 递归的终止条件

关于递归时入栈出栈说明就不长篇大论了。

node* list_reverse(node* head){    if(head==NULL || head->next==NULL)    return head;　　//每次函数执行时带来的next_node都依次入栈　　//最后栈顶保存的是原链表的最后一个结点    node* next_node = list_reverse(head->next);    head->next->next = head;    head->next = NULL;    return next_node;}

2.判断两个链表是否相交

思路：如果两个链表相交了，那么交点肯定在最后一个结点，因此问题转化为求链表最后一个结点。

各自求显得麻烦，可以先判断链表的长度，len1 和 len2，长的链表先走 | len1 - len2 |步，然后开始同时走。

int length_list(node* head){    int count=0;    node* current_node = head;    if(current_node==NULL)        return 0;    else if(current_node->next==NULL)        return 1;    else{        while(current_node->next!=NULL){            count++;            current_node = current_node->next;        }    }    return count;}void intersection_twoLists(node* head1,node* head2){    if(head1==NULL || head2==NULL)    return;    else{        int length1 = length_list(head1);        int length2 = length_list(head2);        int step;        if(length1 >= length2){            step = length1 - length2;            for(int i=1;i<=step;i++){                head1 = head1->next;            }        }else{            step = length2 - length1;            for(int i=1;i<=step;i++){                head2 = head2->next;            }        }        while(head1->next!=NULL && head2->next!=NULL){            head1 = head1->next;            head2 = head2->next;        }        if(head1->data == head2->data){            cout<<"intersection";        }else{            cout<<"not intersection";        }    }}

3.判断链表是否有环

（1）最简单的一种情况就是链表最后一个结点指向了head，如果最后一个结点指向了null，则没有环路，否则会一直绕圈圈。

void loop_list_VersionFirst(node* head){    node* current_node = head;    while(current_node->next!=NULL){        current_node = current_node->next;    }    if(current_node->next==head){        cout<<"has loop"<<endl;    }else{        cout<<"no loop"<<endl;    }}

（2）链表并非从一开始就进入环路，而是从中间某一结点开始

• 想法1：最笨的方法就是将current_node与之前的结点比较，如果发现曾经出现过，那么就存在环路。但这种方法需要将之前遍历过的结点全部保存下来，然后依次与当前结点进行比较，很麻烦。
• 想法2：p1->next , p2->next->next

假设链表有n个结点，未进入环路的结点有k个，则存在于环路中的结点为（n-k）个

现假设p1 p2都已经进入了环路，那么在t时刻，

p1->(v*t+1)%(n-k) 

p2->(2*v*t+1)%(n-k)

如果存在环路，则 (v*t+1)%(n-k) = (2*v*t+1)%(n-k)  在t 时刻，p1和p2相遇

bool hasLoop_list(node* head){    bool loop = false;    node* p1 = head;    node* p2 = head;    if(p1==NULL || p1->next==NULL || p1->next->next==NULL)        return false;    else{        while(p2->next!=NULL){            p1 = p1->next;            p2 = p2->next->next;        }        if(p1 == p2)            loop = true;    }    return loop;}

4.求链表的倒数第k个结点

这道题目可以转化为求正数第（n-k）个结点

int node_countFromEnd(node* head,int k){    int step = length_list(head)-k;    //cout<<length_list(head);    //cout<<"step is "<<step;    node* current_node_k = head;    for(int i=0;i<step;i++){        current_node_k = current_node_k->next;    }    return current_node_k->data;}

 5.单链表排序

如果直接对链表的元素进行排序，那就需要交换指针，这样会很麻烦，其实是我不擅于操作指针罢了，那么对于一个菜鸟来说，最方便的就是将链表中的元素放到数组中，然后再对数组中元素进行快排。但这样需要另外开辟空间。

首先附上快排的代码：

int middle_PathQucik(int* arr,int start_index,int end_index){    int i = start_index-1;    int flag = arr[end_index];    for(int j=start_index;j<end_index;j++){        if(arr[j]<flag){            i+=1;            int temp = arr[i];            arr[i] = arr[j];            arr[j] = temp;        }    }    int temp = arr[i+1];    arr[i+1] = arr[end_index];    arr[end_index] = temp;    return i+1;}void quick_sort(int* arr,int start_index,int end_index){    if(start_index>=end_index)    return;    int middle = middle_PathQucik(arr,start_index,end_index);    quick_sort(arr,start_index,middle-1);    quick_sort(arr,middle+1,end_index);}

我们仅需要做的就是将链表中元素放到数组中，然后数组再形成新的有序链表。

void list_sort(node* head){    node* current_node = head;    int length_arr = length_list(head);    int arr[length_arr];    for(int i=0;i<length_arr;i++){        current_node = current_node->next;        arr[i] = current_node->data;    }    quick_sort(arr,0,length_arr-1);    node* new_head = init_list(arr,length_arr);    list_traversal(new_head);}

 6.合并两个有序链表

这道题目就相当于把一个结点插入有序链表，时间复杂度为O（length1）+O（length2）

把一个结点插入有序链表的代码如下：

void elementInsertOrderList(node* head,int value){    node* current_node = head;    node* pre_node;    node* insert_node = init_node(value);    while(current_node->next!=NULL){        pre_node = current_node;        current_node = current_node->next;    }    if(current_node->data>=value){        pre_node->next = insert_node;        insert_node->next = current_node;    }else{        current_node->next=insert_node;    }    list_traversal(head);    cout<<endl;}

有了上述代码，合并两个有序链表就变得非常简单了。

void mergeTwoOrderLists(node* head1,node* head2){    node* current_node = head2;    int length2 = length_list(head2);    for(int i=0;i<length2;i++){        current_node = current_node->next;        elementInsertOrderList(head1,current_node->data);    }}

 6.删除当前current_node

与正常删除链表结点不同，这道题未提供头指针，所以比较有意思。

给出《编程之美》上的答案：

void delete_currentnode(node* current_node){    node* next_node = current_node->next;    current_node->data = next_node->data;    current_node->next = next_node->next;    delete(next_node);}

由于只知道current_node，它之前的结点无法得知，所以无法用pre_node->next = current_node->next;

但是可以用current_node->next = current_node->next->next; 即delete current_node->next

 换个思路，柳暗花明。