数据结构

最新推荐文章于 2023-04-17 18:51:59 发布
最新推荐文章于 2023-04-17 18:51:59 发布
阅读量143 收藏
点赞数
分类专栏： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LokTar29/article/details/95747891
版权

数据结构的四种基本类型

  1. 集合：元素之间没有任何关系

  2. 线性表：元素之间存在一对一关系
    数组、链表、功能受限的表（栈、队列）

  3. 树：元素之间存在一对多关系
    普通树、二叉树、完全二叉树、满二叉树、有序二叉树

  4. 图：元素之间存在多对多关系
    邻接表、表的遍历（深度优先、广度优先）、最短路径

数据结构的存储方式（物理结构）

  1. 顺序：再一块连续的内存空间上存储元素与元素之间的关系。
    优点是查找速度快（随机访问），不易产生内存碎片。缺点是对内存要求高，添加和删除不方便。

  2. 非顺序：元素随机存储内存空间中，元素中存储指向其他元素的地址。
    有点是对内存要求低，添加删除方便，查找速度慢（只能从头逐个遍历），容易产生内存碎片。

栈：限制为只有一个端口进出元素，就导致先进后出的特性。
一般常用于，表达式解析，内存管理（函数的调用提供支持）。
顺序栈的实现

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


#define TYPE int

typedef struct Stack
{
	TYPE* arr;//内存首地址
 	size_t len;//栈的内容
 	int top;//栈顶的下标
}Stack;
//创建
Stack* creat_stack(size_t cal);
//销毁
void destory_stack(Stack* stack);
//入栈
bool push_stack(Stack *stack,TYPE data);
//出栈
bool pop_stack(Stack* stack);
//栈空
bool empty_stack(Stack* stack);
//栈满
bool full_stack(Stack* stack);
//栈顶
TYPE* top_stack(Stack* stack);


int main()
{
	Stack* stack = creat_stack(15);
 	printf("开始入栈\n");
 	for(int i= 0 ;i<20;i++)
 	{
  		printf("入栈%s",push_stack(stack,i)?"成功":"失败");
  		printf("栈顶%d\n",*top_stack(stack));
 	}
 	printf("开始出栈\n");
 	for(int i= 19 ;i>=0;i--)
 	{
  		printf("出栈%s",pop_stack(stack)?"成功":"失败");
  		printf("栈顶%d\n",*top_stack(stack));
 	}
}

//创建
Stack* creat_stack(size_t cal)
{
 	Stack* stack = malloc(sizeof(Stack));
 	stack->arr = malloc(sizeof(TYPE)*cal);
 	stack->len = cal;
 	stack->top =-1;
 	return stack;
}
//销毁
void destory_stack(Stack* stack)
{
	free(stack->arr);
	free(stack);
}
//入栈
bool push_stack(Stack *stack,TYPE data)
{
	if(full_stack(stack)) return false;
  	stack->arr[++stack->top]=data;
  	return true;
}
//出栈
bool pop_stack(Stack* stack)
{
	if (empty_stack(stack)) return false;
	stack->arr[--stack->top];
	return true;
}
//栈空
bool empty_stack(Stack* stack)
{
	return-1  == stack->top;
}
//栈满
bool full_stack(Stack* stack)
{
	return (stack->top+1 >= stack->len);
}
//栈顶
TYPE* top_stack(Stack* stack)
{
	if(empty_stack(stack)) return NULL;
	return stack->arr+stack->top;
}

链式栈的实现

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

#define TYPE int 

typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;


Node* creat_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;

}

typedef struct Stack
{
	Node* top;
	size_t len;
}Stack;

//创建
Stack* creat_stack(void);
//销毁
void destory_stack(Stack* stack);
//栈空
bool empty_stack(Stack* stack);
//入栈
void push_stack(Stack* stack,TYPE data);
//出栈
bool pop_stack(Stack* stack);
//栈顶
TYPE* top_stack(Stack* stack);

int main()
{
	Stack* stack = creat_stack();
	for (int i=0;i<10;i++)
	{
		push_stack(stack,i);
		printf("top:%d\n",*top_stack(stack));
	}
	printf("------------\n");
	for (int i=0;i<10;i++)
	{
		printf("top:%d\n",*top_stack(stack));
		printf("出栈%s\n",pop_stack(stack)?"成功":"失败");
	}
}



