数据结构之栈(用单向链表实现)

已于 2022-09-15 23:06:31 修改
阅读量851 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言
于 2022-05-08 12:57:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45050132/article/details/124646653
版权

序言

作为一个自动化专业毕业的年轻小伙，自己的编程水平有限，需要广泛学习训练。特此记录下自己编程学习代码。非科班毕业，没有严格考量时间和空间的复杂度。

学习当然是学习了别人的思想然后内化的呀。

源码

linklist1.h

// 单向链表
// 头节点无数据域只有指针域

#ifndef _LINKLIST1_H

	#define _LINKLIST1_H
	
	#include <malloc.h>
	#include <stdio.h>

	struct LinkNode
	{
		void *pData;
		struct LinkNode *pNext;
	};

	struct LinkList
	{
		struct LinkNode head;
		int length;
	};

	//创建链表
	struct LinkList* CreatLinkList(void);

	//按位置往链表插入节点
	void InsertToLinlkListByPos(struct LinkList*pLinkList, int position, void* pData);

	//往链表头插入节点
	void InsertToLinkListHead(struct LinkList*pLinkList, void* pData);

	//往链表尾插入节点
	void InsertToLinkListTail(struct LinkList*pLinkList, void* pData);

	//遍历链表
	void TraverseLinkList(struct LinkList* pLinkList, void(*printCallback)(void*));

	//按位置获取链表节点的数据指针
	void *GetDataPointerOfNodeInLinkListByPos(struct LinkList* pLinkList,int pos);

	//获取链表第一个节点的数据指针
	void *GetDataPointerOfFirstNodeInLinkList(struct LinkList* pLinkList);

	//获取链表最后一个节点的数据指针
	void *GetDataPointerOfLastNodeInLinkList(struct LinkList* pLinkList);

	//按位置删除链表的节点
	void DeleteNodeOFLinkListByPosition(struct LinkList* pLinkList, int position);

	//删除链表的第一个节点
	void DeleteFirstNodeOfLinkList(struct LinkList* pLinkList);

	//删除链表的最后一个节点
	void DeleteLastNodeOfLinkList(struct LinkList* pLinkList);

	//按数据指针删除链表内节点
	void DeleteNodeOFLinkListByValue(struct LinkList* pLinkList, void* data, int(*comparecallback)(void* data1, void* data2));

	//清空链表
	void ClearLinkList(struct LinkList* pLinkList);

	//摧毁链表
	void DestroyLinkList(struct LinkList* linklistpointer);

	//链表去重(删除数据域相同的节点)
	void QuCHongLiskList(struct LinkList*pLinkList,int(*CompareCallBack)(void*,void*));

	//链表逆序
	void ReverseLinkList(struct LinkList*pLinkList);

#endif

linklist1.c

#include "linklist1.h"


struct LinkList* CreatLinkList(void)
{
	struct LinkList* pLinkList;
	
	pLinkList = (struct LinkList*)malloc(sizeof(struct LinkList));
	
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	
	pLinkList->head.pData = NULL;
	
	pLinkList->head.pNext = NULL;
	
	pLinkList->length = 0;
	
	return(pLinkList);
}

void ClearLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pLinkList->length < 1)
	{
		return;
	}
	int length = pLinkList->length;
	for (int i = 0; i < length; i++)
	{
		//用尾删函数删除链表节点
		DeleteLastNodeOfLinkList(pLinkList);
	}
}

void InsertToLinlkListByPos(struct LinkList*pLinkList,int position,void*pData)
{
	
	if (pLinkList == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	
	if (position < 0 || position > pLinkList->length)
	{
		
		return;
	}
	
	struct LinkNode* pFrontNode = &pLinkList->head;
	
	for (int i = 0; i < position; i ++)
	{
		pFrontNode = pFrontNode->pNext;
	}
	
	struct LinkNode* pNewNode = (struct LinkNode*)malloc(sizeof(struct LinkNode));
	pNewNode->pData = pData;
	pNewNode->pNext = NULL;
	
	pNewNode->pNext = pFrontNode->pNext;
	pFrontNode->pNext = pNewNode;
	
	pLinkList->length++;
}

void InsertToLinkListHead(struct LinkList*pLinkList, void* pData)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	InsertToLinlkListByPos(pLinkList,0,pData);
}

