数据结构之一对一（完结）

最新推荐文章于 2022-11-24 16:05:34 发布
最新推荐文章于 2022-11-24 16:05:34 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： java c++ 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bert_chen/article/details/123243831
版权

系统按照最大数据类型对齐;

为什么同一结构,在不同平台大小不同?
因为:

  • 不同平台上相同类型所占(内存)字节不同
  • 不同平台对齐方式不一样

#pragma pack(1):系统按照一个字节对齐。
1

struct Node
{
int a;
short b;
char c;
short d;
}

**小端存储:**低字节写在低地址里
联合体内所有变量共用同一块地址空间
全局变量和静态变量默认初始化为0

数据结构有几种结构？
集合，一对一，一对多，多对多。四种！

OneByOne(一对一)

---------------------------------------------------------------------------------------------
元素同属一个集合,前后元素有关系并单向

例如:线性表:
一个表里面元素a1到aN,a1没有直接前驱有且仅有一个直接后继,ai作为中间元素,有且仅有一个直接前驱
和一个直接后继,aN作为表的尾元素,没有直接后继,有且仅有一个直接前驱

直接前驱也叫直接前件

线性表的两种储存结构

  • 顺序储存→数组
  • 链式储存→链表

递归和循环的优缺点
递归:代码简单,逻辑简单(便于阅读),但是函数跳转浪费时间,函数参数占用空间
循环:相对于递归,节约资源,但是每层循环逻辑必须弄清

stack(栈)

特性:先进后出,且只能操作栈顶
本质:也许是数组,也许是链表
stack

常用栈:单向链表,头添加,头删除

八个基本操作
  • Push 添加元素
  • Pop 删除元素
  • Init 初始化栈
  • Clear 清空栈
  • Deatroy 销毁栈
  • GetCount 获得栈元素个数
  • GetTop 得到栈顶
  • IsEmpty 判断是否是空栈
#include<stdio.h>
#include<stdlib.h>

typedef struct node1
{
	int nValue;
	struct node1 *pNext;
}MyStack;

typedef struct node2
{
	MyStack *pTop;
	int nCount;
}Stack;

//初始化
void s_Init(Stack **pStack)
{
	if(pStack == NULL)return;
	*pStack = (Stack*)malloc(sizeof(Stack));
	(*pStack)->pTop = NULL;
	(*pStack)->nCount = 0;
}

//压栈
void s_Push(Stack *pStack,int nNum)
{
	MyStack *pTemp = NULL;

	if(pStack == NULL)
	{
		printf("栈没啦!!!\n");
		return;
	}

	//开辟新节点装载值
	pTemp = (MyStack*)malloc(sizeof(MyStack));
	pTemp->nValue = nNum;
	pTemp->pNext = pStack->pTop;

	pStack->pTop = pTemp;
	pStack->nCount++;
}

//出栈
int s_Pop(Stack *pStack)
{
	MyStack *pDel = NULL;
	int nNum;
	if(pStack == NULL || pStack->pTop == NULL)return -1;

	pDel = pStack->pTop;
	nNum = pDel->nValue;

	pStack->pTop = pStack->pTop->pNext;
	free(pDel);
	pDel = NULL;
	pStack->nCount--;
	return nNum;
}

//清空
void s_Clear(Stack *pStack)
{
	if(pStack == NULL || pStack->pTop == NULL)return;

	while(pStack->nCount)
	{
		s_Pop(pStack);
	}
}

//销毁
void s_Destroy(Stack **pStack)
{
	s_Clear(*pStack);
	free(*pStack);
	*pStack = NULL;
}

//获得栈内元素个数
int s_GetCount(Stack *pStack)
{
	if(pStack == NULL)return -1;

	return  pStack->nCount;
}

//获得栈顶
MyStack *s_GetTop(Stack *pStack)
{
	if(pStack == NULL)return NULL;
	return pStack->pTop;
}

//是否为空栈
int s_IsEmpty(Stack *pStack)
{
	if(pStack == NULL)return -1;

	return (pStack->nCount)?0:1;
}

int main()
{
	Stack *pStack = NULL;
	s_Init(&pStack);

	s_Push(pStack,1);
	s_Push(pStack,2);
	s_Push(pStack,3);
	s_Push(pStack,4);
	s_Push(pStack,5);

	printf("%d\n",s_Pop(pStack));
	printf("%d\n",s_Pop(pStack));

	printf("-------------------------------------------------\n");
	printf("%d\n",s_GetCount(pStack));

	s_Destroy(&pStack);
	s_Push(pStack,5);
	return 0;
}

