20160225.CCPP体系详解(0035天)

Posted 2022-08-28 尹成

程序片段(01):CircleList.h+CircleList.c+main.c
内容概要:环形链表

///CircleList.h
#pragma once
#include <stdio.h>

typedef struct node

    int data;
    struct node * pNext;
Node;

void circleListTailInsertData(Node ** ppCircleList, int data);
void circleListHeadInsertData(Node ** ppCircleList, int data);

void showCircleList(Node * pCircleList);

Node * circleListSelectFirstData(Node * pCircleList, int data);

void circleListRandInsertData(Node ** ppCircleList, int data, int insertData);

void circleListDeleteFirstData(Node ** ppCircleList, int data);

int countCircleList(Node * pCircleList);

Node * circleListGetEndNode(Node ** ppCircleList, int num);

///CircleList.c
#include "CircleList.h"
#include <stdlib.h>

void circleListHeadInsertData(Node ** ppCircleList, int data)

    if (NULL == ppCircleList)
        abort();
    Node * pNew = (Node *)malloc(sizeof(Node));
    pNew->data = data;
    pNew->pNext = *ppCircleList;
    *ppCircleList = pNew;


void circleListTailInsertData(Node ** ppCircleList, int data)

    if (NULL == ppCircleList)
        abort();
    Node *pNew = (Node *)malloc(sizeof(Node));
    pNew->data = data;
    pNew->pNext = NULL;
    if (NULL == *ppCircleList)
    
        *ppCircleList = pNew;
        pNew->pNext = *ppCircleList;
        return;
    
    Node * pTemp = *ppCircleList;
    while (*ppCircleList != pTemp->pNext)
    
        pTemp = pTemp->pNext;
    
    pTemp->pNext = pNew;
    pNew->pNext = *ppCircleList;


void showCircleList(Node * pCircleList)

    //方式一:空节点环+单节点环+多节点环
    if (NULL == pCircleList)
        abort();
    //方式二:
    Node * pTmp = pCircleList;
    do
    
        printf("%3d", pTmp->data);
        pTmp = pTmp->pNext;
     while (pCircleList != pTmp);
    printf("\\n");


void circleListRandInsertData(Node ** ppCircleList, int data, int insertData)

    if (NULL == ppCircleList || NULL == *ppCircleList)
        return;
    int find = 0;
    Node * pTmp1 = NULL;
    Node * pTmp2 = *ppCircleList;
    do
    
        if (data == pTmp2->data)
        
            find = 1;
            break;
        
        pTmp1 = pTmp2;
        pTmp2 = pTmp2->pNext;
     while (*ppCircleList != pTmp2);
    if (!find)
        return;
    Node * pNew = (Node *)malloc(sizeof(Node));
    pNew->data = insertData;
    //前插逻辑:
    //if (*ppCircleList == pTmp2)
    //
    //  pNew->pNext = *ppCircleList;
    //  Node * pTmp = *ppCircleList;
    //  while (*ppCircleList != pTmp->pNext)
    //  
    //      pTmp = pTmp->pNext;
    //  
    //  *ppCircleList = pNew;
    //  pTmp->pNext = *ppCircleList;
    //  return;
    //
    //pTmp1->pNext = pNew;
    //pNew->pNext = pTmp2;
    //后插逻辑:
    pNew->pNext = pTmp2->pNext;
    pTmp2->pNext = pNew;


Node * circleListSelectFirstData(Node * pCircleList, int data)

    if (NULL == pCircleList)
        abort();
    Node * pTmp = pCircleList;
    do
    
        if (data == pTmp->data)
        
            return pTmp;
        
        pTmp = pTmp->pNext;
     while (pCircleList != pTmp);
    return NULL;