void InsertToLinkListTail(struct LinkList*pLinkList, void* pData)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	InsertToLinlkListByPos(pLinkList,pLinkList->length,pData);
}

void TraverseLinkList(struct LinkList*pLinkList,void(*printCallback)(void*))
{
	if (pLinkList == NULL)
	{
		return;
	}
	struct LinkNode* pCurNode = &pLinkList->head;
	for (int i = 0; i < pLinkList->length; i++)
	{
		pCurNode = pCurNode->pNext;
		printCallback(pCurNode->pData);
	}
}

void *GetDataPointerOfNodeInLinkListByPos(struct LinkList* pLinkList,int pos)
{
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	if (pos < 0)
	{
		return(NULL);
	}
	if (pos >= pLinkList->length)
	{
		return(NULL);
	}
	struct LinkNode *pNode = &pLinkList->head;
	for (int i = 0; i <= pos; i ++)
	{
		pNode = pNode->pNext;
	}
	return(pNode->pData);
}

//获取链表第一个节点的数据指针
void *GetDataPointerOfFirstNodeInLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	if (pLinkList->length < 1)
	{
		return(NULL);
	}
	void *pData;
	pData = GetDataPointerOfNodeInLinkListByPos(pLinkList,0);
	return(pData);
}

//获取链表最后一个节点的数据指针
void *GetDataPointerOfLastNodeInLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	if (pLinkList->length < 1)
	{
		return(NULL);
	}
	void *pData;
	pData = GetDataPointerOfNodeInLinkListByPos(pLinkList,pLinkList->length - 1);
	return(pData);
}

void DeleteNodeOFLinkListByPosition(struct LinkList*pLinkList,int position)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (position < 0 || position >= pLinkList->length)
	{
		return;
	}
	
	struct LinkNode* pCurNode;
	pCurNode = &pLinkList->head;
	for (int i = 0; i < position; i++)
	{
		pCurNode = pCurNode->pNext;
	}
	
	struct LinkNode* pDeleteNode;
	pDeleteNode = pCurNode->pNext;

	pCurNode->pNext = pDeleteNode->pNext;
	
	free(pDeleteNode);
	
	pLinkList->length--;
}

void DeleteFirstNodeOfLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	DeleteNodeOFLinkListByPosition(pLinkList,0);
}

void DeleteLastNodeOfLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	DeleteNodeOFLinkListByPosition(pLinkList,pLinkList->length - 1);
}

void DeleteNodeOFLinkListByValue(struct LinkList* pLinkList, void* pDataIn, int(*comparecallback)(void* data1, void* data2))
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pDataIn == NULL)
	{
		return;
	}

	for (int i = 0; i < pLinkList->length; i ++)
	{
		void *pData;
		pData = GetDataPointerOfNodeInLinkListByPos(pLinkList,i);
		if (comparecallback(pData,pDataIn) == 0)
		{
			DeleteNodeOFLinkListByPosition(pLinkList,i);
			i --;
		}
	}
}

void DestroyLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	ClearLinkList(pLinkList);
	free(pLinkList);
}

