51. 实现对 有头单链表 的基本操作 包括创建，插入，查找，删除，求长，销毁，正逆遍历，逆置，排序

 

 

#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
    int data;
    struct node *next;
}Node;

 

//创建一个带头结点的空链表
int createList(Node ** head)
{
    *head = (Node*)malloc(sizeof(Node));
    if(*head == NULL)
    {
        return -1;
    }
    else
    {
        (*head)->next = NULL;
        return 0;
    }
}

 

//尾插1 //找前驱节点方式
void insertList_end(Node *head,int data)
{
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;


    while(head->next)
    {
        head = head->next;
    }

    head->next = newNode;
    newNode->next = NULL;
}

 

 

//尾插2 
//找待插入的空间地址，也就是前驱节点的next成员所在的内存空间
//这种方式更适合操作无头节点的链表
void insertList_end(Node *head, int data)
{
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;

    Node** p = &(head->next);//最符合逻辑的初始化写法
   // Node** p = &head;
    while(*p)//遍历到待插入的地址结束。
    {
        p = &((*p)->next);
    }
    *p = newNode;
}

 

 

 

//头插1
void insertList_head(Node *head,int data)
{
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;

    newNode->next = head->next;
    head->next = newNode;
}

 

//头插2 //这个方式用在有头链表头插上就有点脱裤子放屁了。但还是写一写好了
//这个方式适合用于无头链表的头插
void insertList_head(Node *head, int data)
{
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;

    Node **p = &(head->next);
    newNode->next = (*p);
    *p = newNode;
}

 

//查找1
//功能：返回待查找节点的地址，不存在返回NULL
Node* searchList(Node *head,int findData)
{
#if 1
    head = head->next;
    while(head)
    {
        if(head->data == findData)
        {
            return head;
        }
        head = head->next;
    }
    return NULL;
#endif

#if 0//只是做了点优化
    head = head->next;
    while(head)
    {
        if(head->data == findData)
        {
            break;
        }
        head = head->next;
    }
    return head;//因为没找到head会==NULL时结束循环，找到会跳出循环，所以上面两个return可以合为一个

#endif
}







//删除1 //遍历到前驱节点
//功能:已有待删除节点的地址，实现删除此节点的操作
void deleteNodeList1(Node* head,Node *deleteNode)
{
    while(head->next != deleteNode)//遍历到前驱节点
    {
        head = head->next;
    }
    head->next = deleteNode->next;
    free(deleteNode);
}


//删除1.1 //对删除1的优化版，无需遍历。
//功能：已有待删除节点的地址，实现删除此节点的操作，优化版
//优化的原理是后驱节点的所有数据覆盖拷贝到待删除节点，再删除后驱节点。不需再遍历
//但是特殊情况是如果待删除节点为尾节点并没有后驱节点，所以需要分两种情况。
void deleteNodeList2(Node* head,Node *deleteNode)
{
    Node* postNode = deleteNode->next;
    if(postNode)
    {
        deleteNode->data = postNode->data;
        deleteNode->next = postNode->next;
        free(postNode);
    }
    else
    {
        while(head->next != deleteNode)//遍历到前驱节点
        {
            head = head->next;
        }
        head->next = deleteNode->next;
        free(deleteNode);
    }

}

 

 

//查找2
//功能：返回待查找节点的前驱节点的地址。方便后来的操作
//注意点，如果不存在待查找节点，那更不存在前驱节点了，直接返回NULL
//另外，此方式只适合有头链表，不适合无头链表，因为如果无头链表第一个有效节点没前驱节点。
Node* searchListPre(Node *head,int findData)
{
   while(head->next)
   {
       if(head->next->data == findData)
       {
           return head;
       }
       head = head->next;
   }
   return NULL;
}


//删除2
//功能：已有待删除节点的前驱节点的地址，实现删除此待删节点的操作
//需配合返回前驱节点的查找函数
//只适合有头链表
void deleteNodeList3(Node *deleteNodePre)
{
    Node* deleteNode = deleteNodePre->next;
    deleteNodePre->next = deleteNode->next;
    free(deleteNode);

}

 

 

//查找3
//返回待查找节点的所在的挂载空间的地址，(挂载空间里存储的"待查找节点的首地址")(挂载空间也就是前驱节点的next成员所在的空间),如果不存在此节点，返回NULL
Node** searchList(Node *head,int findData)
{
    Node **p = &(head->next);
    while(*p)
    {
        if((*p)->data == findData)
            return p;

        p = &((*p)->next);
    }
    return NULL;
}

//删除3
void deleteNodeList(Node **deleteNode)
{
    Node* temp = *deleteNode;
    *deleteNode = (*deleteNode)->next;
    free(temp);
}