//创建
Stack* creat_stack(void)
{
	Stack* stack=malloc(sizeof(Stack));
	stack->top = NULL;
	stack->len = 0;
	return stack;
}
//销毁
void destory_stack(Stack* stack)
{
	while(pop_stack(stack));
	free(stack);

}
//栈空
bool empty_stack(Stack* stack)
{
	return NULL  == stack->top;
}
//入栈
void push_stack(Stack* stack,TYPE data)
{
	Node* node = creat_node(data);
	node->next = stack->top;
	stack->top = node;
	stack->len++;
}
//出栈
bool pop_stack(Stack* stack)
{
	if(empty_stack(stack)) return false;
	Node* node = stack->top;
	stack->top = node->next;
	free(node);
	stack->len--;
	return true;
	
	
}
//栈顶
TYPE* top_stack(Stack* stack)
{
	if(empty_stack(stack)) return NULL;
	return &stack->top->data;	
}

队列：限制为有个端口进出元素，一个只管进，另一个只管出，就导致先进先出特性。

顺序队列的实现

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


#define TYPE int 

typedef struct 	Queue
{
	TYPE* base;
	int size;  
	int head;   //队头
	int tall;   //队尾
	int cnt;   //数量
}Queue;

//创建
Queue * creat_queue(int len);
//销毁
void destory_queue(Queue* queue);
//队空
bool empty_queue(Queue* queue);
//队满
bool full_queue(Queue* queue);
//入队
bool push_queue(Queue* queue,TYPE data);
//出队
bool pop_queue(Queue* queue);
//队头
TYPE* head_queue(Queue* queue);
//队尾
TYPE* tall_queue(Queue* queue);


int main()
{
	Queue* queue =creat_queue(10);
	for (int i=0;i<10;i++)
	{
		printf("入队%s,",push_queue(queue,i)?"成功":"失败");
		printf("队尾:%d\n",*tall_queue(queue));
	}
	for(int i=0;i<5;i++)
	{
		printf("队头:%d,",*head_queue(queue));
		printf("出队%s\n",pop_queue(queue)?"成功":"失败");
	}
	for (int i=77;i<88;i++)
	{
		printf("入队%s,",push_queue(queue,i)?"成功":"失败");
		printf("队尾:%d\n",*tall_queue(queue));
	}
	


}



//创建
Queue * creat_queue(int len)
{
	Queue* queue=malloc(sizeof(Queue));
	queue->base=malloc(sizeof(TYPE)*len);
	queue->size=len;
	queue->head=0;
	queue->tall=-1;
	queue->cnt=0;
	return queue;
}
//销毁
void destory_queue(Queue* queue)
{
	free(queue->base);
	free(queue);
}
//队空
bool empty_queue(Queue* queue)
{
	return !queue->cnt;
}
//队满
bool full_queue(Queue* queue)
{
	return queue->cnt>=queue->size;
}
//入队
bool push_queue(Queue* queue,TYPE data)
{
	//判断是否队满
	//回头
	if (full_queue(queue))  return false;
	queue->tall = (queue->tall+1) % queue->size;
	queue->base[queue->tall] =data;
	queue->cnt++;
	return true;
}
//出队
bool pop_queue(Queue* queue)
{
	//判断是否对空
	//回头
	if (empty_queue(queue))  return false;
	queue->head = (queue->head+1) % queue->size;
	queue->cnt--;
	return true;
}
//队头
TYPE* head_queue(Queue* queue)
{
	if (empty_queue(queue)) return NULL;
	return queue->base+queue->head;
}
//队尾
TYPE* tall_queue(Queue* queue)
{
	if (empty_queue(queue)) return NULL;
	return queue->base+queue->tall;
}

链式队列的实现

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

#define TYPE int

typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

Node* creat_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}


typedef struct Queue
{
	Node* head;
	Node* tail;
	size_t size;
}Queue;

//创建
Queue* creat_queue(void);
//销毁
void destory_queue(Queue* queue);
//入队
void push_queue(Queue* queue,TYPE* data);
//出队
bool pop_queue(Queue* queue);
//查看队头
TYPE* head_queue(Queue* queue);
//查看队尾
TYPE* tail_queue(Queue* queue);
//队空
bool empty_queue(Queue* queue);




