链表的基本操作

最新推荐文章于 2018-06-07 20:17:57 发布

looz

最新推荐文章于 2018-06-07 20:17:57 发布

阅读量131

点赞数

本文链接：https://blog.csdn.net/lly17792230965/article/details/80509995

版权

#define _CRT_SECURE_NO_WARNINGS 1

#pragma once
// 值类型 
typedef int DataType;

typedef struct SListNode {
    DataType data; // 值 
    struct ListNode *pNext; // 指向下一个结点 
} SListNode;

// 初始化 
void SListInit(SListNode **ppFirst);

//创建结点
SListNode* Create(DataType data);


//打印函数
void print(SListNode** ppFirst);

// 尾部插入 
void SListPushBack(SListNode** ppFirst, DataType data);

// 头部插入 
void SListPushFront(SListNode **ppFirst, DataType data);

// 头部删除 
void SListPopFront(SListNode **ppFirst);

// 给定结点插入，插入到结点前 
void SListInsert(SListNode **ppFirst, SListNode *pPos, DataType data);

// 给定结点删除 
void SListErase(SListNode **ppFirst, SListNode *pPos);

// 按值删除，只删遇到的第一个 
void SListRemove(SListNode **ppFirst, DataType data);

// 按值删除，删除所有的 
void SListRemoveAll(SListNode **ppFirst, DataType data);

// 销毁 
void SListDestroy(SListNode **ppFirst);

// 按值查找，返回第一个找到的结点指针，如果没找到，返回 NULL 
SListNode *SListFind(SListNode *pFirst, DataType data);

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include"LinkList.h"


// 初始化 
void SListInit(SListNode **ppFirst)
{
    if (ppFirst == NULL)
    {
        return;
    }
    *ppFirst = NULL;
}

//创建结点
SListNode* Create(DataType data)
{
    SListNode *p = NULL;
    p = (SListNode*)malloc(sizeof(SListNode));
    p->data = data;
    p->pNext = NULL;
    return p;
}

//打印函数
void print(SListNode** ppFirst)
{
    if (ppFirst == NULL)
    {
        return;
    }
    SListNode* flag = *ppFirst;
    while (flag->pNext != NULL)
    {
        printf("%d ", flag->data);
        flag = flag->pNext;
    }
    printf("%d\n", flag->data);
}

// 尾部插入 
void SListPushBack(SListNode** ppFirst, DataType data)
{
    if (ppFirst == NULL)
    {
        return;
    }
    SListNode *flag = *ppFirst;//创建一个flag指针代替*ppFirst遍历链表
    if (*ppFirst == NULL)
    {
        *ppFirst = Create(data);//判断链表如果为空，直接创建结点
    }
    else
    {
        while (flag->pNext != NULL)//让flag找到两边的最后一个结点
        {
            flag = flag->pNext;
        }
        flag->pNext = Create(data);
    }
}

// 头部插入 
void SListPushFront(SListNode **ppFirst, DataType data)
{
    if (ppFirst == NULL)
    {
        return;
    }
    SListNode *NewNode = Create(data);
    NewNode->pNext = *ppFirst;
    *ppFirst = NewNode;
}

// 头部删除 
void SListPopFront(SListNode **ppFirst)
{
    if (ppFirst == NULL)
    {
        return;
    }
    if (*ppFirst == NULL)
    {
        return;
    }
    SListNode *NewNode = *ppFirst;
    *ppFirst = (*ppFirst)->pNext;
    free(NewNode);
    NewNode = NULL;
}

// 给定结点插入，插入到结点前 
void SListInsert(SListNode **ppFirst, SListNode *pPos, DataType data)
{
    if (ppFirst == NULL)
    {
        return;
    }
    SListNode *flag = *ppFirst;
    SListNode *NewNode = Create(data);
    if (*ppFirst == pPos)//如果要插入的结点是第一个结点
    {
        SListPushFront(ppFirst, data);
    }
    else
    {
        while (flag->pNext != pPos)
        {
            flag = flag->pNext;
            if (flag->pNext == NULL)
            {
                return;
            }
        }
        flag->pNext = NewNode;
        NewNode->pNext = pPos;
    }
}

// 给定结点删除 
void SListErase(SListNode **ppFirst, SListNode *pPos)
{
    if (ppFirst == NULL)
    {
        return;
    }
    if (*ppFirst == NULL)
    {
        return;//链表为空，直接返回
    }
    SListNode *flag = *ppFirst;
    if (*ppFirst == pPos)//判断要删除的是否为第一个结点
    {
        SListPopFront(ppFirst);
    }
    else
    {
        while (flag->pNext != pPos)
        {
            flag = flag->pNext;
            if (flag->pNext == NULL)
            {
                return;//没有找到pPOS直接返回
            }
        }
        flag->pNext = pPos->pNext;
        free(pPos);
        pPos = NULL;
    }
}

// 按值删除，只删遇到的第一个 
void SListRemove(SListNode **ppFirst, DataType data)
{
    if (ppFirst == NULL)
    {
        return;
    }
    if (*ppFirst == NULL)
    {
        return;//链表为空，直接返回
    }
    SListNode *flag = *ppFirst;
    SListNode *p = flag->pNext;
    if ((*ppFirst)->data == data)//判断要删除的是否为第一个结点
    {
        SListPopFront(ppFirst);
    }
    else {
        while (p->data != data)
        {
            flag = flag->pNext;
            p = p->pNext;
            if (flag->pNext == NULL)
            {
                return;//没有找到pPOS直接返回
            }
        }
        flag->pNext = p->pNext;
        free(p);
        p = NULL;
    }
}

