单链表

包含的操作

1. 创建单链表和销毁单链表
2. 插入元素和删除元素
3. 打印第k个结点和倒数第K个元素
4. 顺时针打印和逆时针打印
5. 单链表求长度
6. 合并两个单链表
7. 单链表逆转
8. 单链表排序

Linklist.h

#ifndef LINKLIST_H_INCLUDED
#define LINKLIST_H_INCLUDED

struct LinkListNode
{
    int value;
    LinkListNode* next;
};

typedef LinkListNode node;
typedef LinkListNode* phead;

/*
    创建单链表和销毁单链表
*/
phead CreateLinkList();
void DestroryLinkList(phead head);

/*
    插入元素和删除元素
*/
phead InsertNode(phead head,int value,int index);
void DeleteNode(phead* head,int val);
void InsertNode_2(phead* head,int value,int index);

/*
    打印第k个结点和倒数第K个元素
*/
void PrintNode(phead head);
void PrintReverseNode(phead head);

/*
    顺时针打印和逆时针打印
*/
void PrintTheKthNumber(phead head,int k);
void PrintTheKthNumberToTail(phead head,int k);

/*
    单链表求长度
*/
int LengthOfLinklist(phead head);

/*
    合并两个单链表
*/
phead MergeLinkList(phead head_1,phead head_2);

/*
    单链表逆转
*/
phead ReverseLinkList(phead head);
/*
    单链表排序
*/
phead LinklistSort(phead head);
#endif // LINKLIST_H_INCLUDED

linklist.cpp

#include "LinkList.h"
#include <cstdio>
#include <malloc.h>
#include <iostream>
using namespace std;
/*
    创建单链表和销毁单链表
*/
phead CreateLinkList()
{
    cout<<"create node...."<<endl;
    int value;
    phead head = (phead)malloc(sizeof(node));
    if(head==nullptr)
    {
        cout<<"Malloc Error...."<<endl;
        exit(EXIT_FAILURE);
    }
    head->value = -1;
    phead current = head, newNode = NULL;
    while(scanf("%d",&value)!=EOF)
    {
        newNode = (phead)malloc(sizeof(node));
        newNode->value = value;

        current->next = newNode;
        current = newNode;
        current->next = nullptr;
    }
    return head;
}
void DestroryLinkList(phead head)
{
    phead temp;
    while(head!=nullptr)
    {
        temp = head;
        head = head->next;
        free(temp);
    }
    cout<<"\nDestory finished..."<<endl;
}

/*
    插入元素和删除元素
*/
phead InsertNode(phead head,int value,int index)
{
    if(head==nullptr)
        return head;
    if(index <1 && index>LengthOfLinklist(head))
        return head;
    phead newnode = (phead)malloc(sizeof(node));
    newnode->value = value;
    phead temp_1= head,temp_2 = head->next;
    for(int i = 0; i<index; i++)
    {
        temp_1 = temp_1->next;
        temp_2 = temp_2->next;
    }
    temp_1->next = newnode;
    newnode->next = temp_2;

    return head;
}

/*
利用二级指针删除和插入元素，不用考虑插入和删除的位置
*/
void InsertNode_2(phead* head,int value,int index)
{
    if(index <1 && index>LengthOfLinklist(*head))
        exit(EXIT_FAILURE);
    phead newnode = (phead)malloc(sizeof(node));
    newnode->value = value;
    int n = 0;
    phead current = *head;
    while ((current = *head)!=NULL && n<index)
    {
        head = ¤t->next;
        n++;
    }
    *head = newnode;
    newnode->next = current;
}
void DeleteNode(phead* head,int val)
{
    if(*head==nullptr)
        return ;
    phead current = *head;
    while ((current = *head)!=NULL && current->value !=val)
    {
        head = ¤t->next;
    }
    //*head 保存的是地址
    *head = current->next;
    free(current);
}

