数据结构——单链表(链表操作算法集合)

这里整合了数据结构书中关于单链表的所有操作，另外附带常用的单链表操作，算是一个比较全的单链表操作集合吧。对于带头结点的单链表、循环单链表、双链表只给出基本操作，复杂的操作跟这里的单链表差不多。
需要注意的一点：
单链表中一个很重要的方法就是快慢指针：比如求单链表的中间节点，求单链表是否有环，求单链表倒数第K个节点（两个指针相隔K，一起移动）等都用到快慢指针。
感觉概念什么的没什么好啰嗦的，直接看实现：

数据结构

typedef struct LinkList{    datatype info;    struct LinkList* next;}Node;

基本操作

基本操作都比较简单，关键是要注意边界问题，代码不做过多注释

1. 初始化

Node* init_link_list(){    return NULL;}

2. 打印

void print_link_list(Node* head){    if (!head)        printf("the linklist is null.");    Node* p = head;    while(p)    {        printf("%5d",p->info);        p = p->next;    }    printf("\n");}

3. 头结点插入

Node* insert_in_front_link_list(Node* head, datatype x){    Node* p;    p = (Node*)malloc(sizeof(Node));    p->info = x;    p->next = head->next;    head = p;    return head;}

4. 尾节点插入

Node* insert_in_last_link_list(Node* head, datatype x){    Node* p;    Node* px = (Node*)malloc(sizeof(Node));    px->info = x;    if (!head)    {        head = px;        px->next = NULL;    }else{        p = head;        while(p->next)            p = p->next;        p->next = px;        px->next = NULL;    }    return head;}

5. 查找x节点

Node* find_num_link_list(Node* head, datatype x){    Node* p;    p = head;    while(p && p->info != x)        p = p->next;    return p;}

6.找到i位置的节点

Node* find_pos_link_list(Node* head, int i){    if (i < 1)        return NULL;    Node* p = head;    while(p&&i--) p = p->next;    return p;}

7. 在y后面插入x