int main()
{
	Queue* queue =creat_queue();
	for (int i=0;i<10;i++)
	{
		printf("入队%s,",push_queue(queue,i)?"成功":"失败");
	//	printf("队尾:%d\n",*tall_queue(queue));
	}
	for(int i=0;i<5;i++)
	{
	//	printf("队头:%d,",*head_queue(queue));
		printf("出队%s\n",pop_queue(queue)?"成功":"失败");
	}
}





//创建
Queue* creat_queue(void)
{
	Queue* queue = malloc(sizeof(Queue));
	queue->head = NULL;
	queue->tail = NULL;
	queue->size = 0;
}
//销毁
void destory_queue(Queue* queue)
{
	while(pop_queue(queue));
	free(queue);
}
//入队
void push_queue(Queue* queue,TYPE* data)
{
	Node* node = creat_node(data);
	if (0 == queue->size)
	{
		queue->head = node;
		queue->tail = node;
	}
	else
	{
		queue->tail->next = node;
		queue->tail = node;
	}
	queue->size++;
}
//出队
bool pop_queue(Queue* queue)
{
	if (empty_queue(queue)) return false;
	Node* temp = queue->head;
	if (1 === queue->size)
	{
		queue->tail = NULL;

	}

	while(temp->next != queue->tail)
	{
		temp = temp->next;
	}
	free(queue->tail);
	queue->tail = temp;
	temp->next = NULL;
	queue->size--;
}
//查看队头
TYPE* head_queue(Queue* queue);
//查看队尾
TYPE* tail_queue(Queue* queue);
//队空
bool empty_queue(Queue* queue)
{
	return !queue->size;
}

表：每个元素都独立存储在内存中的任意位置，元素之间由指针指向来维护关系。

顺序表的实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define TYPE int

//设计数据结构
typedef struct Array
{
	TYPE* base;    //数组首地址
	size_t size;   //元素的个数
}Array;


//创建
Array*create_array(size_t len);
//销毁
void destory_array(Array* arr);
//访问
TYPE* access_array(Array* arr,int index);
//查找
int find_array(Array*arr,TYPE data);
//排序
void sort_array(Array* arr);
//遍历
void show_array(Array* arr);
//删除
bool delete_array(Array* arr,int index);
//插入
bool insert_array(Array* arr,int index,TYPE data);




int main()
{
	Array* arr=create_array(20);
	for(int i=0;i<20;i++)
	{
		//*access_array(arr,i)=rand() % 100;
		TYPE* p=access_array(arr,i);
		if (NULL!=p)
			*access_array(arr,i)=rand() % 100;
	}
	show_array(arr);
	sort_array(arr);
	show_array(arr);
	delete_array(arr,4);
	show_array(arr);
	
}



//创建
Array*create_array(size_t len)
{
	Array* arr=malloc(sizeof(Array));
	arr->base=malloc(sizeof(TYPE)*len);
	arr->size=len;
	return arr;
}
//销毁
void destory_array(Array* arr)
{
	free(arr->base);
	free(arr);
}
//访问
TYPE* access_array(Array* arr,int index)
{
	if (index<0|index>=arr->size)  return NULL;
	return arr->base+index;	
}
//查找
int find_array(Array*arr,TYPE data)
{
	for(int i=0;i<arr->size;i++)
	{
		if (data = arr->base[i])
			return i;
	}
	return -1;
}
//排序
void sort_array(Array* arr)
{
	for(int i=0;i<arr->size-1;i++)
	{
		for(int j=i+1;j<arr->size;j++)
		{
			if (arr->base[i]>arr->base[j])
			{
				TYPE temp=arr->base[i];
				arr->base[i]=arr->base[j];
				arr->base[j]=temp;
			}
		}
	}

}
//遍历
void show_array(Array* arr)
{
	for(int i=0;i<arr->size;i++)
	{
		printf("%d ",arr->base[i]);
	}
	printf("\n");
}
//删除
bool delete_array(Array* arr,int index)
{
	if (index<0 |index>arr->size) return false;
	for (int i=index;i<arr->size-1;i++)
	{
		arr->base[i]=arr->base[i+1];
	}
	return true;
}
//插入
bool insert_array(Array* arr,int index,TYPE data)
{
	if (index<0 |index>arr->size) return false;
	for (int i=arr->size-1;i<index;i--)
	{
		arr->base[i]=arr->base[i-1];
	}
	arr[index]=data;
	return true;
}

链式表的实现

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