/*
    单链表求长度
*/
int LengthOfLinklist(phead head)
{
    phead temp = head;
    int length = 0;
    while(temp!=nullptr)
    {
        length++;
        temp = temp->next;
    }
    return length;
}
/*
    顺时针打印和逆时针打印
*/
void PrintNode(phead head)
{
    phead temp = head;
    while(temp!=nullptr)
    {
        cout<<temp->value<<"\t";
        temp = temp->next;
    }
    cout<<endl;
}
void PrintReverseNode(phead head)
{
    if(head !=nullptr)
    {
        if(head->next!=nullptr)
            PrintReverseNode(head->next);
    }
    cout<<head->value<<"\t";
}

/*
    打印第k个结点和倒数第K个元素
*/
void PrintTheKthNumber(phead head,int k)
{
    if(head==nullptr)
        return;
    if(k<=0 || k>LengthOfLinklist(head))
        return ;
    phead temp = head;
    int i = 0;
    while(temp!=nullptr && i<k)
    {
        i++;
        temp = temp->next;
    }
    cout<<temp->value<<endl;
}
void PrintTheKthNumberToTail(phead head,int k)
{
    if(head==nullptr)
        return;
    if(k<=0 || k>LengthOfLinklist(head))
        return;
    phead pslow = head,pfast = head;

    for(unsigned int i = 0; i<k-1; i++)
    {
        pfast = pfast->next;
    }
    while(pfast->next!=nullptr)
    {
        pslow = pslow->next;
        pfast = pfast->next;
    }
    cout<<pslow->value<<endl;
}



/*
    合并两个有序单链表
*/
phead MergeLinkList(phead head_1,phead head_2)
{
    if(head_1==nullptr)
        return head_2;
    if(head_2==nullptr)
        return head_1;
    phead newhead = nullptr;

    if(head_1->value < head_2->value)
    {
        newhead = head_1;
        newhead->next = MergeLinkList(head_1->next,head_2);
    }
    else
    {
        newhead = head_2;
        newhead->next = MergeLinkList(head_1,head_2->next);
    }
    return newhead;
}

/*
    单链表逆转
    定义三个指针，分别指向当前结点，当前结点的前一个结点，当前结点的后一个结点

*/
phead ReverseLinkList(phead head)
{
    phead preNode = nullptr; //当前结点的前一个结点
    phead pnode = head; //当前结点
    phead pReverseHead = nullptr;//链表重置后的新的头结点
    phead pnext = nullptr; //当前结点的后一个结点
    while(pnode!=nullptr)
    {
        pnext = pnode->next;

        if(pnext==nullptr) //当前结点是尾结点
            pReverseHead = pnode;
        pnode->next = preNode;//将当前结点的下一个结点指向他的前一个结点

        preNode = pnode;
        pnode = pnext;
    }

    return pReverseHead;
}
/*
    单链表归并排序,将链表等分，知道每一个里面只有一个结点
*/
phead LinklistSort(phead head)
{
    if(head==nullptr || head->next==nullptr)
        return head;
    phead slow = head,fast = head;

    //找到单链表的中间结点
    while(fast->next != NULL && fast->next->next != NULL)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    phead leftHead = head, rightHead = slow->next;
    slow->next = NULL;      //需要把左半链表的尾结点的next赋空值，所以用一个变量来记录右半链表的头

    leftHead  = LinklistSort(leftHead);
    rightHead = LinklistSort(rightHead);

    return MergeLinkList(leftHead, rightHead);
}

main.cpp

#include <iostream>
#include "LinkList.h"
using namespace std;


int main()
{
    phead head = CreateLinkList();
    PrintNode(head);
    //cout<<"\n"<<LengthOfLinklist(head)<<endl;

    //InsertNode(head,100,2);
    //InsertNode_2(&head,100,2);
    //PrintNode(head);
    //PrintReverseNode(head);
    //DeleteNode(&head,5);
    //PrintNode(head);

    //PrintTheKthNumber(head,10);
    //PrintTheKthNumberToTail(head,10);

/*
    cout<<"--------reverse........"<<endl;
    phead temp = ReverseLinkList(head);
    PrintNode(temp);*/
    cout<<"--------sort........"<<endl;
    phead temp_1 = LinklistSort(head);
    PrintNode(temp_1);
    DestroryLinkList(head);
    return 0;
}