void circleListDeleteFirstData(Node** ppCircleList, int data)

    if (NULL == ppCircleList || NULL == *ppCircleList)
        return;
    int find = 0;
    Node * pTmp1 = NULL;
    Node * pTmp2 = *ppCircleList;
    do
    
        if (data == pTmp2->data)
        
            find = 1;
            break;
        
        pTmp1 = pTmp2;
        pTmp2 = pTmp2->pNext;
     while (*ppCircleList != pTmp2);
    if (!find)
        return;
    if (*ppCircleList == pTmp2 && NULL == pTmp2->pNext)
    
        *ppCircleList = NULL;
        free(pTmp2);
        return;
    
    if (*ppCircleList == pTmp2 && NULL != pTmp2->pNext)
    
        Node * pTmp = *ppCircleList;
        while (*ppCircleList != pTmp->pNext)
        
            pTmp = pTmp->pNext;
        
        *ppCircleList = (*ppCircleList)->pNext;
        pTmp->pNext = *ppCircleList;
        free(pTmp2);
        return;
    
    pTmp1->pNext = pTmp2->pNext;
    free(pTmp2);


int countCircleList(Node * pCircleList)

    if (NULL == pCircleList)
        abort();
    if (pCircleList == pCircleList->pNext)
    
        return 1;
    
    int nodeNum = 0;
    Node * pTmp = pCircleList;
    do
    
        ++nodeNum;
        pTmp = pTmp->pNext;
     while (pCircleList != pTmp);
    return nodeNum;


Node * circleListGetEndNode(Node ** ppCircleList, int num)

    Node * pTmp = *ppCircleList;
    Node * pFree = NULL;
    while (1 != countCircleList(*ppCircleList))
    
        for (int i = 0; i < num; ++i)
        
            pFree = pTmp = pTmp->pNext;
        
        pTmp = pTmp->pNext;
        circleListDeleteFirstData(ppCircleList, pFree->data);
    
    return *ppCircleList;

///main.c
#include "CircleList.h"
#include <stdlib.h>
#include <time.h>

int main01(void)

    Node * pCircleList = NULL;
    //srand((unsigned int)time(NULL));
    //for (int i = 0; i < 10; ++i)
    //
    //  circleListTailInsertData(&pCircleList, rand() % 99 + 1);
    //
    circleListTailInsertData(&pCircleList, 1);
    circleListTailInsertData(&pCircleList, 2);
    circleListTailInsertData(&pCircleList, 3);
    circleListTailInsertData(&pCircleList, 6);
    circleListTailInsertData(&pCircleList, 5);
    circleListTailInsertData(&pCircleList, 4);
    //circleListDeleteFirstData(&pCircleList, 4);
    //printf("nodeNum = %d \\n", countCircleList(pCircleList));
    //circleListRandInsertData(&pCircleList, 3, 7);
    showCircleList(pCircleList);
    //printf("%3d \\n", circleListSelectFirstData(pCircleList, 1)->data);

    system("pause");


int main02(void)

    Node * pCircleList = NULL;
    srand((unsigned int)time(NULL));
    for (int i = 0; i < 10; ++i)
    
        circleListTailInsertData(&pCircleList, rand() % 99 + 1);
    
    showCircleList(pCircleList);
    printf("endData = %d \\n", circleListGetEndNode(&pCircleList, 3)->data);

    system("pause");

程序片段(02):Mem.h+Mem.c+mallocfree.c
内容概要:内存链式管理

///Mem.h
#pragma once

#include <stdlib.h>

void * myMalloc(size_t size);
void myFree(void * pStart);
void * myRealloc(void * pStart, size_t size);

typedef struct

    int size;//内存尺寸
    void * pStart;//内存起始
Mem;

typedef struct node

    Mem * pMem;//数据域
    struct node * pNext;//指针域
Node;

Node * pLinkList;

void linkListTailInsertData(Node ** ppLinkList, Mem * pMem);

void showLinkList(Node * pLinkList);

Node * linkListSelectFirstData(Node * pLinkLIst, void * pStart);

void linkListDeleteFirstData(Node ** ppLinkList, void * pMem);

void linkListClear(Node ** ppLinkList);

void linkListUpdateFirstData(Node * pLinkList, void * pOldStart, Mem * pNewMem);

void showLinkListInfo(Node * pLinkList);

///Mem.c
#include "Mem.h"
#include <stdlib.h>
#include <stdio.h>

