数据结构复习

最新推荐文章于 2024-10-05 15:48:11 发布

过路人_WY

最新推荐文章于 2024-10-05 15:48:11 发布

阅读量54

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/m0_51447650/article/details/132238251

版权

一、创建顺序表

#include <stdio.h>
#define SIZE 30

typedef int data_t；    //这样定义为了更加通用

typedef struct List
{
     data_t data[SIZE]；//定义需要的数据（可以是字符、数字、姓名、年龄等等）
     int count；        //定义数组的下表  
}List；

（一）、插入对应下标元素

int insert_list（List *pList，int index，data_t tData）
{               //所指向空间的指针
                 //栈的下标
                 //传入的数据

//入参检查
    if(NULL == pLint || pLint->count > index || index < 0)
    {
        return ERROR；
    }

//判断表是否满了
    if(SIZE == pList->count)
    {
        return FULL；
    }

//插入数据    
    for(int i = pList->count；i < index；i--)
    {
        pLint->data[i] = pLint->data[i-1]；
    }    
    pList->data[index] = tData；
    pList->count++；
    return OK；
}

（二）、删除对应下标元素

int delete_list(List *pList，int index，data_t *pData)
{                                       //保存要删除的元素

//入参检查
    if(NULL == pList || index >  pList->count || index < 0)
    {
        return ERROR；
    }

//判断是否为空表
    if(0 == pList->count)
    {
        return EMPTY；
    }

//保存删除的元素方便显示
    *pData = pList->data[index]；

//删除对应下标元素
    for(int i = index；i < pList->count；i++)
    {
        pList->data[i] = pList->data[i+1]；
    }
    pList->count--；
    return OK；
}

（三）、显示内容

void show_list(List *pList)
{
//入参检查
    if(NULL == pList)
    {
        return；
    }

//打印数组中的元素
    for(int i = 0；i < pList->count；i++)
    {
        printf("%d",pList->data[i])；
    }
    puts("")；
}

（四）、销毁顺序表

void destroy_list(List **ppList)
{

//入参检测
    if(NULL == ppList || NULL == *ppList)
    {
        return；
    }

//释放空间
    free(*ppList)；
    *ppList = NULL；          //ppList就相当于main传入的pList参数
}

二、创建链表

#include <stdio.h>

typedef int data_t；         //定义一个int类型的别名  为了更加通用

typedef struct LinkNode
{
    data_t age；//保存链表结点中的数据
    struct LinkNode *pNext； //保存下一个结点地址
}LinkNode；

typedef struct Link
{
    LinkNode *pHead；        //保存一个结点的地址
    int count；              //记录创建的结点个数
}Link；

（一）、如何插入数据

LinkNode creat_node(data_t tData)
{

//开辟一个结点空间
    LinkNode *pNode = (LinkNode *)malloc(sizeof(LinkNode))；
    if(NULL == pNode)
    {
        reutrn；
    }
    
    memset(pNode，0，sizeof(LinkNode))；

    pNode->age = tData；

    return pNode；

}

1.头部插入

int push_insert(Link *pLink，data_t tData)
{
    LinkNode *pNode = NULL；

//入参检查
    if(NULL == pLink)
    {
        return ERROR；
    }

//创建结点
    pNode = creat_node(tData)；
    if(NULL == pNode)
    {
        reutrn ERROR；
    }

//交换
    pNode->pNext = pLink->pHead:
    pLink->pHead = pNode；
    pLink->count++；
    return OK；
}

2.尾部插入

int push_back_link(Link *pLink, data_t tData)
{
	LinkNode *pNode = NULL;
	LinkNode *pTmp = pLink->pHead;  //空表  NULL
	if(NULL == pLink)
	{
		return LINK_ERR;
	}

//创建新结点
	pNode = create_node(tData);

	//当表为空时，pNode就是第一个结点
	if(NULL == pTmp)
	{
		pLink->pHead = pNode;
		pLink->count++;
		return LINK_OK;
	}

	//找到链表的最后一个结点
	while(pTmp->pNext != NULL)
	{
		pTmp = pTmp->pNext;
	}

	//将新的结点插入
	pTmp->pNext = pNode;
	pLink->count++;
	return LINK_OK;
}

3.位置插入

int insert_item_link(Link *pLink, int pos, data_t tData)
{
	LinkNode *pNode = NULL;
	LinkNode *pTmp = pLink->pHead;
	int i;
	if(NULL == pLink || pos < 0 || pos > pLink->count)
	{
		return LINK_ERR;
	}

//创建新结点
	pNode = create_node(tData);

	//找到要插入位置的前一个结点
	for(i = 0; i < pos-1; i++)
	{
		pTmp = pTmp->pNext;
	}

	//插入
	//如果是空表，pTmp = NULL
	if(0 == pLink->count)
	{
		pLink->pHead = pNode;
	}
	else
	{
		pNode->pNext = pTmp->pNext;
		pTmp->pNext = pNode;
	}

	pLink->count++;
	return LINK_OK;
}

