单链表及其相关函数的使用

最新推荐文章于 2024-08-11 20:19:30 发布
weixin_34391445
最新推荐文章于 2024-08-11 20:19:30 发布
阅读量113
点赞数
文章标签：数据结构与算法 python
原文链接：https://my.oschina.net/crooner/blog/220495
版权
2019独角兽企业重金招聘Python工程师标准>>>
单链表使用的相关函数
#include <stdio.h>
#include <stdlib.h>

typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;

typedef int DataType; //类型定义
typedef struct node
{
    DataType data;
    struct node* next;
} LinkedNode;

/*创建LinkedList*/
LinkedNode *CreateLinkedList(void)
{
    LinkedNode *ll = (LinkedNode *)malloc(sizeof(LinkedNode));
    memset((uint8 *)&(ll->data), 0x00, sizeof(DataType));
    ll->next = NULL;
    return ll;
}

/*在末尾加节点*/
int AppendNodeLinkedList(LinkedNode *head, DataType dt)
{
    if(NULL == head)
        return -1;
    LinkedNode *curr_node = head;
    LinkedNode *new_node = NULL;
    while(curr_node->next != NULL)
    {
        curr_node = curr_node->next;
    }
    new_node = (LinkedNode *)malloc(sizeof(LinkedNode));
    memcpy((uint8 *)&(new_node->data), (uint8 *)&dt, sizeof(LinkedNode));
    new_node->next = NULL;
    curr_node->next = new_node;
    return 1;
}

/*正顺遍历所有节点*/
void VisitAllNode(LinkedNode *head)
{
    if(NULL == head)
        return;
    LinkedNode *currNode = head;
    printf("[");
    while(NULL != currNode)
    {
        printf("%d",currNode->data);
        currNode = currNode->next;
        if(NULL != currNode)
            printf(",");
    }
    printf("]\n");
}

/*逆置整个链表*/
int ReverseLinkedList(LinkedNode **head)
{
    if(NULL == (*head))
        return -1;//头指针为空
    LinkedNode *pre_node = *head;
    if(NULL == pre_node->next)
        return -2;//单节点链表不需要逆置
    LinkedNode *curr_node = pre_node->next;
    if(NULL == curr_node->next)
    {
        curr_node->next = pre_node;
        pre_node->next = NULL;
        *head = curr_node;
        return 1;//两个节点的链表，两两交换即可
    }
    //多于三个节点的链表
    LinkedNode *next_node = curr_node->next;
    pre_node->next = NULL;//头节点变尾节点
    while(NULL != next_node)
    {
        curr_node->next = pre_node;
        pre_node = curr_node;
        curr_node = next_node;
        next_node = next_node->next;
    }
    curr_node->next = pre_node;
    *head = curr_node;
    return 2;
}

/*删除pos上的节点*/
int DelNodeLinkedList(LinkedNode **head, int pos)
{
    if(NULL == (*head))
        return -1;
    LinkedNode *pre_node = *head;
    LinkedNode *curr_node = pre_node->next;
    LinkedNode *next_node = curr_node->next;
    if(NULL == curr_node && 0 == pos)
    {
        memset((uint8 *)&(pre_node->data),0x00, sizeof(DataType));
        free(pre_node);
        pre_node = NULL;
        *head = pre_node;
        return 1;
    }
    if(NULL != curr_node && NULL == next_node && 1 == pos)
    {
        memset((uint8 *)&(curr_node->data),0x00, sizeof(DataType));
        free(curr_node);
        curr_node = NULL;
        pre_node->next = NULL;
        return 2;
    }
    while(NULL != curr_node)
    {
        next_node = curr_node->next;
        if(pre_node == *head && 0 == pos)
        {
            memset((uint8 *)&(pre_node->data),0x00, sizeof(DataType));
            free(pre_node);
            pre_node = NULL;
            *head = curr_node;
            return 3;
        }
        if(1 == pos)
        {
            pre_node->next = next_node;
            memset((uint8 *)&(curr_node->data),0x00, sizeof(DataType));
            free(curr_node);
            curr_node = NULL;
            return 4;
        }
        pos--;
        pre_node = curr_node;
        curr_node = curr_node->next;
    }
    return 5;
}

/*取得LinkedList的长度*/
int GetLenLinkedList(const LinkedNode *head)
{
    if(NULL == head)
        return 0;
    int len = 0;
    const LinkedNode *curr_node = head;
    while(NULL != curr_node)
    {
        curr_node = curr_node->next;
        len++;
    }
    return len;
}

/*取得pos位置上的节点*/
LinkedNode *GetNodeLinkedList(LinkedNode *head, int pos)
{
    if(NULL == head)
        return NULL;
    LinkedNode *curr_node = head;
    while(NULL != curr_node && pos != 0)
    {
        curr_node = curr_node->next;
        pos--;
    }
    return curr_node;
}

/*在pos位置上设置值*/
int SetNodeLinkedList(const LinkedNode *head, int pos, DataType dt)
{
    if(NULL == head)
        return -1;
    const LinkedNode *curr_node = head;
    while(NULL != curr_node && pos != 0)
    {
        curr_node = curr_node->next;
        pos--;
    }
    memcpy((uint8 *)&(curr_node->data), (uint8 *)&dt, sizeof(DataType));
    return 1;
}