void * myMalloc(size_t size)

    void * pStart = malloc(size);
    printf("分配的内存地址为:%p,内存尺寸为:%d \\n",pStart, size);
    Mem * pMem = (Mem *)malloc(sizeof(Mem));
    pMem->pStart = pStart;
    pMem->size = size;
    linkListTailInsertData(&pLinkList, pMem);
    return pStart;


void myFree(void * pStart)

    printf("内存地址:%p处开始释放! \\n", pStart);
    Node * pMem = linkListSelectFirstData(pLinkList, pStart);
    if (NULL == pMem)
        return;
    linkListDeleteFirstData(&pLinkList, pMem);
    free(pMem);


void * myRealloc(void * pStart, size_t size)

    void * pTmp = realloc(pStart, size);
    Mem mem;
    mem.pStart = pTmp;
    mem.size = size;
    linkListUpdateFirstData(pLinkList, pStart, &mem);
    printf("内存地址为:%p的内存重新分配到内存地址为:%p,尺寸为%d! \\n", pStart, pTmp, size);
    return pTmp;


void linkListTailInsertData(Node ** ppLinkList, Mem * pMem)

    if (NULL == ppLinkList)
        abort();
    Node * pNew = (Node *)malloc(sizeof(Node));
    pNew->pMem = pMem;
    pNew->pNext = NULL;
    if (NULL == *ppLinkList)
    
        *ppLinkList = pNew;
    
    else
    
        Node * pTmp = *ppLinkList;
        while (NULL != pTmp->pNext)
        
            pTmp = pTmp->pNext;
        
        pTmp->pNext = pNew;
    


void showLinkList(Node * pLinkList)

    if (NULL == pLinkList)
        abort();
    printf("MemAddr:%p, MemSize:%d \\n", pLinkList->pMem->pStart, pLinkList->pMem->size);
    showLinkList(pLinkList->pNext);


Node * linkListSelectFirstData(Node * pLinkList, void * pStart)

    if (NULL == pLinkList)
        abort();
    for (Node * pTmp = pLinkList; NULL != pTmp; pTmp = pTmp->pNext)
    
        if (pStart == pTmp->pMem->pStart)
        
            return pTmp;
        
    
    return NULL;


void linkListDeleteFirstData(Node ** ppLinkList, void * pStart)

    if (NULL == ppLinkList || NULL == *ppLinkList)
        abort();
    int find = 0;
    Node * p1 = NULL;
    Node * p2 = *ppLinkList;
    while (NULL != p2)
    
        if (pStart == p2->pMem->pStart)
        
            find = 1;
            break;
        
        p1 = p2;
        p2 = p2->pNext;
    
    if (!find)
        return;
    if (*ppLinkList == p2)
    
        *ppLinkList = p2->pNext;
        free(p2);
        return;
    
    p1->pNext = p2->pNext;
    free(p2);


void linkListClear(Node ** ppLinkList)

    if (NULL == ppLinkList)
        abort();
    if (NULL == *ppLinkList)
        abort();
    Node * p1 = NULL;
    Node * p2 = *ppLinkList;
    while (NULL != p2->pNext)
    
        p1 = p2;
        p2 = p2->pNext;
        free(p1->pMem->pStart);
        free(p1);
    
    free((*ppLinkList)->pMem->pStart);
    free(*ppLinkList);


void linkListUpdateFirstData(Node * pLinkList, void * pOldStart, Mem * pMem)

    if (NULL == pLinkList)
        abort();
    for (Node * pTmp = pLinkList; NULL != pTmp; pTmp = pTmp->pNext)
    
        if (pOldStart == pTmp->pMem->pStart)
        
            pTmp->pMem->pStart = pMem->pStart;
            pTmp->pMem->size = pMem->size;
            return;
        
    


void showLinkListInfo(Node * pLinkList)

    int addrNum = 0;
    int memSize = 0;
    for (Node * pTmp = pLinkList; NULL != pTmp; pTmp = pTmp->pNext)
    
        ++addrNum;
        memSize += pTmp->pMem->size;
        printf("第%2d块儿内存,内存地址:%p,内存尺寸:%d! \\n", addrNum, pTmp->pMem->pStart, pTmp->pMem->size);
    
    printf("本程序手动开辟了%d块儿内存,总计占用%d字节的堆内存! \\n", addrNum, memSize);