void QuCHongLiskList(struct LinkList*pLinkList,int(*compareCallBack)(void*,void*))
{
	if (pLinkList == NULL)
	{
		return;
	}

	int length = pLinkList->length;
	if (length < 2)
	{
		return;
	}

	if (compareCallBack == NULL)
	{
		return;
	}

	void **ppData = (void **)malloc(sizeof(void *) * length);
	int sameCount = 0;

	void *pDataI;
	void *pDataJ;
	
	for (int i = 0; i < pLinkList->length; i ++)
	{
		pDataI = GetDataPointerOfNodeInLinkListByPos(pLinkList,i);
		for (int j = i + 1; j < pLinkList->length; j ++)
		{
			pDataJ = GetDataPointerOfNodeInLinkListByPos(pLinkList,j);
			if (compareCallBack(pDataI,pDataJ) == 0)
			{
				*(ppData + sameCount) = pDataJ;
				sameCount ++;
			}
		}
	}

	for (int i = 0; i < sameCount; i ++)
	{
		DeleteNodeOFLinkListByValue(pLinkList,*(ppData + i),compareCallBack);
	}

	free(ppData);
}

void ReverseLinkList(struct LinkList*pLinkList)
{
	//思路：顺序删除，逆序插入
	if (pLinkList == NULL)
	{
		return;
	}

	if (pLinkList->length < 2)
	{
		return;
	}

	int num = pLinkList->length;
	void **ppData = (void *)malloc(sizeof(void *) * num);

	for (int i = 0; i < num; i ++)
	{
		*(ppData + i) = GetDataPointerOfNodeInLinkListByPos(pLinkList,i);
	}

	for (int i = 0; i < num; i ++)
	{
		DeleteLastNodeOfLinkList(pLinkList);
	}

	for (int i = 0; i < num; i ++)
	{
		InsertToLinkListTail(pLinkList,*(ppData + num - i - 1));
	}
}

Stack.h

 #ifndef STACK_H

    #define STACK_H

    #include "linklist1.h"

    #ifdef __cplusplus 
    extern "C"
    {
    #endif

    //创建栈
    void *CreatStack(void);

    //压栈(压入数据指针)
    void PushStack(void *pStack,void *pData);

    //出栈
    void PopStack(void *pStack);

    //获取栈顶数据指针
    void *GetStackTop(void *pStack);

    //清空栈内数据指针
    void ClearStack(void *pStack);

    //判断栈是否为空
    bool IsStackEmpty(void *pStack);

    //销毁栈
    void DestroyStack(void *pStack);

    #ifdef  __cplusplus  
    }
    #endif 

#endif

Stack.c

#include "Stack.h"

//创建栈
void *CreatStack(void)
{
    struct LinkList *pLinkList;
    pLinkList = CreatLinkList();
    if (pLinkList == NULL)
    {
        return(NULL);
    }
    return(pLinkList);
}

//压栈(压入数据指针)
void PushStack(void *pStack,void *pData)
{
    if (pStack == NULL)
    {
        return;
    }
    if (pData == NULL)
    {
        return;
    }

    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pStack;

    //入栈即插入到链表尾
    InsertToLinkListTail(pLinkList,pData);
}

//出栈
void PopStack(void *pStack)
{
    if (pStack == NULL)
    {
        return;
    }

    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pStack;

    //出栈即删除链表尾
    DeleteLastNodeOfLinkList(pLinkList);
}

//获取栈顶数据指针
void *GetStackTop(void *pStack)
{
    if (pStack == NULL)
    {
        return(NULL);
    }
    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pStack;
    if (pLinkList->length < 1)
    {
        return(NULL);
    }
    //栈顶元素即为链表最后一个节点的数据指针
    void *pData;
    pData = GetDataPointerOfLastNodeInLinkList(pLinkList);
    return(pData);
}

//清空栈内数据指针
void ClearStack(void *pStack)
{
    if (pStack == NULL)
    {
        return(NULL);
    }
    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pStack;
    ClearLinkList(pLinkList);
}

//判断栈是否为空
bool IsStackEmpty(void *pStack)
{
    if (pStack == NULL)
    {
        return(true);
    }
    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pStack;
    
    if (pLinkList->length < 1)
    {
        return(true);
    }
    else 
    {
        return(false);
    }
}

