简单链表操作

#include<stdio.h>
#include<stdlib.h>
struct Demo
{
    int num;
    struct Demo * nextList;
};
typedef struct Demo LIT;
LIT* creatList(void);
LIT * creatsortList(void);
void destory1List(LIT* firstHead);
void destoryList(LIT* firstHead);
void printList1(LIT* firstHead);
void printList2(LIT* firstHead);
void reversePrintList(LIT* firstHead);
LIT* findList(LIT* firstHead, int value);
LIT * deleteList(LIT* firstHead, int value);
LIT * insertList(LIT * firstHead, int num);
LIT* findMax(LIT * firstHead);
LIT* reverseList(LIT * firstHead);//链表的逆序组织
LIT* reverList(LIT*firstHead, int s1, int t1, int s2, int t2);
int supList(LIT* firstA, LIT* firstB);//判断B是否是A的连续子序列 
LIT* findList2(LIT*firstHead, int index);//index为序号，以1开始

LIT* mergeSortList(LIT *first1, LIT *first2);
void findSite(LIT*headPtr, int value, LIT**prevoiusPtr, LIT**currentPtr);
int main()
{
    printf("please input nums:");
    /*LIT * first = NULL;
    first = creatList();//创造一个乱序的链表
    printList(first);//打印
    LIT* found =NULL;
    found = findList(first, 34);//在链表中找到34，并返回34对应的LIT地址
    first = deleteList(first, 45);//删除45
    printList(first);
    first = insertList(first ,35);//插入35
    */
    LIT* first1 = creatsortList();//创建一个有序链表
    printList2(first1);
    LIT* first2 = creatsortList();//创建一个有序链表
    printList2(first2);
    mergeSortList(first1, first2);
    printList2(first1);
    /*LIT* maxPtr = findMax(first);
    printf("\n%d", maxPtr->num);*/

    destoryList(first1);
    first1 = NULL;
    
    system("PAUSE");
    return 0;
}
LIT* creatList(void)
{
    int numd, n = 0;
    scanf("%d", &numd);
    LIT* fisrtHead = NULL;
    LIT* p1 = NULL;
    LIT* p2 = NULL;
    p1 = (LIT*)(malloc(sizeof(LIT)));
    p2 = (LIT*)(malloc(sizeof(LIT)));
    while (numd != -1)//读取数字，以-1结束,不将-1加入链表 
    {
        p1->num = numd;
        n++;//记录链表节点数 
        if (n == 1)//判断是否是头节点 
            fisrtHead = p1;//头节点赋给firstHead 
        else
            p2->nextList = p1;//将新节点与链表相连 
        p2 = p1;
        p1 = (LIT*)(malloc(sizeof(LIT)));//创建下一个节点 
        scanf("%d", &numd);
    }
    p2->nextList = NULL;//最末节点的nextList为NULL 
    return fisrtHead;
}