///mallocfree.c
#include "mem.h"

//01.在当前文件当中生效的宏定义
//  1.宏名替换使用(原始习惯保留)
//  2.注意该宏定义的劫持范围为本文件
#define malloc myMalloc
#define free myFree
#define realloc myRealloc

//02.劫持特点:
//  1.劫持函数
//  2.劫持类型
//注:可以采用函数包装的方式实现劫持效果!
int main01(void)

    int a;
    int * p;
    void * p1 = malloc(1024 * 1024 * 100);
    void * p2 = malloc(1024 * 1024 * 100);
    void * p3 = malloc(1024 * 1024 * 100);
    void * p4 = malloc(1024 * 1024 * 100);
    showLinkListInfo(pLinkList);
    realloc(p1, 1024 * 1024 * 200);
    showLinkListInfo(pLinkList);
    free(p2);
    free(p2);
    free(10003);
    showLinkListInfo(pLinkList);
    linkListClear(pLinkList);
    showLinkListInfo(pLinkList);

    system("pause");

程序片段(03):Stack.h+Stack.c+linkstack.c
内容概要:正向链式栈

///Stack.h
#pragma once 

//01.与栈结构相关的概念:
//  1.按实现数据结构的不同:
//      (1).数组栈+链表栈
//      (2).两种结构的异同点:
//          数组栈:定长
//          链表栈:变长
//  2.按照实现原理的不同:
//      (1).正向栈+反向栈
//      (2).两种结构的异同点:
//          正向栈:一直都是尾插法+获取栈顶数据+数据量可控
//          反向栈:一直都是头插法+获取栈底数据+数据量不可控
#define DT int

//02.链表当中的每个节点
//  所存储的数据内容自定义
typedef struct node

    int id;//节点编号
    DT data;//数据域
    struct node *pNext;//指针域
Node;

void initStack(Node ** ppStack);
void showStack(Node * pStack);
void pushStack(Node ** ppStack, int id, DT data);
void popStack(Node ** ppStack, Node * pData);
void clearStack(Node ** ppStack);

///Stack.c
#include "Stack.h"
#include <stdlib.h>
#include <stdio.h>

void initStack(Node ** ppStack)

    if (NULL == ppStack)
        abort();
    //初始化栈结构
    *ppStack = NULL;
    //初始化首节点
    //(*ppStack)->id = 0;
    //(*ppStack)->data = 0;
    //(*ppStack)->pNext = NULL;


void showStack(Node * pStack)

    //if (NULL == pStack)
    //  abort();
    //for (Node * pTmp = pStack; NULL != pTmp; pTmp = pTmp->pNext)
    ////循环方式
    //  printf("id:%3d---data:%3d", pTmp->id, pTmp->data);
    //
    if (NULL == pStack)
        return;
    printf("id:%3d---data:%3d", pStack->id, pStack->data);
    showStack(pStack->pNext);


void pushStack(Node ** ppStack, int id, DT data)

    if (NULL == ppStack)
        abort();
    Node * pNew = (Node *)malloc(sizeof(Node));
    pNew->id = id;
    pNew->data = data;
    pNew->pNext = NULL;
    if (NULL == *ppStack)
    
        *ppStack = pNew;
        return;
    
    Node * pTmp = *ppStack;
    while (NULL != pTmp->pNext)
    
        pTmp = pTmp->pNext;
    
    pTmp->pNext = pNew;


void popStack(Node ** ppStack, Node * pData)

    if (NULL == ppStack)
        abort();
    if (NULL == (*ppStack)->pNext)
    
        pData->id = (*ppStack)->id;
        pData->data = (*ppStack)->data;
        free(*ppStack);
        *ppStack = NULL;
        return;
    
    Node * pTmp = *ppStack;
    while (NULL != pTmp->pNext->pNext)
    
        pTmp = pTmp->pNext;
    
    pData->id = pTmp->pNext->id;
    pData->data = pTmp->pNext->data;
    free(pTmp->pNext);
    pTmp->pNext = NULL;