//销毁栈
void DestroyStack(void *pStack)
{
    if (pStack == NULL)
    {
        return(NULL);
    }
    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pStack;
    DestroyLinkList(pLinkList);
}

main.c(测试用)

#include "Stack.h"

//压栈和读取栈顶元素测试
void Test0(void)
{
	void *pStack;
	pStack = CreatStack();
	int a = 10;
	int b = 20;

	PushStack(pStack,&a);
	int *p1 = (int *)GetStackTop(pStack);
	printf("*p1 = %d\n",*p1);

	PushStack(pStack,&b);
	p1 = (int *)GetStackTop(pStack);
	printf("*p1 = %d\n",*p1);
}

//综合测试
void Test1(void)
{
	void *pStack;
	pStack = CreatStack();

	int team[] = {1,2,3,4,5};
	int *p;

	for (int i = 0; i < 5; i ++)
	{
		PushStack(pStack,&team[i]);
	}

	while (1)
	{
		if (IsStackEmpty(pStack) == false)
		{
			p = (int *)GetStackTop(pStack);
			printf("*p = %d\n",*p);
			PopStack(pStack);
		}
		else 
		{
			break;
		}
	}

	DestroyStack(pStack);
}

int main()
{

	Test1();

	getchar();
	return (0);
}
lxzlife
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用单向链表实现栈（C++源代码）
04-07
栈是基本的数据结构。其特点是添加和访问数据都在线性表的一端（头端）。数据访问遵循先进后出（FILO）的原则。...本程序用单向链表实现栈。是C++、数据结构及算法学习的一个小小练习。供大家参考。
栈的单链表实现
退役的熬夜选手
10-16 198
栈的单链表实现 //listack.h #include<stdio.h> #include<malloc.h> typedef char ElemType; typedef struct linknode{ ElemType data; struct linknode *next; }LinkStNode; //初始化栈 void InitStack(LinkStNo...
C++类模板实现栈(链表实现)
Rice__的博客
06-13 558
使用链表保存数据 头文件如下 #pragma once template <class T> class LinkStack; //保存数据结点 template <class T> class LinkNode { public: LinkNode(const T& d = T(), LinkNode* n = nullptr); friend class LinkStack<T>; private: T data; LinkNode* ne.
【数据结构】如何用单链表实现栈？
好吃的爆米花
07-20 5227
文章目录一、前言二、源码下载：持续更新中三、什么是栈？三、链表节点四、栈结构的定义五、栈空判断六、栈满判断七、入栈push(int value) 实现八、出栈pop()实现九、栈的打印（单向链表的逆序打印） 一、前言 工作之余，学习一下数据结构与算法，今天学习数据结构：“栈”。 相信各位帅气的程序员对这个栈是相当的熟悉。 但是笔者就总有一个臭毛病：一看就会，一写就拉稀。 所以今天小编就自己动手亲自用单向链表实现“栈” 二、源码下载：持续更新中 https://gitee.com/sunshineAndD
编写一个类，实现简单的栈（提示：用链表结构实现）。数据的操作按先进后出（FILO）的顺序。
Cielfire
10-28 2173
提示： 成员函数为   void queue::put(int item);  //将数据item插入到栈中   int queue::get();  //从栈中取数据 数据成员为   一个指向链首的指针 链表结构为   struct Node   {   int a;   Node* next;   } 对象使用过程   queue que;   que.put(10...
数据结构（c++）栈的模板类（使用链表实现）
Gpwner的博客
11-29 1374
List Node.h #ifndef LISTNODE_H #define LISTNODE_H #include<iostream> /* Create by 软件工程 gpwner 2016年11月28日17:37:23 */ using namespace std; template<class Type> class ListNode { public: //链表结点构造函数
数据结构 链表 C语言 单向链表 栈
05-20
数据结构 链表 C语言 单向链表 栈
浅谈PHP链表数据结构(单链表)
12-18
单向链表，双向链表，环形链表 PHP的底层是C，当一个程序运行时，内存分成五个区（堆区，栈区，全局区，常量区，代码区） 规定：基本数据类型，一般放在栈区 复合数据类型，比如对象，放在堆区 定义一个类Hero 定义...
用c语言实现各种数据结构的源代码
05-17
用C语言写了各种数据结构底层的实现，其中包括单向链表，双向链表，队列，双端队列，栈，搜索二叉树，AVL平衡二叉树，并且包括实现了他们的大部分常用的方法，比如入栈、出栈、是否为空、插入、删除、销毁、初始化...
第三天-队列与栈的逻辑与单向循环链表.zip
05-01
//链表节点类型 //不安全的遍历 #define list_for_each(head, pos) for(pos=head->next; pos!=head; pos=pos->next) //安全的遍历 #define list_for_each_safe(head, pos, n) for(pos=head->next, n=pos->next; ...
[C语言实现]栈和队列&链表实现
m0_73976305的博客
04-02 271
循环队列 共享栈
链表方式实现栈和队列（C语言）
weixin_73567058的博客
04-21 836
栈（Stack）是一种常见的数据结构，它是一种线性数据结构，具有后进先出（Last In First Out, LIFO）的特点。栈可以看作是一个容器，只能在容器的一端进行插入和删除操作，这一端被称为栈顶（Top），另一端被称为栈底（Bottom）。栈的基本操作有入栈（Push）、出栈（Pop）、获取栈顶元素（Top）和判断栈是否为空（Empty）。入栈操作将一个元素插入到栈顶，出栈操作将栈顶元素删除并返回，获取栈顶元素操作返回栈顶元素但不删除，判断栈是否为空操作返回一个布尔值。
数据结构 -- 使用链表实现栈
sfvgn的博客
07-11 225
【代码】数据结构 -- 使用链表实现栈。
链栈（入栈，出栈，遍历）
热门推荐
m0_61395860的博客
02-07 1万+
一、链栈概述 1.为什么要用链栈？ 链式存储结构可以更好的避免栈上溢，因为顺序栈在定义结构体时需要定义最大值。 2.什么是链栈 栈的链式存储结构就是链栈，栈底就是链表的最后一个结点，而栈顶是链表的第一个结点，一个链栈可以由栈顶指针top唯一确定。 结构体的定义： #include<stdio.h> #include<stdlib.h> typedef struct Stack{ int data; struct Stack *next; }*LStack; 二、
栈——链表实现
m0_53223094的博客
11-21 2493
链栈的一些基本操作，附带源码
单链表实现栈
niumannn的博客
12-18 334
S = NULL;return 0;S = p;return 1;free(p);return 1;
数据结构：链表、栈
m0_62021646的博客
12-31 1921
1. 链表 1.1 什么是链表 链表是数据结构之一，其中的数据呈线性排列。 在链表中，数据的添加和删除都较为方便，访问比较耗费时间。 链表的数据元素是一个一个串联在一起的，这一串数据形成的结构就是“链表”。它就像一条自行车“链条”一样。每一个数据元素可以称之为一个节点。 链表在内存中的物理存储空间是非连续、非顺序的。其中每个节点包含两部分，一个是存储数据元素的**“数据域”，另一个是存储下一个节点地址的“指针域”**。 1.2 单链表 1.2.1 单链表图解 1.2.2 单链表的应用 题目描述： 实现一个
用单链表实现栈
p812438109的专栏
11-27 1936
一）栈 栈：先进后出、后进先出 二）用单链表实现栈 第一步：初始化单链表结构 /** * 用单链表实现栈 * @author ouyangjun */ public class SingleChainTableStack<E> { /** 初始化单链表结构 */ static class Node<E> { E i...
数据结构----单向链表
最新发布
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一...单向链表常用于需要频繁插入和删除操作的场景，比如实现栈、队列等数据结构，也可以用于实现其他高级数据结构，如图、树等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值