数据结构基本概念_及栈stack

数据结构基本概念

数据结构：

是相互之间存在一种或多种特定关系的数据元素的集合

数据结构的三个层次：

抽象层-逻辑结构、结构层-物理结构、实现层-运算结构

数据结构三要素：

逻辑结构、物理结构、运算结构

1. 逻辑结构：分为线性结构和非线性结构

(1) 集合：数据元素之间同属于一个集合，无其他关系只堆积在一起，属于非线性结构
(2) 线性表：数据元素之间存在一对一的关系，属于线性结构
(3) 树形结构：数据元素之间存在一对多的关系，属于非线性结构
(4) 图/网状结构：数据元素之间存在多对多的关系，属于非线性结构

2. 物理结构：也称存储结构，分为顺序存储、链式存储、索引存储、散列存储

(1) 顺序结构：使用连续的内存地址，数据元素由存储单元邻接关系来体现(数组描述)，随机存取访好、空间利用程度不好、插删差；顺序表(数组)、顺树
(2) 链式结构：用不连续的内存地址(也可连续)，数据元素是节点组成，节点由数据和地址组成，随机存取访不好、空间利用程度充分、插删好；链式表(链表)、链树

3. 运算结构：在数据上运算包括定义与实现

(1)定义：针对逻辑结构的，指出运算的功能
(2)实现：针对物理结构的，指出运算具体操作步骤，如创建销毁、插入删除、取出修改、排序查找

数据结构中的栈(stack)

• 栈：是一种受限的线性表只能在某一端进行插入和删除操作，只允许在一端进行插入或删除操作的线性表。
• 特点：先进后出，后进先出(LIFO)。如：进1.2.3.4.5，出5.4.3.2.1；想象30对袜子往洗衣机扔，然后洗衣机吐出来(没洗之前)，从上开始吐到下完。723老辉说猪肉荣过堆袜臭的洗衣机都停电咧！我完美舒适清晰巨美丽的表达诗意，说了一句成功在于积累！nice！！
• 栈顶：线性表允许进行插入和删除的一端。
• 栈底：固定的，不允许进行插入和删除的另一端。
• 空栈：不含任何元素的空表

栈的顺序存储结构，顺序表的实现

定义声明函数：

/**
 *C实现：定义声明函数
 */
#ifndef SEQUENCE_H_INCLUDED
#define SEQUENCE_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
typedef struct Stack_sx{
	int* arr;   //数组首地址
	size_t cap; //容量
	size_t top; //下标/栈顶
}STACK_SX;
//初始化栈
void stack_sx_init(STACK_SX* stack, size_t cap);
//释放化栈
void stack_sx_deinit(STACK_SX* stack);
//判断栈空
int stack_sx_empty(STACK_SX* stack);
//判断栈满
int stack_sx_full(STACK_SX* stack);
//入栈
void stack_sx_push(STACK_SX* stack, int data);
//出栈
int stack_sx_pop(STACK_SX* stack);
//查看栈顶
int stack_sx_top(STACK_SX* stack);
//元素数量
size_t stack_sx_size(STACK_SX* stack);

#endif // SEQUENCE_H_INCLUDED

声明函数实现：

/**
 *C实现：声明函数实现
 */
#include "sequence.h"

//初始化栈
void stack_sx_init(STACK_SX* stack, size_t cap)
{
	stack->arr = malloc(cap * sizeof(int));
	stack->cap = cap;
	stack->top = 0;
}
//释放化栈
void stack_sx_deinit(STACK_SX* stack)
{
	free(stack->arr);
	stack->arr = NULL;
	stack->cap = 0;
	stack->top = 0;
}
//判断栈空
int stack_sx_empty(STACK_SX* stack)
{
	return !stack->top;
}
//判断栈满
int stack_sx_full(STACK_SX* stack)
{
	return stack->top >= stack->cap;
}
//入栈
void stack_sx_push(STACK_SX* stack, int data)
{
	stack->arr[stack->top++] = data;
}
//出栈
int stack_sx_pop(STACK_SX* stack)
{
	stack->top--;
	return stack->arr[stack->top];
}
//查看栈顶
int stack_sx_top(STACK_SX* stack)
{
	return stack->arr[stack->top-1];
}
//元素数量
size_t stack_sx_size(STACK_SX* stack)
{
	return stack->top;
}

实现函数验证：

