程序片段(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.关于队列内容:
// 1.队列没有正反向的差别:
// 仅仅有实现上面的正反向差别
// 2.队列分为两种:
// 普通队列+优先队列
#define DT int
typedef struct node
{
int priority;//优先队列
DT data;
struct node * pNext;
}Node;
void initQueue(Node ** ppQueue);
void showQueue(Node * pQueue);
void enQueue(Node ** ppQueue, int priority, 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)
return;
if (NULL == *ppQueue)
return;
*ppQueue = NULL;
}
void showQueue(Node * pQueue)
{
if (NULL == pQueue)
return;
for (Node * pTmp = pQueue; NULL != pTmp; pTmp = pTmp->pNext)
{
printf("优先级:%2d, 数据:%4d \n", pTmp->priority, pTmp->data);
}
printf("\n");
}
void enQueue(Node ** ppQueue, int priority, DT data)
{
if (NULL == ppQueue)
abort();
Node * pNew = (Node *)malloc(sizeof(Node));
pNew->priority = priority;
pNew->data = data;
pNew->pNext = NULL;
if (NULL == *ppQueue)
{
*ppQueue = pNew;
return;
}
if (priority > (*ppQueue)->priority)
{
pNew->pNext = *ppQueue;
*ppQueue = pNew;
return;
}
//优先队列:前插实现
Node * p1 = NULL;
Node * p2 = *ppQueue;
int find = 0;
while (NULL != p2)
{
if (priority > p2->priority)
{
find = 1;
break;
}
p1 = p2;
p2 = p2->pNext;
}
if (find)
{
p1->pNext = pNew;
pNew->pNext = p2;
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->priority = (*ppQueue)->priority;
pData->data = (*ppQueue)->data;
if (NULL == (*ppQueue)->pNext)
{
free(*ppQueue);
*ppQueue = NULL;
return;
}
Node * pTmp = *ppQueue;
*ppQueue = (*ppQueue)->pNext;
free(pTmp);
}///优先队列測试.c
#include "Queue.h"
#include <stdlib.h>
#include <stdio.h>
int main01(void)
{
Node * pQueue;
initQueue(&pQueue);
enQueue(&pQueue, 4, 100);
enQueue(&pQueue, 2, 100);
enQueue(&pQueue, 1, 100);
enQueue(&pQueue, 3, 100);
enQueue(&pQueue, 5, 100);
enQueue(&pQueue, 5, 102);
enQueue(&pQueue, 5, 101);
printf("优先队列此时状态! \n");
showQueue(pQueue);
while (NULL != pQueue)
{
Node tmp;
deQueue(&pQueue, &tmp);
printf("优先级:%2d, 数据:%4d \n", tmp.priority, tmp.data);
}
system("pause");
}程序片段(07):CppList.cpp+List.h+List.c+main.c
内容概要:List
///CppList.cpp
#include <stdio.h>
#include <stdlib.h>
#include <list>
using namespace std;//导入命名空间
int main01(void)
{
list<int> myList;//设定元素类型
//list<list<list<int>>> myHighList;
for (int i = 0; i < 10; ++i)
{
myList.push_back(i + 1);
}
for (auto tmp : myList)
{//遍历一个STL容器
printf("%d", tmp);
}
system("pause");
return 1;
}///List.h
#pragma once
typedef struct node
{
int data;//数据域
struct node * pPre;//前驱
struct node * pNext;//后期
}Node;
typedef struct list
{
Node * pHead;//头指针
Node * pTail;//尾指针
}List;
void initList(List * pList);
void listHeadInsert(List * pList, int data);
void listTailInsert(List * pList, int data);
void showList(List * pList);
void revShowList(List * pList);
Node * listSelelctFirst(List * pList, int data);
Node * listRevSelectFirst(List * pList, int data);
void listRandInsert(List * pList, int findData, int insertData);
void listDeleteFirst(List * pList, int data);
void listRevDeleteFirst(List * pList, int data);///List.c
#include "List.h"
#include <stdlib.h>
#include <stdio.h>
void initList(List * pList)
{
if (NULL == pList)
abort();
pList->pHead = pList->pTail = NULL;
}
void listHeadInsert(List * pList, int data)
{
if (NULL == pList)
abort();
Node * pNew = (Node *)malloc(sizeof(Node));
pNew->data = data;
pNew->pPre = pNew->pNext = NULL;
if (NULL == pList->pHead)
{//空双链
pList->pHead = pList->pTail = pNew;
return;
}
pNew->pNext = pList->pHead;
pList->pHead->pPre = pNew;
pList->pHead = pNew;
}
void listTailInsert(List * pList, int data)
{
if (NULL == pList)
abort();
Node * pNew = (Node *)malloc(sizeof(Node));
pNew->data = data;
pNew->pPre = pNew->pNext = NULL;
if (NULL == pList->pTail)
{
pList->pHead = pList->pTail = pNew;
return;
}
pList->pTail->pNext = pNew;
pNew->pPre = pList->pTail;
pList->pTail = pNew;
}
void showList(List * pList)
{
if (NULL == pList)
abort();
if (NULL == pList->pHead)
{
return;
}
for (Node * pTmp = pList->pHead; NULL != pTmp; pTmp = pTmp->pNext)
{
printf("%3d", pTmp->data);
}
printf("\n");
}
void revShowList(List * pList)
{
if (NULL == pList)
abort();
if (NULL == pList->pTail)
return;
for (Node * pTmp = pList->pTail; NULL != pTmp; pTmp = pTmp->pPre)
{
printf("%3d", pTmp->data);
}
}
Node * listSelectFirst(List * pList, int data)
{
if (NULL == pList)
abort();
if (NULL == pList->pHead)
return;
for (Node * pTmp = pList->pHead; NULL != pTmp; pTmp = pTmp->pNext)
if (data == pTmp->data)
return pTmp;
return NULL;
}
Node * listRevSelectFirst(List * pList, int data)
{
if (NULL == pList)
abort();
if (NULL == pList->pTail)
return;
for (Node * pTmp = pList->pTail; NULL != pTmp; pTmp = pTmp->pPre)
if (data == pTmp->data)
return pTmp;
return NULL;
}
void listRandInsert(List * pList, int findData, int insertData)
{
if (NULL == pList)
abort();
if (NULL == pList->pTail)
return;
int find = 0;
Node * p1 = NULL;
//逆向前插<正向后插>
//正向前插<逆向后插>
Node * p2 = pList->pTail;
while (NULL != p2)
{//逆向前插
if (findData == p2->data)
{
find = 1;
break;
}
p1 = p2;
p2 = p2->pPre;
}
if (!find)
return;
Node * pNew = (Node *)malloc(sizeof(Node));
pNew->data = insertData;
pNew->pPre = pNew->pNext = NULL;
if (pList->pTail == p2)
{
pList->pTail->pNext = pNew;
pList->pTail = pNew;
return;
}
p2->pNext = pNew;
pNew->pPre = p2;
p2->pPre = pNew;
pNew->pNext = p1;
}
void listRevDeleteFirst(List * pList, int data)
{
if (NULL == pList)
abort();
if (NULL == pList->pTail)
return;
int find = 0;
Node * p1 = NULL;
Node * p2 = pList->pTail;
while (NULL != p2)
{
if (data == p2->data)
{
find = 1;
break;
}
p1 = p2;
p2 = p2->pPre;
}
if (!find)
return;
if (p2 == pList->pTail)
{
pList->pTail->pPre->pNext = NULL;
Node * pTmp = pList->pTail;
pList->pTail = pList->pTail->pPre;
free(pTmp);
return;
}
if (p2 == pList->pHead)
{
pList->pTail->pNext->pPre = NULL;
Node * pTmp = pList->pHead;
pList->pHead = pList->pHead->pNext;
free(pTmp);
return;
}
p1->pPre = p2->pPre;
p2->pPre->pNext = p1;
free(p2);
}///main.c
#include "List.h"
#include <stdio.h>
#include <stdlib.h>
int main01(void)
{
List list;
initList(&list);
//listHeadInsert(&list, 5);
//listHeadInsert(&list, 4);
//listHeadInsert(&list, 3);
//listHeadInsert(&list, 2);
//listHeadInsert(&list, 1);
listTailInsert(&list, 1);
listTailInsert(&list, 2);
listTailInsert(&list, 3);
listTailInsert(&list, 4);
listTailInsert(&list, 5);
//listRevDeleteFirst(&list, 3);
listRandInsert(&list, 3, 6);
showList(&list);
system("pause");
}