***二级指针的使用:***一般是参数无中生有,和从有到无

递归相当于栈的实际应用
因为:解决大问题的方式与其子问题方式一致(定义)

斐波那契数列FIBONACCI

也叫***黄金分割数列***

#include<stdio.h.>
#include<stdlib.h>
int Fibonacci_1(int n)//迭代法
{
	if (n<=2)
	{
		return 1;
	}
	return Fibonacci_1(n-1)+Fibonacci_1(n-2);
}
int Fibonacci_2(int n)
{

	int i = 3;
	int a = 1;
	int b = 1;
	int c = 0;
	if (n<=2)
	{
		return 1;
	}
	for ( ;i <=n; i++)
	{
		c = a+b;
		a = b;
		b = c;
	}

	return c;
}
int main()
{
	printf("%d\n",Fibonacci_1(10));
	printf("%d\n",Fibonacci_2(10));
	return 0;
}
四则运算

后缀表达式(逆波兰表示法)。
**中缀表示法:**例如:19+41*5-7/6,也叫表达式

转换规则

中缀转后缀(官方版)

借助辅助栈,遇到数字或字符直接打印,遇到符号(+ - * /),拿当前符号与栈顶元素进行优先级比较。如果当前元素优先级高直接入栈,如果当前元素优先级低,则直接出栈直到比当前元素优先级比它低的,如果遇到左括号无条件入栈,如果遇到右括号,将栈内元素依次出栈直到左括号停下来,如果没有元素,就将栈内元素全部拿出。

非官方版

所以运算加括号,将运算符放到括号后面。

后缀转中缀

遇到数字或字符直接进栈,遇到符号将栈顶元素下一个和栈顶元素构成表达式。

Queue

实际应用:打印机
特性:先进先出
queue

#include<stdio.h>
#include<stdlib.h>

typedef struct node3
{
	int nValue;
	struct node3 *pNext;
}MyQueue;

typedef struct node4
{
	int nCount;
	MyQueue* pHead;
	MyQueue *pTail;
}Queue;

void q_Init(Queue **pQueue)
{
	if(pQueue == NULL)return;
	*pQueue = (Queue*)malloc(sizeof(Queue));
	(*pQueue)->nCount = 0;
	(*pQueue)->pHead = NULL;
	(*pQueue)->pTail = NULL;
}

void q_Push(Queue *pQueue,int nNum)
{
	MyQueue *pTemp = NULL;
	if(pQueue == NULL)return;

	pTemp = (MyQueue*)malloc(sizeof(MyQueue));
	pTemp->nValue = nNum;
	pTemp->pNext = NULL;

	if(pQueue->pHead == NULL)
	{
		pQueue->pHead = pTemp;
	}
	else
	{
		pQueue->pTail->pNext = pTemp;
	}

	pQueue->pTail = pTemp;
	pQueue->nCount++;

}
int q_Pop(Queue *pQueue)
{
	MyQueue *pDel = NULL;
	int nNum;
	if(pQueue == NULL || pQueue->pHead == NULL)return -1;

	pDel = pQueue->pHead;
	nNum = pDel->nValue;

	pQueue->pHead = pQueue->pHead->pNext;
	free(pDel);
	pDel = NULL;
	pQueue->nCount--;

	if(pQueue->nCount == 0)
	{
		pQueue->pTail = NULL;
	}

	return nNum;
}

int q_IsEmpty(Queue *pQueue)
{
	if(pQueue == NULL )return -1;
	return pQueue->nCount ? 0:1;
}
Queue To Stack

用两个Queue(队列)实现Stack(栈)

#include<stdio.h>
#include<stdlib.h>

typedef struct node3
{
	int nValue;
	struct node3 *pNext;
}MyQueue;

typedef struct node4
{
	int nCount;
	MyQueue* pHead;
	MyQueue *pTail;
}Queue;

typedef struct node
{
	Queue *pQueue1;
	Queue *pQueue2;
	int nCount;
}Stack;


void q_Init(Queue **pQueue)
{
	if(pQueue == NULL)return;
	*pQueue = (Queue*)malloc(sizeof(Queue));
	(*pQueue)->nCount = 0;
	(*pQueue)->pHead = NULL;
	(*pQueue)->pTail = NULL;
}