Node* insert_x_after_y(Node* head, datatype x, datatype y){    Node* px,*p;    if (head == NULL)        return NULL;    p = head;    while(p && p->info != y)        p = p->next;    if (p == NULL) //没有找到y        return NULL;    px = (Node*)malloc(sizeof(Node));    px->info = x;    px->next = p->next;    p->next = px;    return head;}

8. 在第i处后面插入x

Node* insert_x_after_i(Node* head, datatype x, int i){    Node* p,*px;    if (head == NULL || i < 1)        return NULL;    p = head;    while(p && i--)        p = p->next;    if (p == NULL) //没有找到y        return NULL;    px = (Node*)malloc(sizeof(Node));    px->info = x;    px->next = p->next;    p->next = px;    return head;}

9. 删除x

Node* delete_num_link_list(Node* head, datatype x){    Node*p,*pre;    if (head == NULL)        return NULL;    p = head;    pre = NULL;    while(p && p->info != x){        pre = p;        p = p->next;    }    if (p == NULL)        return NULL;    if (pre == NULL && p->info == x) //第一个节点        head = head->next;    else        pre->next = p->next;    free(p);    return head;}

10. 删除i处的元素

Node* delete_pos_link_list(Node* head, int i){    Node* p,*pre;    if (head == NULL || i < 1)    {        return NULL;    }    p = head; pre = NULL;    if (i == 1)    {        head = head->next;    }    else    {        while(p && i--)        {            pre = p;            p = p->next;        }        if (p == NULL) //i大于链表长度            return NULL;        pre->next = p->next;    }    free(p);    return head;}

常用操作

1. 判断单链表节点值是否有序

int is_ordered(Node* head){    Node* p,*q;    if (!head)        return -1;    p = head;q= head->next;    bool flag_increase = false;    bool flag_decrease = false;    while(q){        if (p->info < q->info)            flag_increase =true;        else if(p->info > q->info)            flag_decrease = true;        if (flag_decrease && flag_increase)            return 0;        p = q;q = q->next;    }    return 1;}

2. 单链表就地转置

Node* reverse_link_list(Node* head){    if(!head) return NULL;    Node* pre,*cur,*rear;    cur = head;    pre = rear = NULL;    while(cur->next){        rear = cur->next;        cur->next = pre;        pre = cur;        cur = rear;    }    cur->next = pre;    return cur;}Node* reverse_link_list2(Node* head){    Node* p,*q;    if (!head)        return NULL;    q = head->next;    if(!q)        return head;    p = head;    head = reverse_link_list2(q);    q->next = p;    p->next = NULL;    return head;}void reverse_link_list3(Node* pcur, Node* head){    if (!pcur || !pcur->next){        head = pcur;    }else{        Node* pnext = pcur->next;        reverse_link_list3(pnext,head);        pnext->next = pcur;        pcur->next = NULL;    }}//栈实现void reverse_link_list4(Node* head){    Node* stack[100];    int top = -1;    Node *p;    p = head;    if (!p || !p->next){        return p;    }    else{        while(p){          stack[++top] = p;          p = p->next;        }        head->next = NULL; //头结点指向NULL        head = stack[top]; //头结点指向尾结点        while(top > 0){            p = stack[top--];            p->next = stack[top];        }        return head;    }}

3. 单链表节点个数

int link_list_num(Node* head){    Node* p;    int num;    if (!head)        return NULL;    p = head;    num = 0;    while(p){        p= p->next;        num++;    }    return num;}

4. 单链表中倒数第k个节点；两个指针，第一个先走K步，然后一起走，当第一个指针到尾时，第二个指针即倒数第k

Node* get_last_k(Node* head, int k){    Node* p1,*p2;    if(!head)        return NULL;    p1 = p2 = head;    while(p2){        p2 = p2->next;        if (k>0)            k--;        else            p1 = p1->next;    }    if (k > 0)        return NULL;    return p1;}

5. 查找节点的中间节点,偶数时指向前面那个；两个指针，一个一次走一步，一个走两步，到尾。

Node* get_middle(Node* head){    if (!head || !head->next)        return NULL;    Node* p1,*p2;    p1 = p2 = head;    while(p2->next){        p2 = p2->next;        if (p2->next)        {            p2 = p2->next;            p1 = p1->next;        }    }    return p1;}

6.从头到尾打印单链表；递归和栈

void back_order_print(Node* head){    Node* p = head;    if (!p->next)    {        printf("%5d",p->info);    }else{        back_order_print(p->next);        printf("%5d",p->next->info);    }}void back_order_print2(Node* head){    int size = 10;    int* stk = new int[size];    int top = 0;    Node* p = head;    while(p){        if (! (top%10)) //两倍内存增加        {            int* temp = new int[size*2];            for(int i = 0;i<size;i++)                temp[i] = stk[i];            delete stk;            stk = temp;            size = size*2;        }        stk[top++] = p->info;        p = p->next;    }    while(top--){        printf("%5d", stk[top]);    }    printf("\n");}

7. 合并有序单链表,从小到大

Node* Merge_link_list(Node* head1, Node* head2){    Node* p1,*p2;    Node* new_head,*p;    if (!head1){        return head2;    }    if (!head2){        return head1;    }    p1 = head1;    p2 = head2;    if (p1->info < p2->info){        new_head = p = p1;        p1 = p1->next;    }else{        new_head = p = p2;        p2 = p2->next;    }    while(p1&&p2){        if (p1->info < p2->info){            p->next = p1;            p1 = p1->next;            p = p->next;        }else{            p->next = p2;            p2 = p2->next;            p = p->next;        }    }    if (!p1){        p->next = p1;    }else if (!p2){        p->next = p2;    }    return new_head;}

8. 判断单链表是否有环；两个指针，一个走一步，一个两步，若有环，则两个会相等。

int has_circle(Node* head){    if (!head){        return -1;    }    Node* p1,*p2;    p1 = p2 =head;    while(p2->next)    {        p2 = p2->next;        if (!p2->next)            return 0;        else            p2 = p2->next;        p1 = p1->next;        if (p1 == p2)            return 1;    }    return 0;}

9. 判断两个单链表是否相交；若相交，最后一个节点的地址一定相同。

int is_intersected(Node* head1, Node* head2){    if (!head1 || !head2)        return -1;    Node*p1,*p2;    p1 = head1;    p2 = head2;    while(p1->next)        p1 = p1->next;    while(p2->next)        p2 = p2->next;    if (&p2 == &p1)        return 1;    else        return 0;}

10. 给出一单链表头指针pHead和一节点指针pToBeDeleted，O(1)时间复杂度删除节点pToBeDeleted

//把前一个节点的值复制到当前节点，然后删除后面这个，但是考虑尾节点，需要O(n)。Node* delete_node(Node*head, Node* pdeleted){    if (!head || !pdeleted)        return NULL;    Node* temp;    if (pdeleted->next) //包含删除的是第一个的情况    {        pdeleted->info = pdeleted->next->info;        temp = pdeleted->next;        pdeleted->next = pdeleted->next->next;        delete temp;temp = NULL;    }else{        temp = head;        if (head == pdeleted)        {            head = NULL;        }else{            while(temp->next->next){                temp = temp->next;            }            temp->next = NULL;        }        delete pdeleted;    }}

11.判断单链表是进环的第一个点

//1.先获得快慢指针相交点，这时相交点到目标点与头点到目标点的距离相同。Node* getfirstnode(Node* head){    Node*fast,*slow;    fast = slow = head;    while(fast->next && slow)    {        fast = fast->next->next;        slow = slow->next;    }    if (fast != slow)    {        return NULL;    }    slow = head;    while(slow != fast)    {        slow = slow->next;        fast = fast->next;    }    return fast;}

12.两个链表相交，找出交点

//1.先求两链表的长a，b。a>b,先将a移动a-b下，然后两个链表一起走，判断。//2.先将两个链表入栈s1,s2，然后出栈，判断。Node* intersect_node(Node* p1,Node *p2){    stack<Node*> s1;    stack<Node*> s2;    while(p1)    {        s1.push(p1);        p1= p1->next;    }    while(p2)    {        s2.push(p2);        p2=p2->next;    }    while(s1.top() == s2.top())    {        s1.pop();        s2.pop();    }    return s1.top()->next;}

数据结构中熟练操作单链表，非常重要，动手写可能会写得出来，但是思路不一定是优秀的，这是我的体会。