void clearStack(Node ** ppStack)

    if (NULL == ppStack)
        abort();
    if (NULL == *ppStack)
        return;
    Node * p1 = NULL;
    Node * p2 = *ppStack;
    while (NULL != p2->pNext)
    
        p1 = p2;
        p2 = p2->pNext;
        free(p1);
    
    *ppStack = NULL;

///linkstack.c
#include "Stack.h"
#include <stdlib.h>
#include <stdio.h>

void decToBin(int decValue)

    if (0 == decValue)
        return;
    decToBin(decValue / 2);
    printf("%d", decValue % 2);


int main01(void)

    //decToBin(1000);

    Node * pStack = NULL;
    initStack(&pStack);
    int decValue = 1000;
    while (decValue)
    
        pushStack(&pStack, 0, decValue % 2);
        decValue /= 2;
    
    while (NULL != pStack)
    
        Node  tmp;
        popStack(&pStack, &tmp);
        printf("%d", tmp.data);
    
    printf("\\n");
    clearStack(&pStack);

    decValue = 1000;
    while (decValue)
    
        pushStack(&pStack, 0, decValue % 2);
        Node tmp;
        popStack(&pStack, &tmp);
        printf("%d", tmp.data);
        decValue /= 2;
    
    printf("\\n");

    system("pause");


int main02(void)

    Node * pStack = NULL;
    initStack(&pStack);
    int decValue = 10;
    while (decValue)
    
        pushStack(&pStack, 0, decValue % 2);
        decValue /= 2;
    
    while (pStack)
    
        Node tmp;
        popStack(&pStack, &tmp);
        printf("%d", tmp.data);
    

    system("pause");

程序片段(04):Stack.h+Stack.c+main.c
内容概要:反向链式栈

///Stack.h
#pragma once

#define DT int 

typedef struct node

    int id;
    int data;
    struct node * pNext;
Node;

void initStack(Node ** ppStack);

void showStack(Node * pStack);

void pushStack(Node ** ppSack, int id, DT data);

void popStack(Node ** ppStack, Node * pNode);

void clearStack(Node ** ppStack);

///Stack.c
#include "Stack.h"
#include <stdlib.h>
#include <stdio.h>

void initStack(Node ** ppStack)

    if (NULL == ppStack)
        abort();
    *ppStack = NULL;


void showStack(Node * pStack)

    if (NULL == pStack)
        abort();
    for (Node * pTmp = pStack; NULL != pTmp; pTmp = pTmp->pNext)
    
        printf("%d", pTmp->data);
    
    printf("\\n");


void pushStack(Node ** ppStack, int id, DT data)

    if (NULL == ppStack)
        abort();
    Node * pNew = (Node *)malloc(sizeof(Node));
    pNew->id = id;
    pNew->data = data;
    pNew->pNext = NULL;
    if (NULL == *ppStack)
    
        *ppStack = pNew;
        return;
    
    pNew->pNext = *ppStack;
    *ppStack = pNew;


void popStack(Node ** ppStack, Node * pData)

    if (NULL == ppStack)
        abort();
    if (NULL == *ppStack)
        return;
    pData->id = (*ppStack)->id;
    pData->data = (*ppStack)->data;
    if (NULL == (*ppStack)->pNext)
    
        *ppStack = NULL;
        free(*ppStack);
        return;
    
    Node * pTmp = *ppStack;
    *ppStack = (*ppStack)->pNext;
    free(pTmp);


void clearStack(Node ** ppStack)

    if (NULL == ppStack)
        abort();
    if (NULL == *ppStack)
        return;
    Node * p1 = NULL;
    Node * p2 = *ppStack;
    for (Node * pTmp = *ppStack; NULL != pTmp; pTmp = pTmp->pNext)
    
        p1 = p2;
        p2 = p2->pNext;
        free(p1);
    
    *ppStack = NULL;