#define TYPE int

typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

// 创建节点
Node* creat_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

typedef struct List
{
	Node* head;
	Node* tail;
	size_t size;
}List;

// 创建
List* creat_list(void);
// 销毁
void destory_list(List* list);
// 头添加
void head_add_list(List* list,TYPE data);
// 尾添加
void tail_add_list(List* list,TYPE data);
// 头删除
bool head_del_list(List* list);
// 尾删除
bool tail_del_list(List* list);
// 插入
bool insert_list(List* list,int index,TYPE data);
// 位置删除
bool delete_index_list(List* list,int index);
// 值删除
bool delete_value_list(List* list,TYPE data);
// 排序
void sort_list(List* list);
// 遍历
void show_list(List* list);

int main()
{
	List* list  = creat_list();
	for(int i=0; i<10; i++)
	{
		//tail_add_list(list,i);
		head_add_list(list,i);
	}
	show_list(list);
	delete_index_list(list,9);
	delete_index_list(list,0);
	//insert_list(list,-1,100);
	show_list(list);
	/*
	show_list(list);
	sort_list(list);
	show_list(list);
	for(int i=0; i<5; i++)
	{
		head_del_list(list);
	}
	show_list(list);
	*/
}

// 创建
List* creat_list(void)
{
	List* list = malloc(sizeof(List));
	list->head = NULL;
	list->tail = NULL;
	return list;
}

// 销毁
void destory_list(List* list)
{
	while(0 < list->size)
	{
		head_del_list(list);
	}

	free(list);
}

// 头添加
void head_add_list(List* list,TYPE data)
{
	Node* node = creat_node(data);

	if(0 == list->size)
	{
		list->head = node;
		list->tail = node;
	}
	else
	{
		node->next = list->head;
		list->head = node;
	}
	list->size++;
}

// 尾添加
void tail_add_list(List* list,TYPE data)
{
	Node* node = creat_node(data);

	if(0 == list->size)
	{
		list->head = node;
		list->tail = node;
	}
	else
	{
		list->tail->next = node;
		list->tail = node;
	}
	list->size++;
}

// 头删除
bool head_del_list(List* list)
{
	if(0 >= list->size) return false;

	Node* temp = list->head;
	list->head = temp->next;
	
	if(1 == list->size) 
	{
		list->tail = NULL;
	}

	free(temp);
	list->size--;
	return true;
}

// 尾删除
bool tail_del_list(List* list)
{
	if(0 >= list->size) return false;
	
	if(1 == list->size)
	{
		head_del_list(list);
		return true;
	}

	Node* prev = list->head;
	while(prev->next != list->tail)
	{
		prev = prev->next;
	}

	free(list->tail);
	list->tail = prev;
	prev->next = NULL;
	list->size--;
	
	return true;
}

// 插入
bool insert_list(List* list,int index,TYPE data)
{
	if(index < 0 || index >= list->size) return false;
	
	if(0 == index)
	{
		head_add_list(list,data);
		return true;
	}

	Node* prev = list->head;
	for(int i=0; i<index-1; i++)
	{
		prev = prev->next;
	}

	Node* node = creat_node(data);
	node->next = prev->next;
	prev->next = node;
	list->size++;
	
	return true;
}

// 位置删除
bool delete_index_list(List* list,int index)
{
	if(index < 0 || index >= list->size) return false;
	
	if(0 == index)
		head_del_list(list);
	else if(list->size == index+1)
		tail_del_list(list);
	else
	{
		Node* prev = list->head;
		for(int i=0; i<index-1; i++)
		{
			prev = prev->next;
		}

		Node* node = prev->next;
		prev->next = node->next;
		free(node);
		list->size--;
	}
	return  true;
}

// 值删除
bool delete_value_list(List* list,TYPE data)
{
	if(data == list->head->data)
	{
		head_del_list(list);
		return true;
	}

	Node* prev = list->head;
	while(NULL!=prev->next)
	{
		if(data == prev->next->data)
		{
			Node* node = prev->next;
			prev->next = node->next;
			free(node);
			list->size--;
			return true;
		}
		prev = prev->next;
	}
	return false;
}

// 排序
void sort_list(List* list)
{
	for(Node* i=list->head; NULL != i->next; i=i->next)
	{
		for(Node* j=i->next; NULL != j; j=j->next)
		{
			if(i->data > j->data)
			{
				TYPE temp = i->data;
				i->data = j->data;
				j->data = temp;
			}
		}
	}
}