void q_Push(Queue *pQueue,int nNum)
{
	MyQueue *pTemp = NULL;
	if(pQueue == NULL)return;

	pTemp = (MyQueue*)malloc(sizeof(MyQueue));
	pTemp->nValue = nNum;
	pTemp->pNext = NULL;

	if(pQueue->pHead == NULL)
	{
		pQueue->pHead = pTemp;
	}
	else
	{
		pQueue->pTail->pNext = pTemp;
	}

	pQueue->pTail = pTemp;
	pQueue->nCount++;

}

int q_Pop(Queue *pQueue)
{
	MyQueue *pDel = NULL;
	int nNum;
	if(pQueue == NULL || pQueue->pHead == NULL)return -1;

	pDel = pQueue->pHead;
	nNum = pDel->nValue;

	pQueue->pHead = pQueue->pHead->pNext;
	free(pDel);
	pDel = NULL;
	pQueue->nCount--;

	if(pQueue->nCount == 0)
	{
		pQueue->pTail = NULL;
	}

	return nNum;
}

int q_IsEmpty(Queue *pQueue)
{
	if(pQueue == NULL )return -1;
	return pQueue->nCount ? 0:1;
}

void s_Init(Stack **pStack)
{
	if(pStack == NULL)return;
	*pStack = (Stack*)malloc(sizeof(Stack));
	(*pStack)->nCount = 0;
	(*pStack)->pQueue1 = NULL;
	(*pStack)->pQueue2 = NULL;

	//初始化两个队列
	q_Init(&((*pStack)->pQueue1));
	q_Init(&((*pStack)->pQueue2));
}

void s_Push(Stack *pStack,int nNum)
{
	MyQueue *pTemp = NULL;
	if(pStack == NULL || pStack->pQueue1 == NULL || pStack->pQueue2 == NULL)return;
	
	//将数值放入非空队列
	if(!q_IsEmpty(pStack->pQueue1))
	{
		q_Push(pStack->pQueue1,nNum);
	}
	else
	{
		q_Push(pStack->pQueue2,nNum);
	}
}


int s_Pop(Stack *pStack)
{
	int nNum;
	if(pStack == NULL || (pStack->pQueue1 == NULL && pStack->pQueue2 == NULL))return -1;

	//检测非空队列
	if(!q_IsEmpty(pStack->pQueue1))
	{
		//将队列元素依次放入空队列里 直到剩一个的时候停下来
		while(pStack->pQueue1->nCount != 1)
		{
			q_Push(pStack->pQueue2, q_Pop(pStack->pQueue1) );
		}
		nNum = q_Pop(pStack->pQueue1);
	}
	else
	{
		//将队列元素依次放入空队列里 直到剩一个的时候停下来
		while(pStack->pQueue2->nCount != 1)
		{
			q_Push(pStack->pQueue1, q_Pop(pStack->pQueue2) );
		}
		nNum = q_Pop(pStack->pQueue2);
	}
	return nNum;
}
Stack To Queue

用两个栈实现队列

#include<stdio.h>
#include<stdlib.h>
typedef struct node1
{
	int nValue;
	struct node1 *pNext;
}MyStack;

typedef struct node2
{
	MyStack *pTop;
	int nCount;
}Stack;
typedef struct node3
{
	Stack *Mystack_1;
	Stack *Mystack_2;
	int nCount;
}MyQueue;

//初始化
void s_Init(Stack **pStack)
{
	if(pStack == NULL)return;
	*pStack = (Stack*)malloc(sizeof(Stack));
	(*pStack)->pTop = NULL;
	(*pStack)->nCount = 0;
}

//压栈
void s_Push(Stack *pStack,int nNum)
{
	MyStack *pTemp = NULL;

	if(pStack == NULL)
	{
		printf("栈没啦!!!\n");
		return;
	}

	//开辟新节点装载值
	pTemp = (MyStack*)malloc(sizeof(MyStack));
	pTemp->nValue = nNum;
	pTemp->pNext = pStack->pTop;

	pStack->pTop = pTemp;
	pStack->nCount++;
}