//逆置链表
//方法为拆分为两个链表,一个包含头结点的空链表A,一个是不带头结点的链表B。，
//从链表B里从头到尾取节点，用头插法将节点依次插入到链表A中。
void reverseList(Node * head)
{
    //无头链表B
    Node* headB = head->next;

    //有头空链表A
    head->next = NULL;
    Node* headA = head;

    while(headB)
    {
        Node* newNode = headB;
        headB = headB->next;
        newNode->next = headA->next;
        headA->next = newNode;
    }
}

 

 

//求链表长度
int getLenList(Node* head)
{
    head = head->next;
    int len = 0;
    while(head)
    {
        len++;
        head= head->next;
    }
    return len;
}

 

 

//清空链表 留头节点释放删除掉所有有效节点，只留头结点
void clearList(Node* head)
{
    Node* temp = head->next;
    head->next = NULL;

    while(temp)
    {
        Node* p = temp;
      //  free(p);
        temp = temp->next;
        free(p);
    }
}

 

 

//销毁链表 释放删除掉所有节点，包括头结点
//头结点被销毁后，调用函数中头指针应该置为NULL，相当于修改了其指向，因此需要使用二级指针参数。
void destroyList(Node** head)
{
    while(*head)//循环结束会为NULL
    {
        Node* temp = *head;
        *head = (*head)->next;

        free(temp);
    }
}

 

 

//销毁链表 释放删除掉所有节点，包括头结点
//头结点被销毁后，调用函数中头指针应该置为NULL，相当于修改了其指向，因此需要使用二级指针参数。
void destroyList(Node** head)
{
    while(*head)//循环结束会为NULL
    {
        Node* temp = *head;
        *head = (*head)->next;

        free(temp);
    }
}

 

 

 

//对链表排序，使用选择排序
/*-------------------使用选择排序--------------------*/
//对数据域进行交换1   套用选择排序模板
void selectSortDataUp(Node* head)//升序
{
    int i,j;
    int len = getLenList(head);
   // printf("len = %d\n",len);
    Node* cur = head;
    Node* post = NULL;


    for(i = 0;i<len-1;i++)
    {
        cur = cur->next;
        post = cur->next;
        for(j = i+1;j<len;j++)
        {
            if(cur->data > post->data)
            {
#if 0
                Node temp;
                temp.data = cur->data;
                cur->data = post->data;
                post->data = temp.data;
#endif
#if 1
                int temp;
                temp = cur->data;
                cur->data = post->data;
                post->data = temp;
#endif

            }
            post = post->next;
        }
    }
}

//对数据域进行交换2  判NULL方式
void selectSortDataDown(Node* head)//降序
{
    Node *Nodei,*Nodej;
    for(Nodei = head->next ; Nodei->next ; Nodei = Nodei->next)
    {
        for(Nodej = Nodei->next; Nodej ;Nodej = Nodej->next)
        {
            if(Nodei->data < Nodej->data)
            {
                int temp = Nodei->data;
                Nodei->data = Nodej->data;
                Nodej->data = temp;
            }
        }
    }
}


//对数据域进行交换2.1 选择排序的优化，比而不换，只记下标，比完再换。
void selectSortDataDown2(Node* head)//降序
{
    Node *Nodei,*Nodej;
    Node *idx;
    for(Nodei = head->next ; Nodei->next ; Nodei = Nodei->next)
    {
        idx = Nodei;
        for(Nodej = Nodei->next; Nodej ;Nodej = Nodej->next)
        {
            if(idx->data < Nodej->data)
            {
                 idx = Nodej;
            }
        }
        if(idx != Nodei)
        {
            Nodei->data ^= idx->data;
            idx->data ^= Nodei->data;
            Nodei->data ^= idx->data;
        }

    }
}


//对指针域进行交换，调整节点在链表结构中的挂载顺序
//i,j,iPre,jPre,都是指向一个节点的，打断重连时并没有改其指向，所以重连后，这四个指针仍旧指向原先的节点。
//始终保持让i指向左位置，j指向右位置
void selectSortPointer(Node* head)//升序
{
    Node* i;
    Node* j;
    Node* iPre;
    Node* jPre;
    for(iPre = head,i = head->next;i->next;iPre = iPre->next,i = iPre->next)
    {
        for(jPre = i,j = jPre->next;j;jPre = jPre->next,j = jPre->next)
        {
            if(i->data > j->data)
            {
                if(jPre == i)
                {
                    iPre->next = j;
                    Node* temp = j->next;
                    j->next = i;
                    i->next = temp;

                    i = iPre->next;
                    jPre = i;
                }
                else
                {
                    iPre->next = j;
                    Node* temp = j->next;
                    j->next = i->next;
                    jPre->next = i;
                    i->next = temp;

                    i = iPre->next;
                }
            }
        }
    }
}

 

 