// 遍历
void show_list(List* list)
{
	for(Node* node=list->head; NULL!=node; node=node->next)
	{
		printf("%d ",node->data);
	}
	printf("\n");
}

双向链表的实现

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

#define TYPE int

typedef struct Node
{
	struct Node* prev;	// 前一个元素
	TYPE data;			// 数据
	struct Node* next;	// 后一个元素
}Node;

// 创建节点
Node* creat_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->prev = NULL;
	node->data = data;
	node->next = NULL;
	return node;
}

typedef struct List
{
	Node* head;
	Node* tail;
	size_t size;
}List;

// 创建
List* creat_list(void);
// 销毁
void destory_list(List* list);
// 头加
void head_add_list(List* list,TYPE data);
// 尾加
void tail_add_list(List* list,TYPE data);
// 插入
bool insert_list(List* list,int index,TYPE data);
// 位置删除
bool delete_index_list(List* list,int index);
// 值删除
bool delete_value_list(List* list,TYPE data);
// 遍历
void show_list(List* list);
bool del_head_list(List* list);
bool del_tail_list(List* list);

int main()
{
	List* list = creat_list();
	for(int i=0; i<10; i++)
	{
		tail_add_list(list,i);
	}
	insert_list(list,1,100);
	show_list(list);
	delete_value_list(list,0);
	delete_value_list(list,100);
	delete_value_list(list,9);
	show_list(list);
	destory_list(list);
}

// 创建
List* creat_list(void)
{
	List* list = malloc(sizeof(List));
	list->head = NULL;
	list->tail = NULL;
	list->size = 0;
	return list;
}

// 销毁
void destory_list(List* list)
{
	while(list->size>0)
	{
		del_tail_list(list);
	}
	free(list);
}

// 头加
void head_add_list(List* list,TYPE data)
{
	Node* node = creat_node(data);

	if(0 == list->size)
	{
		list->head = node;
		list->tail = node;
	}
	else
	{
		node->next = list->head;
		list->head->prev = node;
		list->head = node;
	}

	list->size++;
}

// 尾加
void tail_add_list(List* list,TYPE data)
{
	Node* node = creat_node(data);
	if(0 == list->size)
	{
		list->head = node;
		list->tail = node;
	}
	else
	{
		list->tail->next = node;
		node->prev = list->tail;
		list->tail = node;
	}
	list->size++;
}

// 插入
bool insert_list(List* list,int index,TYPE data)
{
	if(index < 0 || index >= list->size) return false;
	if(0 == index)
	{
		head_add_list(list,data);
		return true;
	}

	Node* next = NULL;
	if(index < list->size/2)
	{
		next = list->head;
		for(int i=0; i<index; i++)
		{
			next = next->next;
		}
	}
	else
	{
		next = list->tail;
		for(int i=list->size-1; i>index; i--)
		{
			next = next->prev;
		}
	}
	Node* prev = next->prev;
	Node* node = creat_node(data);

	node->next = next;
	node->prev = prev;
	prev->next = node;
	next->prev = node;
	list->size++;

	return true;
}

// 删除头
bool del_head_list(List* list)
{
	if(list->size <= 0) return false;
	Node* node = list->head;
	if(1 == list->size)
	{
		list->head = NULL;
		list->tail = NULL;
	}
	else
	{
		list->head = node->next;
		node->next->prev = NULL;
	}
	free(node);
	list->size--;
	return true;
}

// 删除尾
bool del_tail_list(List* list)
{
	if(list->size <= 0) return false;
	Node* node = list->tail;
	if(1 == list->size)
	{
		list->head = NULL;
		list->tail = NULL;
	}
	else
	{
		list->tail = node->prev;
		node->prev->next = NULL;
	}
	free(node);
	list->size--;
	return true;
}

// 位置删除
bool delete_index_list(List* list,int index)
{
	if(index < 0 || index >= list->size) return false;
	if(0 == index) return del_head_list(list);
	if(list->size-1 == index) return del_tail_list(list);

	Node* node = NULL;
	if(index < list->size/2)
	{
		node = list->head;
		for(int i=0; i<index; i++)
		{
			node = node->next;
		}
	}
	else
	{
		node = list->tail;
		for(int i=list->size-1; i>index; i--)
		{
			node = node->prev;
		}
	}

	Node* prev = node->prev;
	Node* next = node->next;
	
	prev->next = next;
	next->prev = prev;
	free(node);
	list->size--;
	return true;
}

