数据结构-单链表代码实现(C语言)

#include <stdio.h>

typedef struct ListNode
{
    int val;
    struct ListNode *pNext; //存放下一个节点的地址
    
}ListNode;

typedef struct List
{
    int length;
    ListNode* pHead;
}List;

void init(List &list)
{
    list.length = 0;
    list.pHead = NULL;
}

void destory(List &list)
{
    ListNode *p = list.pHead, *pNext = NULL;
    // 1. 确定边界条件
    // 2. 分情况讨论
    while(NULL != p)
    {
        pNext = p->pNext;
        delete p;
        p = pNext;
    }

    list.length = 0;
    list.pHead = NULL;
}
// getNode,如果index不是有效的，返回NULL
ListNode *getNode(List &list, int index)
{
    ListNode *p = NULL;
    if(index >= 0 && index < list.length)
    {
        int i = 0;
        p = list.pHead;

        while(i != index)
        {
            p = p->pNext;
            i++;
        }
    }
    return p;
}

int get(List &list, int index)
{
    ListNode *p = getNode(list, index);
    int n = 0;
    if(NULL != p)
    {
        n = p->val;
    }

    return n;
}

void set(List &list, int index, int value)
{
    ListNode *p = getNode(list, index);
    if(NULL != p)
    {
        p->val = value;
    }
}

// 空间换时间
int getLength(List &list)
{
    return list.length;
}

// 没找到返回NULL
ListNode *findNode(List &list, int value)
{
    ListNode *p = list.pHead;
    while(NULL != p)
    {
        if(p->val == value)
        {
            break;
        }
        p = p->pNext;
    }

    return p;
}

// 没找到返回-1
int find(List &list, int value)
{
    int pos = 0;
    ListNode *p = list.pHead;
    while(NULL != p)
    {
        if(p->val == value)
        {
            break;
        }
        pos++;
        p = p->pNext;
    }

    // 当找不到时，p走到链表尾部，此时对应的pos是 list.length 
    if(pos == list.length)
    {
        pos = -1;
    }

    return pos;
}

int prev(List &list, int index)
{
    return get(list, index-1);
}

ListNode *prevNode(List &list, ListNode *pCrt)
{
    if(NULL == pCrt)
    {
        return NULL;
    }

    ListNode *pPrev = list.pHead, *p = NULL;
    while(NULL != pPrev)
    {
        p = pPrev->pNext;
        if(p == pCrt)
        {
            break;
        }
        pPrev = p;
    }

    return pPrev;
}

int next(List &list, int index)
{
    return get(list, index+1);
}

ListNode *nextNode(ListNode *p)
{
    return p->pNext;
}

void insert(List &list, int index, int value)
{
    // 插在一个有效位置之后
    // 插在链表尾部
    if(index == -1 || index == list.length || index >= 0 && index < list.length)
    {
        ListNode *p = NULL;
        if(index >= 0 && index < list.length)
        {
            // 插到一个有效位置
            if(index == 0) 
            {
                //插在头部
                p = new ListNode;
                p->val = value;
                p->pNext = list.pHead;
                list.pHead = p;
            }
            else
            {
                //插在中间 你需要找到index的前一个ListNode
                ListNode *pPrev = getNode(list, index-1);
                p = new ListNode;
                p->val = value;
                p->pNext = pPrev->pNext;
                pPrev->pNext = p;
            }
        }
        else
        {
            // 插入尾部
            if(list.length != 0)
            {
                // 此时链表不空
                ListNode *pPrev = getNode(list, list.length-1);
                p = new ListNode;
                p->val = value;
                p->pNext = NULL;
                pPrev->pNext = p;
                
            }
            else
            {
                // 链表为空
                p = new ListNode;
                p->val = value;
                p->pNext = NULL;
                list.pHead = p;
            } 
        }
        list.length++;
    }
}

void remove(List &list, int index)
{
    // 判定index指向有效的Node
    if(index >= 0 && index < list.length)
    {
        ListNode *p = NULL;
        if(index != 0)
        {
            // 非头部
            ListNode *pPrev = getNode(list, index-1);
            p = pPrev->pNext;
            pPrev->pNext = p->pNext;
        }
        else
        {
            // 头部
            p = list.pHead;
            list.pHead = p->pNext;
        }
        delete p;
        list.length--;
        
    }
}

void traverse(List &list)
{
    ListNode *p = list.pHead, *pNext = NULL;
    while(NULL != p)
    {
        pNext = p->pNext;
        printf("%d ", p->val);
        p = pNext;
    }
    printf("\n");

}

int main()
{
    List list;
    init(list);
    insert(list, 0, 1);
    insert(list, 0, 2);
    insert(list, 1, -2);
    insert(list, -1, -5);
    insert(list, 5, -7);
    traverse(list);
    printf("%d, %d\n", find(list, 10), find(list, -5));
    remove(list, 0);
    traverse(list);
    destory(list);
    traverse(list);
    return 0;
}