void destoryList1(LIT* firstHead)//逐个free链表的节点 
{
    LIT * temper = NULL;
    while (firstHead != NULL)
    {
        temper = firstHead;
        firstHead = firstHead->nextList;
        free(temper);
    }
}
void printList1(LIT* firstHead)//顺序
{
    if (firstHead == NULL)
    {
        printf("list null");
        return;
    }
    printf("Now print:");
    LIT *p1 = NULL;
    p1 = firstHead;
    while (p1 != NULL)
    {
        printf("%d  ", p1->num);
        p1 = p1->nextList;
    }
    printf(" NULL!\n");
}
void printList2(LIT* firstHead)
{
    if (firstHead != NULL)
    {
        printf("%d ", firstHead->num);
        printList2(firstHead->nextList);
    }
    else
        printf("NULL!\n");
}
void reversePrintList(LIT* firstHead)//强调的是逆序，倒着，不是大小
{
    if (firstHead != NULL)
    {
        reversePrintList(firstHead->nextList);
        printf("%d ", firstHead->num);
    }
}
void destoryList(LIT* firstHead)
{
    if (firstHead == NULL)
    {
        printf("list null!\n");
        return;
    }
    /*LIT *p1=NULL,*p2=NULL;
    p1 = firstHead->nextList;
    free(firstHead);
    while (p1 != NULL)
    {
        p2 = p1->nextList;
        free(p1);
        p1 = p2;
    }*/
    LIT * temper = NULL;
    while (firstHead != NULL)
    {
        temper = firstHead;
        firstHead = firstHead->nextList;
        free(temper);
    }
}
LIT* findList(LIT* firstHead, int value)
{
    if (firstHead == NULL)
    {
        printf("list null!\n");
        return firstHead;
    }
    LIT *p1 = firstHead;
    while (p1 != NULL && (p1->num) != value)
    {
        p1 = p1->nextList;
    }
    if (p1 != NULL)
        printf("\n%d be found!\n", p1->num);
    else
        printf("no find!\n");
    return p1;
}
LIT * deleteList(LIT* firstHead, int value)
{
    if (firstHead == NULL)
    {
        printf("list null");
        return firstHead;
    }
    LIT*p1 = NULL, *p2 = NULL;
    p1 = firstHead;
    while (p1->nextList != NULL && (p1->num) != value)
    {
        p2 = p1;
        p1 = p1->nextList;
    }
    if (p1->num == value)
    {
        if (p1 == firstHead)
            firstHead = p1->nextList;//first
        else
            p2->nextList = p1->nextList;//mid+last(p1->next==NULL)
        printf("delete:%d\n", value);
    }
    else
        printf(" no find!\n");
    return firstHead;
}
LIT * insertList(LIT * firstHead, int num)//（从小到大）顺序排列的插入
{
    LIT *stud = (LIT*)malloc(sizeof(LIT));
    if (num == -1)//-1结束 
        return firstHead;
    if (stud != NULL) //创建节点成功 ，则赋值 
    {
        stud->num = num;
        stud->nextList = NULL;
    }
    LIT *p1 = NULL;
    LIT *p2 = NULL;
    p1 = firstHead;//p1与firstHead 指向相同 ，用于不断nextList 找出需要的节点 
    if (firstHead == NULL)//头节点为NULL ，则stud作为新的头节点 
    {
        firstHead = stud;
        stud->nextList = NULL;
    }
    else
    {
        while ((stud->num > p1->num) && (p1->nextList != NULL))// 循环 找出可插入的节点位置 
        {
            p2 = p1;//p2为在循环时p1的上一节点 
            p1 = p1->nextList;
        }
        if (stud->num <= p1->num)
        {
            if (firstHead == p1)//first插入 
                firstHead = stud;
            else
                p2->nextList = stud;//mid插入 
            stud->nextList = p1;
        }
        else //last插入 ，作为末节点 
        {
            p1->nextList = stud;
            stud->nextList = NULL;
        }
    }
    return firstHead;
}
LIT* creatsortList(void)//创建一个顺序的链表（从小到大） 
{
    int num;
    LIT * firstHead = NULL;
    scanf("%d", &num);//读入num 
    while (num != -1)
    {
        firstHead = insertList(firstHead, num);//将num插入原链表里，并返回新的头节点 
        scanf("%d", &num);//循环读入num 
    }
    return firstHead;//返回头节点 
}
LIT* findMax(LIT * firstHead)//找到最大值所在节点
{
    LIT * maxPtr = NULL;
    if (firstHead->nextList == NULL)//最后一个节点返回firstHead 
        return firstHead;
    else
    {
        maxPtr = findMax(firstHead->nextList);//递归找出下一节点后的max 对应的节点 
        return maxPtr->num > firstHead->num ? maxPtr : firstHead;//比较当前节点的num与 macPtr指向的num，返回较大值的节点位置 
    }
}

LIT* findMin(LIT * firstHead)//找到最小值所在节点 
{
    LIT * minPtr = NULL;
    if (firstHead->nextList == NULL)//最后一个节点返回firstHead 
        return firstHead;
    else
    {
        minPtr = findMin(firstHead->nextList); //递归找出下一节点后的min 对应的节点 
        return minPtr->num < firstHead->num ? minPtr : firstHead;//比较当前节点的num与 macPtr指向的num，返回较小值的节点位置
    }
}

int totalList(LIT* firstHead)//求和 （num） 
{
    int sum = 0;
    while (firstHead != NULL)
    {
        sum += firstHead->num;
        firstHead = firstHead->nextList;
    }
    return sum;
}
LIT* reverseList(LIT * firstHead)//链表的逆序组织
{
    LIT* newHeader = NULL, *currentPtr = NULL;
    while (firstHead != NULL)
    {
        currentPtr = firstHead;
        firstHead = firstHead->nextList;
        if (newHeader == NULL)
        {
            newHeader = currentPtr;
            currentPtr->nextList = NULL;
        }
        else
        {
            currentPtr->nextList = newHeader;
            newHeader = currentPtr;
        }
    }
    return newHeader;
}
int supList(LIT* firstA, LIT* firstB)//判断B是否是A的连续子序列 
{
    LIT* p1 = firstB, *p2 = firstA;
    //记录最初的firstB,firstA
    while (firstA != NULL)//判断A是否能够容纳B(比B长) 
    {

        while ((firstA != NULL) && (firstB != NULL) && (firstA->num == firstB->num))//比对是否连续相等
        {
            firstA = firstA->nextList;
            firstB = firstB->nextList;
        }
        if (firstB == NULL)//B能成功遍历完
            return 1;
        else
        {
            firstB = p1;
            firstA = p2->nextList;
            p2 = firstA;
        }//重新从B的首节点开始
    }
    return 0;
}
int lengthList(LIT*firstHead)//链表长度 
{
    int n = 0;
    while (firstHead != NULL)
    {
        n++;
        firstHead = firstHead->nextList;
    }
    return n;
}