// 值删除
bool delete_value_list(List* list,TYPE data)
{
	if(data == list->head->data) 
		return del_head_list(list);
	if(data == list->tail->data)
		return del_tail_list(list);
	
	Node* node = list->head;
	while(NULL != node)
	{
		if(data == node->data) break;
		node = node->next;
	}

	Node* prev = node->prev;
	Node* next = node->next;
	
	prev->next = next;
	next->prev = prev;
	free(node);
	list->size--;
	return true;
	
}

// 遍历
void show_list(List* list)
{
	for(Node* i=list->head; i!=NULL; i=i->next)
	{
		printf("%d ",i->data);
	}
	printf("\n");
	for(Node* i=list->tail; i!=NULL; i=i->prev)
	{
		printf("%d ",i->data);
	}
	printf("\n");
}
一生红蓝
关注
专栏目录
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
《趣学数据结构》课件.rar
10-03
《趣学数据结构》课件.rar 《趣学数据结构》课件.rar《趣学...《趣学数据结构》课件.rar《趣学数据结构》课件.rar《趣学数据结构》课件.rar《趣学数据结构》课件.rar《趣学数据结构》课件.rar《趣学数据结构》课件.rar
C#数据结构与算法
qq_41603955的博客
03-15 7727
一、数据结构介绍 为什么学习数据结构？ 对于同样的问题，有的人写出来的程序效率高，而有的人却用很复杂的方法解决。 学习数据结构的目的是：能用最有效的方法解决绝大多数的问题。 学习数据结构的三个目的： 1.讲授常用的数据结构 这些数据结构形成了程序员基本数据结构工具箱(toolkit)。对于许多常见的问题，工具箱里的数据结构是理想的选择。就像.NET Framework 中 Windows 应用程序开发中的工具箱，程序员可以直接拿来或经过少许的修改就可以使用，非常方便。 2.讲授常用的算法 它和
数据结构知识总结
梦呓~ bolg
01-22 1646
前言：算法+数据结构=程序 什么是数据结构？ 简单说，数据结构就是一个容器，以某种特定的布局存储数据。这个“布局”使得数据结构在某些操作上非常高效，在另一些操作上则没那么高效。所以，我们需要根据不同的问题场景选择最优的数据结构。 为什么我们需要数据结构？ 由于数据结构用来以有组织的形式存储数据，而且数据是计算机中最重要的实体，数据结构的价值显而易见。 根据不同是场景，数据需要以特定格式存储。 常用...
约瑟夫环数据结构
youngcm1的博客
06-13 8957
/编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持有一个密码(正整数)。 一开始任选一个整数作为报数上限值m，从第一个人开始顺时针自1开始顺序报数， 报到m时停止报数。报m的人出列，将他的密码作为新的m值， 从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有的人全部出列为止。 试设计一个函数，可输出出列顺序。 要求：1使用线性表实现， 2函数输入参数为n个人密码的数组、n的值，m的初始值，输出参数为出列序数组/ #define MAXSIZE 9999 typedef struct n
redis底层数据结构 -String
liang只的博客
12-22 3630
redis包含5种常用数据结构 String 、List、Hash、Set 、Zset String 字符串不同的外在形式 以set为例 redis其实可以理解为 K-V数据库，因此对每个键值对都会有一个 dictEntry，里面存储了指向 Key 和 Value 的指针；next 指向下一个 dictEntry，与本 Key-Value 无关 key 可以看出 key不是直接存的字符串，而是一个SDS结构 value value既然不是存的String，也不...
【Java 数据结构】树和二叉树
最新发布
书生-w的博客
04-17 1万+
树是一种非线性的数据结构，它是由n个(n>=0)个有限节点组成一个具有层次关系的集合。它的形状像一颗倒挂的树，根在上，叶在下。 特点： · 有一个特殊的结点称为根节点，根节点没有前驱结点 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1,T2,.....,Tm，其中每一个集合又是一颗与树类似的字树。每棵子树的根节点有且只有一个前驱，可以没有或者多个后继 · 树是递归定义的 注意：在树形结构中，子树不能有交集，否则就不是树形结构
“数据结构”课程的内容
weixin_43312392的博客
09-29 1794
前期课程 计算机基础、C语言…… 数据结构承上启下 后期课程 算法设计与分析、操作系统、编译原理、数据库原理、软件工程……
数据结构与算法基础（王卓）（2）：线性表的初始化及结构整理
Zz_zzzzzzz__的博客
11-29 2495
位置：PPT：46；其中ElemType表示：线性表中的元素的类型也可以是自己自定义的数据结构类型位置：PPT：62；
半边数据结构【Half Edge】
新缸中之脑
11-11 2734
表示多边形网格的常用方法是共享顶点列表和存储其顶点索引的面列表。这种表示既方便又对于许多目的都是有效的，但是在某些领域它被证明是无效的。Half Edge就是解决网格中邻接元素查询的一种数据结构。
数据结构思维导图
qq_44111805的博客
04-18 1867
第一章 绪论 第二章 线性表 第三章 栈和队列 第四章 串 第五章 树与二叉树 第七章 查找 以上思维导图是由我在考研期间准备数据结构所绘，主要结合王道数据结构使用，但缺少了第六章图和第八章排序的思维导图请见谅。使用思维导图工具是幕布，大家可以自行补上缺少的部分。 ...
数据结构与算法——线性表的顺序储存结构
xzt12138的博客
07-20 7003
顺序储存结构就是在内存中找了一块地，将一组数据以连续的方式将其储存在这块内存中。而且每个元素的数据类型相同，所以我们可以用C语言的一维数组来实现顺序储存结构。即，把第一个数据元素存到下标为0的位置，接着把线性表相邻的元素储存在数组中相邻的位置。......
《初识数据结构》教学建议.pdf
08-07
### 数据结构的基本概念 数据结构是计算机存储、组织数据的方式。它旨在使数据的存取和处理更加高效。数据结构通常由数据对象和数据关系两部分构成。数据对象是指具有相同数据类型的元素的集合；数据关系则定义了...
西北民族大学--数据结构考试卷答案.pdf
08-17
"西北民族大学--数据结构考试卷答案.pdf" 以下是根据提供的文件信息生成的相关知识点： 数据结构定义 数据结构是由一个逻辑结构和这个逻辑结构上的一个基本运算集构成的整体。 数据结构分类 数据结构可以分为...
[详细完整版]数据结构.txt
07-11
线性数据结构部分： 一、填空题 1. 数据结构包括数据的逻辑结构、 数据的储存结构 和数据的运算三个方面。 2. 数据结构包括 逻辑结构 、数据的存储结构和数据的运算三个方面。 3. 在算法"正确"的前提下，评价算法...
基于C++的酒店管理系统
LokTar29的博客
08-22 5322
酒店管理系统： 前提: 楼层，房间编号，房间类型，价格 开房：姓名，房间，随行人员，押金，时长 续费：延时，修改类型 退房：押金，消费 实现：在class.h中构建出房间以及顾客的两个类以及访问和修改类中私有成员的成员函数，然后在class.cpp中实现这些成员函数，func中实现开房、续费、查询、退房等具体的功能函数。 main.c #include <iostream> #in...
基于TCP的C/S模型文件传输
LokTar29的博客
08-09 1035
实现： 文件上传 文件下载 通过命令行查看服务器的各层文件：cd、ls、mkdir、exit server.c #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include &l...
运算符重载返回值的引用或临时对象
LokTar29的博客
08-17 757
const Point operator+(const Point& that) const { return Point(that.x+x,that.y+y); } const Point& operator+=(const Point& that) { x += that.x; y += that.y; return *this; } ...
Linux上使用Git连接GitHub
LokTar29的博客
08-29 606
Git版本控制系统是一个分布式的系统，是用来保存工程源代码历史状态的命令行工具 Linux和Windows上都可以使用Git工具连接码云或者GitHub，这可以很方便的进行代码的下载以及上传。 具体步骤： 1、在终端输入 sudo apt-get install git 进行下载和安装Git 2、在终端输入 git config --global user.name “user_name” 引号内...
数据结构基础概念解析
"数据结构概念名词解释大全" 数据结构是计算机科学中不可或缺的一部分，它主要研究数据的组织方式，以及如何高效地存储和处理这些数据。以下是对标题和描述中涉及的一些关键概念的详细解释： 1. **数据**：数据是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值