//对链表排序，使用选择排序
//对数据域进行交换1     套用冒泡排序模板
void bubbleSortDataUp(Node* head)//升序
{
    int i,j;
    int len = getLenList(head);
    Node* cur = NULL;
    for(i = 0;i<len-1;i++)
    {
        cur = head->next;
        for(j=0;j<len-1-i;j++)
        {
            if(cur->data > cur->next->data)
            {
                cur->data ^= cur->next->data;
                cur->next->data ^= cur->data;
                cur->data ^= cur->next->data;
            }
            cur = cur->next;
        }
    }
}


//对数据域进行交换1.1 优化版，已序而不排
void bubbleSortDataUp2(Node* head)
{
    int i,j;
    int len = getLenList(head);
    Node* cur = NULL;
    int doswap;//
    for(i = 0;i<len-1;i++)
    {
        doswap = 0;//
        cur = head->next;
        for(j=0;j<len-1-i;j++)
        {
            if(cur->data > cur->next->data)
            {
                doswap = 1;//

                cur->data ^= cur->next->data;
                cur->next->data ^= cur->data;
                cur->data ^= cur->next->data;

            }
            cur = cur->next;
        }
        if(doswap == 0)//
            break;
    }
}

//对数据域进行交换2   判NULL方式没法实现



//对指针域排序
void bubbleSortPointer(Node* head)//升序
{
    int len = getLenList(head);
    int m,n;
    Node *i = head->next;
    Node *j = i->next;
    Node *iPre = head;
    for(m = 0;m<len-1;m++)
    {
        for(n = 0;n<len-1-m;n++)
        {
            if(i->data > j->data)
            {
                iPre->next = j;
                Node* temp = j->next;
                j->next = i;
                i->next = temp;

                i = iPre->next;
                j = i->next;
            }

            iPre = iPre->next;
            i = iPre->next;
            j = i->next;
        }

        iPre = head;
        i = iPre->next;
        j = i->next;
    }
}

 

 

 

//正序打印链表
void traverseList(Node* head)
{
    head = head->next;
    while(head)
    {
        printf("%d ",head->data);
        head = head->next;
    }
}



//逆序打印链表
void traverseList2(Node* head)
{
    if(head->next == NULL)
    {
        return;
    }
    else
    {
        head = head->next;
        traverseList2(head);
        printf("%d ",head->data);
    }
}

 

 

 

 

int main(void) //测试，均通过QT测试通过。
{
    Node * listhead;
    int res = createList(&listhead);
    if(res == 0)
    {
        printf("create succeed\n");
    }
    else
    {
        printf("create error\n");
        exit(-1);
    }
    int i;
    for(i = 0; i<5;i++)
    {
      //  insertList_end(listhead,i);
        insertList_head(listhead,i);
    }

    traverseList(listhead);putchar(10);

#if 0
    Node* findNode = searchList(listhead,3);
    if(findNode)
        printf("%d\n",findNode->data);
    else
        printf("There is no such node\n");
#endif
#if 0
    Node* findNodePre = searchListPre(listhead,3);
    Node* findNode = findNodePre->next;
    if(findNode)
        printf("%d\n",findNode->data);
    else
        printf("There is no such node\n");
#endif

#if 0
    Node** findNode = searchList(listhead,3);
    if(findNode)
        printf("%d\n",(*findNode)->data);
    else
        printf("There is no such node\n");
#endif
#if 0
    Node* findNode = searchList(listhead,3);
    if(findNode)
        deleteNodeList2(listhead,findNode);
    traverseList(listhead);putchar(10);
#endif

#if 0
    Node* findNodePre = searchListPre(listhead,3);
    if(findNodePre)
        deleteNodeList3(findNodePre);
    traverseList(listhead);putchar(10);
#endif

#if 0
    Node** findNode = searchList(listhead,3);
    if(findNode)
        deleteNodeList(findNode);
    traverseList(listhead);putchar(10);

#endif

#if 0
    reverseList(listhead);
    traverseList(listhead);putchar(10);
#endif

#if 0
    printf("len = %d\n",getLenList(listhead));
#endif

#if 0
    clearList(listhead);
//    traverseList(listhead);putchar(10);
    for(i = 7; i<15;i++)
    {
        insertList_end(listhead,i);
      //  insertList_head(listhead,i);
    }
    traverseList(listhead);putchar(10);

#endif

#if 0
    destroyList(&listhead);
    printf("listhead = %d",listhead);

#endif

#if 0
    traverseList2(listhead);putchar(10);
#endif

#if 0

  //  selectSortDataUp(listhead);
 //   selectSortDataDown(listhead);
    selectSortDataDown2(listhead);
    traverseList(listhead);putchar(10);

#endif

#if 0
    bubbleSortDataUp2(listhead);
    traverseList(listhead);putchar(10);
#endif

#if 0
    selectSortPointer(listhead);
    traverseList(listhead);putchar(10);

#endif
#if 1
    bubbleSortPointer(listhead);
    traverseList(listhead);putchar(10);

#endif


    return 0;
}