（二）、如何删除链表结点

1.头部删除

int push_delete(Link *pLink)
{
    LinkNode *pTmp = pLink->pHead；
//入参检查
    if(NULL == pLink  || pLink->count <= 0)
    {
        return ERROR；
    }
//头部删除
    pLink->pHead = pTmp->pNext；
    free(pTmp)；
    pTmp = NULL；
    pTmp = pLink->pHead；
    return OK；
}

2.尾部删除

int back_delete(Link *pLink)
{
    LinkNode *pTmp = NUULL；
    LinkNode *pDel = pLink->pHead；
//入参检查
    if(NULL == pLink || pLink->count <= 0)
    {
        return ERROR；
    }
    
//尾部删除
    for(int i = 0；i < pLink->count-1；i++)
    {
        pDel = pDel->pNext；
    }
    pTmp = pDel->pNext；
    free(pTmp)；
    pTmp = NULL；
    pLink->count--；
    return OK；
}

3.位置删除

int push_delete(Link *pLink，int pos，data_t *pData)
{
    LinkNode *pDel = NULL；
    LinkNode *pTmp = pLink->pHead；
//入参检查
    if(NULL == Plink || pLink->count < pos || pos < 0)
    {   
        return ERROR；
    }

//若为空表
    if(0 == pLink->count)
    {
        return EMPTY；
    }

//反之 找到要删除的结点
    for(int i = 0；i < pos-1；i++)
    {
        pTmp = pTmp->pNext；
    }

    //如果只有一个结点或者要删除的是头结点
    *pData = pLink->data
    if(0 == pos)
    {
        pLink->pHead = pTmp->pNext；
    }
    else
    {        
       pDel = pTmp->pNext；
       pTmp->pNext = pDel->pNext；
    }
    free(pDel)；
    pDel = NULL；
    pLink->count--；
    return OK；
}

（三）、显示

void show_link(Link *pLink)
{
	LinkNode *pTmp = pLink->pHead;
	if(NULL == pLink)
	{
		return;
	}
    while(pTmp != NULL)
	{
		printf("name:%s, age:%d\n", pTmp->data.name, pTmp->data.age);
		pTmp = pTmp->pNext;
	}
}

（四）、销毁

void destroy_link(Link **ppLink)
{
	LinkNode *pDel = *ppLink->pHead;
	if(NULL == ppLink || NULL == *ppLink)
	{
		return;
	}

	//如果不是空表
	if(0 < *ppLink->count)
	{
    	//用头删法循环删除所有结点
		while(pDel != NULL)
		{
			pLink->pHead = pDel->pNext;
			free(pDel);
			pDel = pLink->pHead;
		}
	}
	//删除空表
	free(*ppLink);
	*ppLink = NULL;
}

三、创建栈

栈（先进后出）	队列（先进先出）
顺序栈	链式队列
链式栈

（一）、顺序栈

1、入栈


int push_stack(Stack *pStack, data_t tData)
{
	if(NULL == pStack)
	{
		return STACK_ERR;
	}
	//如果栈满
	if(SIZE == pStack->iTop+1)
	{
		return STACK_FULL;
	}
	//因为此时栈顶有元素，iTop++之后才能给对应位置赋值
	pStack->iTop++;
	pStack->data[pStack->iTop] = tData;
    return STACK_OK;
}

2、出栈

int pop_stack(Stack *pStack, data_t *pData)
{
	if(NULL == pStack || NULL == pData)
	{
		return STACK_ERR;
	}
	//栈空
	if(0 == pStack->iTop+1)
	{
		return STACK_EMPTY;
	}

	*pData = pStack->data[pStack->iTop];
	pStack->iTop--;
	return STACK_OK;
}

3、显示

//入栈
while(1)
	{
		tData = getchar();
		if(tData == '#')
		{
			break;
		}
		if(STACK_FULL == push_stack(pStack, tData))
		{
			printf("满了!\n");
			break;
		}
	}
//出栈
	while(STACK_EMPTY != pop_stack(pStack, &tData))
	{
		printf("%c ", tData);
	}
	printf("\n");

	destroy_stack(&pStack);
	return 0;
}

4、销毁

void destroy_stack(Stack **ppStack)
{
	if(NULL == ppStack || NULL == *ppStack)
	{
		return;
	}
	free(*ppStack);
	*ppStack = NULL;
}

（二）、链式栈

StackNode *create_node(data_t tData)
{
	StackNode *pNode = (StackNode *)malloc(sizeof(StackNode));
	if(NULL == pNode)
	{
		return NULL;
	}
	memset(pNode, 0, sizeof(StackNode));
	pNode->data = tData;
	return pNode;
}