///main.c
#include "Stack.h"
#include <stdlib.h>
#include <stdio.h>

void decToBin(int decValue)

    if (0 == decValue)
        return;
    decToBin(decValue /= 2);
    if (0 != (decValue /= 2))
    
        printf("%d", decValue %= 2);
    


int main(void)

    //decToBin(1000);

    Node * pStack = NULL;
    initStack(&pStack);
    int decValue = 1000;
    while (decValue)
    
        pushStack(&pStack, 0, decValue % 2);
        decValue /= 2;
    
    while (NULL != pStack)
    
        Node tmp;
        popStack(&pStack, &tmp);
        printf("%d", tmp.data);
    

    system("pause");

程序片段(05):Queue.h+Queue.c+main.c
内容概要:链式队列

///Queue.h
#pragma once

#define DT int

typedef struct node

    DT data;
    struct node * pNext;
Node;

void initQueue(Node ** ppQueue);
void showQueue(Node * pQueue);
void enQueue(Node ** ppQueue, DT data);
void deQueue(Node ** ppQueue, Node * pData);
void clearQueue(Node ** ppQueue);

///Queue.c
#include "Queue.h"
#include <stdlib.h>
#include <stdio.h>

void initQueue(Node ** ppQueue)

    if (NULL == ppQueue)
        abort();
    *ppQueue = NULL;


void showQueue(Node * pQueue)

    if (NULL == pQueue)
        return;
    for (Node * pTmp = pQueue; NULL != pTmp; pTmp = pTmp->pNext)
    
        printf("%d", pTmp->data);
    
    printf("\\n");


void enQueue(Node ** ppQueue, DT data)

    if (NULL == ppQueue)
        abort();
    Node * pNew = (Node *)malloc(sizeof(Node));
    pNew->data = data;
    pNew->pNext = NULL;
    if (NULL == *ppQueue)
    
        *ppQueue = pNew;
        pNew->pNext = NULL;
        return;
    
    Node * pTmp = *ppQueue;
    while (NULL != pTmp->pNext)
    
        pTmp = pTmp->pNext;
    
    pTmp->pNext = pNew;


void deQueue(Node ** ppQueue, Node * pData)

    if (NULL == ppQueue)
        abort();
    if (NULL == *ppQueue)
        return;
    pData->data = (*ppQueue)->data;
    if (NULL == (*ppQueue)->pNext)
    
        free(*ppQueue);
        *ppQueue = NULL;
        return;
    
    Node * pTmp = *ppQueue;
    *ppQueue = (*ppQueue)->pNext;
    free(pTmp);


void clearQueue(Node ** ppQueue)

    if (NULL == ppQueue)
        abort();
    if (NULL == *ppQueue)
        return;
    Node * p1 = NULL;
    Node * p2 = *ppQueue;
    while (NULL != p2)
    
        p1 = p2;
        p2 = p2->pNext;
        free(p1);
    
    *ppQueue = NULL;

///main.c
#include "Queue.h"
#include <stdlib.h>

int main(void)

    Node * pQueue = NULL;
    initQueue(&pQueue);
    for (int i = 0; i < 10; ++i)
    
        printf("enQueue:%2d \\n", i + 1);
        enQueue(&pQueue, i + 1);
        showQueue(pQueue);
    
    while (NULL != pQueue)
    
        Node tmp;
        deQueue(&pQueue, &tmp);
        printf("deQueue:%2d \\n", tmp.data);
        showQueue(pQueue);
    

    system("pause");

程序片段(06):Queue.h+Queue.c+优先队列测试.c
内容概要:优先链式队列

///Queue.h
#pragma once

//01.关于队
以上是关于20160225.CCPP体系详解(0035天)的主要内容，如果未能解决你的问题，请参考以下文章
 
 20160206.CCPP体系详解(0016天)
 20160219.CCPP体系详解(0029天)
 20160218.CCPP体系详解(0028天)
 20160226.CCPP体系详解(0036天)
 20160210.CCPP体系详解(0020天)
 20160209.CCPP体系详解(0019天)