// 按值删除，删除所有的 
void SListRemoveAll(SListNode **ppFirst, DataType data)
{
    if (ppFirst == NULL)
    {
        return;
    }
    if (*ppFirst == NULL)
    {
        return;//链表为空，直接返回
    }
    SListNode *flag = *ppFirst;
    SListNode *p = flag->pNext;
    if ((*ppFirst)->data == data)//判断要删除的是否为第一个结点
    {
        SListPopFront(ppFirst);
    }
    while (p != NULL)
    {
        if (p->data == data)
        {
            flag->pNext = p->pNext;
            p = p->pNext;
        }
        else {
            flag = flag->pNext;
            p = p->pNext;
        }
    }
    free(p);
    p = NULL;
}

// 销毁 
void SListDestroy(SListNode **ppFirst)
{
    if (ppFirst == NULL)
    {
        return;
    }
    if ((*ppFirst)->pNext == NULL)
    {
        return;
    }
    SListDestroy(&((*ppFirst)->pNext));
    free(*ppFirst);
    (*ppFirst) = NULL;
}

// 按值查找，返回第一个找到的结点指针，如果没找到，返回 NULL 
SListNode *SListFind(SListNode *pFirst, DataType data)
{
    if (pFirst == NULL)
    {
        return NULL;
    }
    SListNode *flag = pFirst;
    do{
        flag = flag->pNext;
        if (flag->data == data)
        {
            return flag;
        }
    } while (flag->pNext != NULL);
    return NULL;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"LinkList.h"

#define FUNHEAD printf("\n====================%s===================\n",__FUNCTION__);

//初始化测试函数
void TestInit()
{
    FUNHEAD;
    SListNode *pFirst;
    SListInit(&pFirst);
    printf("%p\n", pFirst);
}

//尾插测试函数
void TestPushBack()
{
    FUNHEAD;
    SListNode *pFirst;
    SListInit(&pFirst);
    SListPushBack(&pFirst, 1);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 5);
    SListPushBack(&pFirst, 7);
    print(&pFirst);
}

//头插测试函数
void TestPushFront()
{
    FUNHEAD;
    SListNode *pFirst;
    SListInit(&pFirst);
    SListPushBack(&pFirst, 1);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 5);
    SListPushFront(&pFirst, 7);
    print(&pFirst);
}

//头删测试函数
void TestPopFront()
{
    FUNHEAD;
    SListNode *pFirst;
    SListInit(&pFirst);
    SListPushBack(&pFirst, 1);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 5);
    SListPushBack(&pFirst, 7);
    SListPopFront(&pFirst);
    print(&pFirst);
}

// 给定结点插入，插入到结点前 
void TestInsert()
{
    FUNHEAD;
    SListNode *pFirst;
    SListInit(&pFirst);
    SListPushBack(&pFirst, 1);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 5);
    SListPushBack(&pFirst, 7);
    SListNode *pPos = pFirst->pNext;
    SListInsert(&pFirst, pPos, 9);
    print(&pFirst);
}

//给定结点删除
void TestErase()
{
    FUNHEAD;
    SListNode *pFirst;
    SListInit(&pFirst);
    SListPushBack(&pFirst, 1);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 5);
    SListPushBack(&pFirst, 7);
    SListNode *pPos = pFirst->pNext;
    SListErase(&pFirst, pPos);
    print(&pFirst);
}

// 按值删除，只删遇到的第一个
void TestRemove()
{
    FUNHEAD;
    SListNode *pFirst;
    SListInit(&pFirst);
    SListPushBack(&pFirst, 1);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 5);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 7);
    SListRemove(&pFirst, 3);
    print(&pFirst);
}

//按值删除，删除所有的
void TestRemoveAll()
{
    FUNHEAD;
    SListNode *pFirst;
    SListInit(&pFirst);
    SListPushBack(&pFirst, 1);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 5);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 7);
    SListRemoveAll(&pFirst, 7);
    print(&pFirst);
}

//销毁函数测试函数
void TestDestroy()
{
    FUNHEAD;
    SListNode *pFirst;
    SListInit(&pFirst);
    SListPushBack(&pFirst, 1);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 5);
    SListPushBack(&pFirst, 7);
    SListDestroy(&pFirst);
    printf("%p\n", pFirst);
}

//查找测试函数
void TestFind()
{
    FUNHEAD;
    SListNode *pFirst;
    SListNode *ret = NULL;
    SListInit(&pFirst);
    SListPushBack(&pFirst, 1);
    SListPushBack(&pFirst, 3);
    SListPushBack(&pFirst, 5);
    SListPushBack(&pFirst, 7);
    ret = SListFind(pFirst, 7);
    printf("%p\n", ret);
}


int main()
{
    TestInit();
    TestPushBack();
    TestPushFront();
    TestPopFront();
    TestInsert();
    TestErase();
    TestRemove();
    TestRemoveAll();
    TestDestroy();
    TestFind();
    system("pause");
    return 0;
}

looz

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
链表的基本操作

#define _CRT_SECURE_NO_WARNINGS 1#pragma once// 值类型 typedef int DataType;typedef struct SListNode { DataType data; // 值 struct ListNode *pNext; // 指向下一个结点 } SListNode;// 初始化 void SL...
复制链接

扫一扫