//实现交换此链表中任意指定的两段，第一段为[s1,t1]，第二段[s2,t2]。s1、t1、s2、t2代表链表的第几个节点，且满足s1<=t1，s2<=t2，t1<s2，s2一定小于等于链表节点的总个数
LIT* reverList(LIT*firstHead, int s1, int t1, int s2, int t2)
{
    LIT* s1ptr = findList(firstHead, s1);
    LIT* t1ptr = findList(firstHead, t1);
    LIT* s2ptr = findList(firstHead, s2);
    LIT* t2ptr = findList(firstHead, t2);
    LIT* s1suptr = findList(firstHead, s1 - 1);
    LIT* t1laptr = findList(firstHead, t1 + 1);
    LIT* s2suptr = findList(firstHead, s2 - 1);

    int len = lengthList(firstHead);
    if (s1 != 1 && t2 != len)
    {
        LIT* s1suptr = findList(firstHead, s1 - 1);
        LIT* t2laptr = findList(firstHead, t2 + 1);
        s1suptr->nextList = s2ptr;
        //s1前一个与s2相连 
        t1ptr->nextList = t2laptr;
        //t2后一个与t1相连 
    }
    else if (s1 == 1 && t2 != len)
    {
        LIT* t2laptr = findList(firstHead, t2 + 1);
        t1ptr->nextList = t2laptr;
        //t2后一个与t1相连 
        firstHead = s2ptr;//以s2为头节点 
    }
    else if (s1 != 1 && t2 == len)
    {
        LIT* s1suptr = findList(firstHead, s1 - 1);
        s1suptr->nextList = s2ptr;
        //s1前一个与s2相连 
        t1ptr->nextList = NULL;//以t1为尾节点 
    }
    else
    {
        t1ptr->nextList = NULL;//以t1为尾节点 
        firstHead = s2ptr;//以s2为头节点    
    }
    if ((t1 + 1) != s2)
    {
        t2ptr->nextList = t1laptr;
        //t1后一个与t2相连 
        s2suptr->nextList = s1ptr;
        //s2前一个与s1相连 
    }
    else
    {
        t2ptr->nextList = s1ptr;//t2与s1相连 
    }
    return firstHead;
}
LIT* findList2(LIT*firstHead, int index)
{
    int n = 1;
    while (firstHead != NULL && n < index)
    {
        n++;
        firstHead = firstHead->nextList;
    }
    return firstHead;
}
LIT* mergeSortList(LIT *first1, LIT *first2)
{
    LIT* left2Ptr, *previous1Ptr, *previous2Ptr, *current1Ptr, *current2Ptr;
    while (first2 != NULL)
    {
        left2Ptr = first2;
        previous1Ptr = NULL;
        previous2Ptr = NULL;
        current1Ptr = NULL;
        current2Ptr = NULL;
        findSite(first1, left2Ptr->num, &previous1Ptr, &current1Ptr);
        //从1中找到left2Ptr指向的首数字能插入的地方
        if (current1Ptr == NULL)//1都小于2,插入尾部
        {
            previous1Ptr->nextList = left2Ptr;
            first2 = NULL;
        }
        else
        {
            findSite(first2, current1Ptr->num, &previous2Ptr, &current2Ptr);
            //比较并确定链表2本次可归并的连续K个结点；这段结点由left2Ptr和previous2Ptr指向 
            if (current1Ptr == first1)//插入首部
            {
                (previous2Ptr)->nextList = first1;
                first1 = left2Ptr;
            }
            else//插中间
            {
                previous1Ptr->nextList = left2Ptr;
                previous2Ptr->nextList = current1Ptr;
            }
            first2 = current2Ptr;
        }
    }
    return first1;
}

void findSite(LIT*headPtr, int value, LIT**prevoiusPtr, LIT**currentPtr)//查找插入的位置，改变prePtr,currPtr,使value处在指向中间
{
    *prevoiusPtr = NULL;
    *currentPtr = headPtr;
    while ((*currentPtr != NULL) && (*currentPtr)->num < value)
    {
        *prevoiusPtr = *currentPtr;
        *currentPtr = (*currentPtr)->nextList;
    }
}