/*用于排序函数的规则制定*/
int GetSortRule(DataType dt1, DataType dt2)
{
    if(dt1 > dt2)
        return 1;
    else if(dt1 < dt2)
        return -1;
    else
        return 0;
}

/*
对链表排序
从小到大，GetSortRule:dt1>dt2,ret=1; dt1<dt2,ret=-1; dt1==dt2,ret=0;
从大到小，GetSortRule:dt1>dt2,ret=-1; dt1<dt2,ret=1; dt1==dt2,ret=0;
*/
int SortLinkedList(LinkedNode *head, int (*GetSortRule)(DataType dt1, DataType dt2))
{
    if(NULL == head)
        return -1;
    LinkedNode *pre_node = head;
    LinkedNode *curr_node = head;
    LinkedNode *out_node = head;
    while(NULL != out_node)
    {
        while(NULL != curr_node)
        {
            if((*GetSortRule)(pre_node->data, curr_node->data) > 0)
            {
                DataType tmp;
                memcpy((uint8 *)&(tmp), (uint8 *)&(pre_node->data), sizeof(DataType));
                memcpy((uint8 *)&(pre_node->data), (uint8 *)&(curr_node->data), sizeof(DataType));
                memcpy((uint8 *)&(curr_node->data), (uint8 *)&(tmp), sizeof(DataType));
            }
            pre_node = curr_node;
            curr_node = curr_node->next;
        }
        out_node = out_node->next;
        pre_node = head;
        curr_node = head;
    }
    return 0;
}

/*类memcpy操作,连接新链*/
int CpyLinkedList(LinkedNode **dest_head, LinkedNode *src_head)
{
    if(NULL == (*dest_head) || NULL == src_head)
        return -1;
    LinkedNode *dest_curr_node = *dest_head;
    LinkedNode *dest_head_node = *dest_head;
    LinkedNode *src_curr_node = src_head;
    LinkedNode *src_head_node = src_head;
    while(NULL != src_curr_node->next)
    {
        src_curr_node = src_curr_node->next;
    }
    if(NULL == dest_head_node->next)
    {
        dest_head_node->next = src_head_node;
        *dest_head = dest_head_node;
        return 1;
    }
    dest_curr_node = dest_curr_node->next;
    dest_head_node->next = src_head_node;
    src_curr_node->next = dest_curr_node;
    *dest_head = dest_head_node;
    return 2;
}

/*逆向遍历(效率较低)*/
int ReVisitAllNode(LinkedNode *head)
{
    if(NULL == head)
        return -1;
    LinkedNode *curr_node = head;
    LinkedNode *out_node = head;
    int len = GetLenLinkedList(curr_node);
    int i = 0;
    printf("[");
    for(i = len-1; i >= 0; i--)
    {
        curr_node = head;
        out_node = GetNodeLinkedList(curr_node, i);
        printf("%d",out_node->data);
        if(out_node != head)
            printf(",");
    }
    printf("]\n");
    return 1;
}

/*单链表成环*/
int LinkLinkedList(LinkedNode *head)
{
    if(NULL == head)
        return -1;
    LinkedNode *curr_node = head;
    while(NULL != curr_node->next)
    {
        curr_node = curr_node->next;
    }
    curr_node->next = head;
    return 1;
}

/*单链表解环*/
int UnLinkLinkedList(LinkedNode *head)
{
    if(NULL == head)
        return -1;
    LinkedNode *curr_node = head;
    while(head != curr_node->next)
    {
        curr_node = curr_node->next;
    }
    curr_node->next = NULL;
    return 1;
}


int main()
{
    LinkedNode *pln = CreateLinkedList();
    AppendNodeLinkedList(pln, 11);
    AppendNodeLinkedList(pln, 22);
    AppendNodeLinkedList(pln, 33);
    
    printf("normal ord:");
    VisitAllNode(pln);
    
    printf("reverse1:");
    ReverseLinkedList(&pln);
    VisitAllNode(pln);
    
    printf("del:");
    DelNodeLinkedList(&pln, 0);
    VisitAllNode(pln);
    
    printf("LinkedList Len = %d\n",GetLenLinkedList(pln));
    
    printf("LinkedList[%d].data = %d\n",2, GetNodeLinkedList(pln, 2)->data);
    
    SetNodeLinkedList(pln, 1, 99);
    printf("LinkedList[%d].data = %d\n",1, GetNodeLinkedList(pln, 1)->data);
    
    printf("del:");
    VisitAllNode(pln);
    
    printf("sort:");
    SortLinkedList(pln, GetSortRule);
    VisitAllNode(pln);
    
    LinkedNode *pln2 = CreateLinkedList();
    AppendNodeLinkedList(pln2, 66);
    AppendNodeLinkedList(pln2, 77);
    
    //插入新链
    LinkedNode *tmp = GetNodeLinkedList(pln, 1);
    CpyLinkedList(&tmp, pln2);
    tmp = NULL;
    printf("new linkedlist:");
    VisitAllNode(pln);
    
    printf("re-visit linkedlist:");
    ReVisitAllNode(pln);
    
    LinkLinkedList(pln);
    //VisitAllNode(pln);
    UnLinkLinkedList(pln);
    VisitAllNode(pln);
    
    return 0;
}
转载于:https://my.oschina.net/crooner/blog/220495