//出栈
int s_Pop(Stack *pStack)
{
	MyStack *pDel = NULL;
	int nNum;
	if(pStack == NULL || pStack->pTop == NULL)return -1;

	pDel = pStack->pTop;
	nNum = pDel->nValue;

	pStack->pTop = pStack->pTop->pNext;
	free(pDel);
	pDel = NULL;
	pStack->nCount--;
	return nNum;
}	
//是否为空栈
int s_IsEmpty(Stack *pStack)
{
	if(pStack == NULL)return -1;

	return (pStack->nCount)?0:1;
}
void q_Init(MyQueue **queue)
{
	if (queue == NULL )return;
	(*queue) = (MyQueue*)malloc(sizeof(MyQueue));
	(*queue)->Mystack_1 = NULL;
	(*queue)->Mystack_2 = NULL;
	s_Init(&(*queue)->Mystack_2);
	s_Init(&(*queue)->Mystack_1);
	(*queue)->nCount = 0;
}
void q_Push(MyQueue *queue,int nValue)
{
	s_Push(queue->Mystack_2,nValue);
	return;

}
int q_Pop(MyQueue *queue)
{

	int num;
	if (s_IsEmpty((queue)->Mystack_1))
	{
		while (queue->Mystack_2->nCount != 1)
		{
			s_Push((queue)->Mystack_1,s_Pop((queue)->Mystack_2));
		}
		num = s_Pop((queue)->Mystack_2);
		while (queue->Mystack_1->nCount != 0)
		{
			s_Push((queue)->Mystack_2,s_Pop((queue)->Mystack_1));
		}
	}

	return num;

}
Juinjonn
关注
专栏目录
数据结构王卓部分第一部分PPT.rar
03-21
数据结构是计算机科学中的核心课程，它探讨了如何在计算机中组织、存储和处理数据，以便高效地执行各种操作。...通过学习这个部分，你可以建立起对数据结构和算法的坚实基础，为后续的编程学习铺平道路。
数据结构--线性表
Yzhenfeng7的博客
12-10 1054
该篇文章通过学习慕课MOOC《数据结构》做的笔记内容，方便日后复习
设计表：1对n，n对1，和n对n
awodwde的博客
08-28 3268
1对n，n对1，和n对n，外键应该放在哪个表里 1对n，外键放在n的一端： 举例子： 周杰伦有很多很多粉丝，不可能让周记住所有粉丝的名字，而是应该所有粉丝都记得周的名字，所以外键应该放在多的一端的表里 n对n，放在其中的任何一张表都不合适：中间表存储对应关系 ...
数据结构（一）——数据结构简介
天山老妖
03-02 936
一、数据结构简介 数据结构是相互间存在特定关系的数据的集合，分为逻辑结构和物理结构。 1、逻辑结构 集合结构：数据元素之间没有特别的关系，仅同属相同集合。 线性结构：数据元素间是一对一的关系 树形结构：数据元素间存在一对多的层次关系 图形结构：数据元素之间是多对多的关系 2、物理结构 物理结构是逻辑结构在计算机中存储形式，分为顺序存储结构和链式存储结构。 顺序存储结构将数据存储在地址连续的存储单元里。 链式存储结构将数据存储在任意的存储单元里，通过保存地址的方式找到相关联的数据.
数据结构：八大常见数据结构
weixin_43062845的博客
11-26 5762
数据结构目录： 一、结构分类 二、区别联系 1. 数组 2. 栈 3. 队列 4. 链表 5. 树 6. 散列表 7. 堆 8. 图 数据结构是指，相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。常用的数据结构有：数组、栈、队列、链表、树、散列表、堆、图。 一、结构分类： 数据结构大多是以三种分类方式分类，分别是逻辑结构，物理结构，存储结构，一般来讲大多是以逻辑结...
数据库设计方法、规范与技巧（推荐）
bjguan's BLOG
10-15 2336
数据库设计方法、规范与技巧（推荐）   一、数据库设计过程数据库技术是信息资源管理最有效的手段。数据库设计是指对于一个给定的应用环境，构造最优的数据库模式，建立数据库及其应用系统，有效存储数据，满足用户信息要求和处理要求。数据库设计中需求分析阶段综合各个用户的应用需求（现实世界的需求），在概念设计阶段形成独立于机器特点、独立于各个DBMS产品的概念模式（信息世界
数据结构1800试题.pdf
05-02
线性结构的数据元素呈一对一关系，而非线性结构则更为复杂，如树形结构中数据元素间存在一对多或多对多关系。 - **存储结构**：数据结构的实现方式，如顺序存储（数组）和链式存储（链表）。 3. **数据结构的术语*...
青岛大学王卓数据结构与算法课程PPT截图
02-17
"线性表"是基本的数据结构之一。它是一组逻辑上相邻的元素序列，具有插入、删除、查找等基本操作。线性表的"顺序表示和实现"是指在数组中存储线性表，操作简单但空间利用率低；而"链式表示"使用链表，虽然增加了额外...
线性
qq_41988508的博客
10-31 703
线性表 线性表的定义 ： 线性表是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。 这种一对一的关系是指数据元素之间的位置关系，即： 1、除第一个位置的数据元素之外，其他数据元素搁置的前面都只有一个数据元素； 2、除最后一个位的置数据元素外， 其他 数据元素位置的后面都只有一个元素。 也就是说，数据元素是一个接一个地排列的。因此，...
python 数据结构篇
热门推荐
qq_62047219的博客
07-07 2万+
python中的数据结构实现：数组、链表（单链表、双向链表、双向循环链表）、队列（FIFO、LIFO/栈、优先级队列、双端队列）、树（二叉树、堆、树、森林）、图
基于JAVA的数据结构及算法（一）
Zwjue_的博客
12-02 243
数据的逻辑结构有4种：1.集合：数据仅仅属于同一个集合，没有其他的相互关系 2.线性：一对一 3.树形：一对多 4.图形：多对多 数据的逻辑结构一般采用二元组的形式定义： 数据结构 = （D,S) D：数据元素的集合。 S：D中元素之间的关系的集合...
java数据结构与算法_day1
weixin_52977653的博客
03-30 314
数据结构分为： 线性结构：数组、队列、链表和栈 数据元素之间存在一对一关系 具有两种不同存储结构： 顺序存储结构：线性表称为顺序表，其中的存储元素是连续(地址连续)的 链式存储结构：线性表称为链表，其中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息 非线性结构：二维数组、多维数组...
Java数据结构之单链表
m0_58290966的博客
01-16 304
一、单链表基本内容 用一组任意的内存单元存储数据，内存单元可以连续也可以不连续。 元素之间的关系，用指针来表示。对于任意元素ai，即要存储本身的数据，还要存储其直接后继元素a(i+1)的位置信息。 存储数据元素信息的叫做数据域，存储直接后继元素位置信息的叫做指针域，整体组成数据元素ai 的存储映像，叫做节点。 链表有带头节点的和不带头节点的。带头结点的，头节点的数据域可以存储信息，也可以不存储信息。指针域存储的是第一个节点在内存中的位置，之后的每个节点，其实就是上一个元素的后继指针指向的节点。 .
数据结构---Java版
最新发布
qq_63897791的博客
11-24 2582
🎈数据结构通常有四种基本类型：集合结构，线性结构（一对一），树形结构（一对多），图形结构或网状结构（多对多）；主要描述的三个方面的内容：数据的逻辑结构、物理结构、数据的操作集合。🎈数据的逻辑结构与数据在计算机中的具体存储没有关系，主要包括集合、线性、树形、图形结构，有两个要素，数据结构的集合（D）和D上的关系集（反映了D中元素的前驱后继关系）。🎈数据的物理结构又称存储结构，有顺序和链式两种方式：🎶顺序存储的特点是数据元素在存储器中的相对位置来说体现数据元素的逻辑关系，通常用一维数组来实现。
数据结构-树的简介
tiehui1987的博客
08-22 489
数据结构–树的简介 文章目录数据结构--树的简介@[toc]一，树的定义二，节点间的关系三，树的表示法四，二叉树五，总结 一，树的定义 一对一的数据结构是线性结构，一对多的数据结构中包含树。 树是N个节点的有限集合。如果N=0称为空树。 有且只有一个特定的称为根的节点。 其余节点可分为M个互不相交的有限集合。每一个集合本身又是一颗树，并且称为根的子树。 二，节点间的关系 节点的子树的根称为该节点的孩子，相应地，该节点称为孩子的双亲（Parent） 同一个双亲（parent）的孩子之间互称兄弟（si
数据结构——链式结构
addy_li的博客
10-24 1221
数据结构——链式结构 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录数据结构——链式结构一、创建空链表二、单链表1.节点的插入方法（头插法和尾插法）2.单链表代码三、单链表的反转反转方法一：总结 一、创建空链表 typedef struct Node { int data; struct Node* next; }Node; //创建空链表 Node* creatList() { Node* list = (Node*)malloc(sizeof(struct Node
[数据结构]线性表链式结构及基本操作
weixin_43717520的博客
04-06 1838
链表
数据结构之表（顺序表、链表、栈、队列）（一对一关系）
Glanic的博客
08-17 809
顺序表和链式表的实现 顺序表： 数据项： 存储元素的内存首地址 表的容量 元素的数量 运算： 创建、销毁、清空、插入、删除、访问、查询、修改、排序、遍历 注意点： 1、不要越界 2、时刻保持元素的连续性 优点：支持随机访问，修改、访问、排序的效率比较高，大块的连续的内存不容易产生内存碎片 缺点：对内存的要求比较高(内存连续)，插入、删除元素时很不方便、效
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Juinjonn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值