C++链表

链表操作总结：

               链表是一种重要的数据结构。它是动态分配存储的一种结构。它可以根据需要开辟存储单元。

链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素，链表中的每一个元素

称为“结点”，每个结点包含两部分：1.实际数据data   2.下一个结点的地址next。表尾的地址部分存放“NULL”.

表示链表到此结束。

     链表的各类操作包括：学习单向链表的创建、删除、  插入（无序、有序）、输出、  排序（选择、插入、冒泡）、反序等等。

      那么链表该如何遍历呢，遍历链表需要从头到尾，访问每一个元素，直到链表尾。也就是说不断地访问当前节点的next，直到NULL。下面是链表的遍历输出：

 

#include <iostream>
using namespace std;
class node
{
public:
	int value;
	node *next;
	node()
	{
		value = 0;
		next = NULL;
	}
};
int main()
{	
	node *head,*curr;
	head = new node();
	head->next = NULL;
	head->value = 15;
	for (size_t i = 0; i < 10; i++)
	{
		curr = new node();
		curr->value = i;
		curr->next = head;
		head = curr;
	}
	while (head!=NULL)
	{
		cout << head->value << endl;
		head = head->next;
	}
}

链表相对于数组有个非常明显的优点就是能以时间复杂度o(1)完成一个节点的插入或者删除操作。

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