1、插入

//进栈（压栈）
int push_stack(Stack *pStack, data_t tData)
{
	StackNode *pNode = NULL;
	if(NULL == pStack)
	{
		return STACK_ERR;
	}

//创建一个新的结点
	pNode = create_node(tData);

	//将这个新的结点插入在头部（栈顶）
	//如果此时是空栈
	if(0 == pStack->count)
	{
		pStack->pTop = pNode;
	}

	//如果不是空栈
	else
	{
		pNode->pNext = pStack->pTop;
		pStack->pTop = pNode;
	}
	pStack->count++;
	return STACK_OK;
}

2、删除

//出栈
int pop_stack(Stack *pStack, data_t *pData)
{
	StackNode *pDel = pStack->pTop;

	if(NULL == pStack)
	{
		return STACK_ERR;
	}

	if(0 == pStack->count)
	{
		return STACK_EMPTY;
	}

    if(pData != NULL)
	{
		*pData = pStack->pTop->data;
	}

    pStack->pTop = pDel->pNext;
	free(pDel);
	pDel = NULL;
	pStack->count--;
	return STACK_OK;
}

3、显示

//入栈
	while(1)
	{
		tData = getchar();
		if(tData == '#')
		{
			break;
		}
		push_stack(pStack, tData);
	}

//出栈
	while(STACK_EMPTY != pop_stack(pStack, &tData))
	{
		printf("%c ", tData);
	}
	printf("\n");

	destroy_stack(&pStack);
	return 0;
}

4、销毁

void destroy_stack(Stack **ppStack)
{

//ppStack--->pStack===*ppStack
	if(NULL == ppStack || NULL == *ppStack)
	{
		return;
	}

	StackNode *pDel = (*ppStack)->pTop;

//先使用头删删除一个一个的结点
    if(0 < (*ppStack)->count)
	{
		while((*ppStack)->pTop != NULL)
		{
			pop_stack(*ppStack, NULL);
		}
	}

//销毁栈
	free(*ppStack);
	*ppStack = NULL;
}

四、创建队列

QueueNode *create_node(data_t tData)
{
	QueueNode *pNode = (QueueNode *)malloc(sizeof(QueueNode));
	if(NULL == pNode)
	{
		return NULL;
	}
	memset(pNode, 0, sizeof(QueueNode));
	pNode->data = tData;
	return pNode;
}

（一）、入队

//入队
int enter_queue(Queue *pQueue, data_t tData)
{
	if(NULL == pQueue)
	{
		return QUEUE_ERR;
	}
	QueueNode *pNode = create_node(tData);

	//如果是空队列
	//头和尾是一个
	if(0 == pQueue->count)
	{
		pQueue->pHead = pNode;
		pQueue->pTail = pNode;
	}
	else
	{
		pQueue->pTail->pNext = pNode;
		pQueue->pTail = pNode;
	}
	pQueue->count++;
	return QUEUE_OK;
}

（二）、出队

//出队
int leave_queue(Queue *pQueue, data_t *pData)
{
	QueueNode *pDel = NULL;
	if(NULL == pQueue || NULL == pData)
	{
		return QUEUE_ERR;
	}
	pDel = pQueue->pHead;

//如果是空队，返回
	if(0 == pQueue->count)
	{
		return QUEUE_EMPTY;
	}

    *pData = pDel->data;

//头部删除
	pQueue->pHead = pDel->pNext;
	free(pDel);

	//如果删除的是最后一个结点，pHead和pTail都要为NULL
	if(NULL == pQueue->pHead) //if(1 == pQueue->count)
	{
		pQueue->pTail = NULL;
	}
	pQueue->count--;  //if(0 == pQueue->count) pQueue->pTail=NULL
	return QUEUE_OK;
}

（三）、显示

//入队
	while(1)
	{
		tData = getchar();
		if(tData == '#')
		{
			break;
		}
		enter_queue(pQueue, tData);
	}

//出队
	while(QUEUE_EMPTY != leave_queue(pQueue, &tData))
	{
		printf("%c ", tData);
	}
	printf("\n");

	destroy_queue(&pQueue);

（四）、销毁

//销毁队列
void destroy_queue(Queue **ppQueue)
{
	if(NULL == ppQueue || NULL == *ppQueue)
	{
		return;
	}
	QueueNode *pDel = (*ppQueue)->pHead;

//先使用头删删除一个一个的结点
    if(0 < (*ppQueue)->count)
	{
		while((*ppQueue)->pHead!= NULL)
		{
			leave_queue(*ppQueue, NULL);
		}
	}

	//销毁栈
	free(*ppQueue);
	*ppQueue = NULL;
}