/**
 *C实现：实现函数验证
 */
#include "sequence.h"

int main()
{
	int i;
	STACK_SX stack_sx;
	stack_sx_init(&stack_sx, 5);//初始
	for(i = 0; !stack_sx_full(&stack_sx); i++){//判断满后退出
		stack_sx_push(&stack_sx, i+1);//入栈
	}
	printf("栈顶=%d\n", stack_sx_top(&stack_sx));//栈顶
	printf("数量=%d\n", stack_sx_size(&stack_sx));//数量
	while(!stack_sx_empty(&stack_sx)){//判断空后，不在出栈
		printf("%d\n", stack_sx_pop(&stack_sx));//出栈
	}
	stack_sx_deinit(&stack_sx);释放
	return 0;
}

结果：

概念这种东西，每个人的逻辑思维都不同，希望经过整理自己能够更好的理解。受益匪浅

链式结构我下次再整理写吧，我很困了
这是我第一次写博客，纪念19/4/27—凌晨4:35

栈的链式存储结构，链式表的实现

定义声明函数：

/**
 *C实现：定义声明函数
 */
#ifndef CHAIN_H_INCLUDED
#define CHAIN_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
typedef struct StackNode{	//节点结构
	int data;				//数据
	struct StackNode* next;	//指向下一个节点地址
}STACK_NODE;
typedef struct Stack_ls{	//栈结构
	STACK_NODE* top;		//栈顶节点指针
}STACK_LS;
//初始化栈
void stack_ls_init(STACK_LS* stack);
//释放化栈
void stack_ls_deinit(STACK_LS* stack);
//判断栈空
int stack_ls_empty(STACK_LS* stack);
//入栈
void stack_ls_push(STACK_LS* stack, int data);
//出栈
int stack_ls_pop(STACK_LS* stack);
//查看栈顶
int stack_ls_top(STACK_LS* stack);
//元素数量
size_t stack_ls_size(STACK_LS* stack);

#endif //CHAIN_H_INCLUDED

声明函数实现：

/**
 *C实现：声明函数实现
 */
#include "chain.h"

//创建节点(创建一个)
static STACK_NODE* create_stack_node(STACK_NODE* next, int data)
{
	STACK_NODE *node = malloc(sizeof(STACK_NODE));
	node->data = data;
	node->next = next;
	return node;
}
//销毁节点(销毁一个)
static STACK_NODE* destroy_stack_node(STACK_NODE* node)
{
	STACK_NODE* next = node->next;
	free(node);
	return next;
}
//初始化栈
void stack_ls_init(STACK_LS* stack)
{
	stack->top = NULL;
}
//释放化栈(释放空间)
void stack_ls_deinit(STACK_LS* stack)
{
	while(stack->top){
		stack->top = destroy_stack_node(stack->top);
	}
}
//判断栈空(没满)
int stack_ls_empty(STACK_LS* stack)
{
	return !stack->top;
}
//入栈
void stack_ls_push(STACK_LS* stack, int data)
{
	stack->top = create_stack_node(stack->top, data);
}
//出栈
int stack_ls_pop(STACK_LS* stack)
{
	int data = stack->top->data;
	stack->top = destroy_stack_node(stack->top);
	return data;
}
//查看栈顶
int stack_ls_top(STACK_LS* stack)
{
	return stack->top->data;
}
//元素数量
size_t stack_ls_size(STACK_LS* stack)
{
	size_t size = 0;
	STACK_NODE* node = stack->top;
	for(; node; node = node->next)size++;
	return size;
}

实现函数验证：

/**
 *C实现：实现函数验证
 */
#include "chain.h"

int main()
{
	int i;
	STACK_LS stack_ls;
	stack_ls_init(&stack_ls);//初始
	for(i = 0; i < 5; i++){
		stack_ls_push(&stack_ls, i+1);//入栈
	}
	printf("栈顶=%d\n", stack_ls_top(&stack_ls));//栈顶
	printf("数量=%d\n", stack_ls_size(&stack_ls));//数量
	while(!stack_ls_empty(&stack_ls)){//判断空，不在出栈
		printf("%d\n", stack_ls_pop(&stack_ls));//出栈
	}
	stack_ls_deinit(&stack_ls);//释放
	return 0;
}

结果：

下一篇队列(FIFO),受益匪浅，侵权立删，蟹蟹