1. Toy模板网首页
  2. > Toy博客

【数据结构】一篇带你彻底吃透 顺序表

9月前 作者：虾米Life 分类：Toy博客 阅读(77) 违法举报

这篇具有很好参考价值的文章主要介绍了【数据结构】一篇带你彻底吃透 顺序表。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1 - 顺序表的概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改等功能。

  • 顺序表一般可以分为：
  1. 静态顺序表：使用定长数组存储元素。
  2. 动态顺序表：使用动态开辟的数组存储。

而现实的顺序表大多数采用动态的，因为静态顺序表有几个缺点，当然还有优点.我们下面就展开讲讲

静态顺序表缺点：

  1. 插入和删除操作需要移动大量的元素
  2. 当线性表长度变化较大时，难以确定存储空间的容量
  3. 造成存储空间的 “碎片”

静态顺序表优点：

  1. 可以快速访问任一元素

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小。

相对总体来说静态顺序表是不够优的，所有该文章我们就讲解动态顺序表，当然最后还会附上静态顺序表的全代码.

  • 存储顺序表结构需要三个属性
  1. 存储空间的起始位置:数据data .
  2. 线性表的存储容量: capacity
  3. 线性表的当前长度: sz
struct SeqListNode
{
	STDataType* data; 
	int sz;       //顺序表元素个数
	int capacity; //顺序表容量
};

2 - 动态顺序表接口实现

存储结构三个属性

typedef int STDataType; //方便以后要存储其它类型。

//动态通讯录
typedef struct SeqListNode
{
	STDataType* data;  //动态开辟的数组
	int sz;  //顺序表元素个数
	int capacity; //顺序表容量
}SeqNode;

初始化顺序表

//初始化顺序表
void Seqinit(SeqNode* head)
{
	assert(head); //断言:判断是否为空指针
	head->data = NULL;  //首先指向NULL
	head->sz = 0;       //初始顺序个数为0
	head->capacity = 0; //初始容量为0
}

顺序表增容

顺序表添加元素时，都需检测一下是否要增容。不然会出现越界情况。
每次扩容为原来的2倍,如扩容太大会浪费空间。

void CheckCapacity(SeqNode* head)
{
	//断言:判断是否为空指针
	assert(head);
	int newcapacity = 0;//新容量
	if (head->sz == head->capacity)
	{
		if (head->capacity == 0)
			newcapacity = head->capacity = 4; //首次扩容为4
		else
			newcapacity = head->capacity * 2; //扩容为原来的2倍
		
		//扩容
		STDataType* tmp = NULL;
		if (head->data == NULL)
			tmp = (STDataType*)malloc(newcapacity * sizeof(STDataType)); //首次扩容
		else
			tmp = (STDataType*)realloc(head->data, sizeof(STDataType) * newcapacity); //再次扩容

		//检测扩容是否成功
		if (tmp == NULL)
		{
			//如果扩容失败就退出程序
			perror(" Capacityfile: ");
			exit(-1);
		}
		//扩容成功把内容给回顺序表属性
		head->data = tmp;
		head->capacity = newcapacity;
	}
}

顺序表尾插

//顺序表尾插
void SeqPushBack(SeqNode* head, STDataType x)
{
	assert(head);		  //断言:判断是否为空指针
	CheckCapacity(head);  //检测是否需要扩容
	
	head->data[head->sz] = x;  //要插入的数据
	head->sz++;  //顺序表容量+1
}

顺序表头插

头插算法思路

  1. 从最后个元素开始向前遍历到第0个位置，分别向后挪动一个位置.
  2. 将要插入元素填入首元素位置处
  3. 表长+1.
//顺序表头插
void SeqPushFront(SeqNode* head, STDataType x)
{
	assert(head);//断言:判断是否为空指针
	CheckCapacity(head);  //检测是否需要扩容

	//从前往后递推覆盖
	int i = head->sz - 1;
	for (i; i >= 0; i--)
	{
		head->data[i + 1] = head->data[i]; //将数据【0 - sz-1】向后递推覆盖
	}
	head->data[0] = x; //进行头插
	head->sz++;  //顺序表容量+1
}

顺序表尾删

直接把表长减一即可

//顺序表尾删
void SeqPopBack(SeqNode* head)
{
	assert(head);//断言:判断是否为空指针
	if (head->sz == 0) //判断顺序表是否有元素
	{
		printf("该顺序表为空，无法删除\n");
		return;
	}
	head->sz--;  //顺序表容量-1
}

顺序表头删

  1. 从第二个元素开始到最后一个元素,分别将他们都向前移动一个位置。
  2. 表长在减1。
//顺序表头删
void SeqPopFront(SeqNode* head)
{
	assert(head);//断言:判断是否为空指针
	if (head->sz == 0) //判断顺序表是否有元素
	{
		printf("该顺序表为空，无法删除\n");
		return;
	}
    
	//从后往前递推覆盖
	int i = 0;
	for (i = 0; i > head->sz-1; i--)
	{
		head->data[i] = head->data[i + 1]; //将数据从【1-sz-1】向前覆盖
	}
	head->sz--;  //顺序表容量-1
}

顺序表查找

只要遍历顺序表找到需要查找的值，如果找到返回他的下标即可.
找不到返回-1，

int SeqFind(const SeqNode* head, STDataType x)
{
	assert(head);//断言:判断是否为空指针
	if (head->sz == 0) //判断顺序表是否有元素
	{
		printf("该顺序表为空，无法查找\n");
		return -1;
	}
	
	int i = 0;
	for (i = 0; i < head->sz; i++)
	{
		if (head->data[i] == x) //查找到，就返回该元素下标
		{
			return i;
		}
	}
	return -1; //查找失败 返回-1
}

顺序表中删除指定下标数据

删除算法思路:

  1. 如果删除位置不合理，抛出异常.
  2. 从删除元素位置开始遍历到最后一个元素位置，分别将他们都向前挪动一个位置.
  3. 表长减1
//在顺序表中删除指定下标位置的数据
void SeqErase(SeqNode* head, int pos)
{
	assert(head);//断言:判断是否为空指针
	
	if (pos < 0 || head->sz == 0)
	{
		printf(" 要删除下标非法或者顺序表为空，删除失败\n");
		return ;
	}
	
	int i = pos;
	//将要删除的位置把后面的覆盖过来,最后在减
	for (i; i < head->sz-1; i++)
	{
		head->data[i] = head->data[i+1]; //将【pos+1 - sz-1】的数据向前挪动一个位置
	}
	head->sz--;//顺序表容量-1
}

在顺序表指定下标位置插入数据

插入算法的思路文章来源地址https://www.toymoban.com/news/detail-417910.html

  1. 如果删除位置不合理，抛出异常
  2. 从最后一个元素开始向前遍历到要插入的位置，分别将他们都向后移动一个位置
  3. 将元素添加到要插入的位置
  4. 表长+1
void SeqInsert(SeqNode* head, int pos, STDataType x)
{
	assert(head); //断言:判断是否为空指针
    void Seqmodify(SeqNode* head, int pos, STDataType x);
	if (pos < 0 )
	{
		printf(" 下标非法，删除失败\n");
		return;
	}
	CheckCapacity(head);  //检测是否需要扩容

	//将顺序表【pos - sz-1】从最后一个元素开始依次挪动到后一位
	int i = head->sz-1;
	for (i; i >= pos; i--)
	{
		head->data[i+1] = head->data[i]; //依次挪动到后一位，直到pos位置挪动到后一位
	}
	head->data[pos] = x; //插入数据
	head->sz++;    //顺序表容量+1
}

修改指定下标的值

//修改指定下标的值
void Seqmodify(SeqNode* head, int pos, STDataType x)
{
	assert(head);//断言:判断是否为空指针
	if (pos < 0 || head->sz == 0)
	{
		printf(" 要修改的下标非法或者顺序表为空，修改失败\n");
		return;
	}

	head->data[pos] = x;//修改数据;
}

获得顺序表个数

//查顺序表中有效数据个数
int Seqsize(const SeqNode* head)
{
	assert(head);//断言:判断是否为空指针
	return head->sz; //返回顺序表有效数据个数
}

顺序表打印

//顺序表打印
void Seqprint(const SeqNode* head)
{
	assert(head); //断言:判断是否为空指针
	if (head->sz == 0)
	{
		printf("顺序表为空，无法打印\n");
		return;
	}
	int i = 0;
	for (i = 0; i < head->sz; i++)
	{
		printf("%d ", head->data[i]);
	}
	printf("\n");
}

顺序表销毁

//顺序表销毁
void SeqDestroy(SeqNode* head)
{
	assert(head); //断言:判断是否为空指针

	free(head->data);
	head->data = NULL;  
	head->sz = 0;   
	head->capacity = 0;
}

3 - 动态顺序表全代码

SeqLish.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int STDataType;

//动态通讯录
typedef struct SeqListNode
{
	STDataType* data; 
	int sz;  //顺序表元素个数
	int capacity; //顺序表容量
}SeqNode;


//初始化链表
void Seqinit(SeqNode* head);

//增容
void CheckCapacity(SeqNode* head);

//顺序表尾插
void SeqPushBack(SeqNode* head, STDataType x);

//顺序表打印
void Seqprint(const SeqNode* head);

//顺序表销毁
void SeqDestroy(SeqNode* head);

//顺序表头插
void SeqPushFront(SeqNode* head, STDataType x);

//顺序表尾删
void SeqPopBack(SeqNode* head);

//顺序表头删
void SeqPopFront(SeqNode* head);

//顺序表查找
int SeqFind(const SeqNode* head, STDataType x);

//在顺序表中删除指定下标位置的数据
void SeqErase(SeqNode* head, int pos);

//在顺序表指定下标位置插入数据
void SeqInsert(SeqNode* head, int pos, STDataType x);

//修改指定下标的值
void Seqmodify(SeqNode* head, int pos, STDataType x);

//查顺序表中有效数据个数
int Seqsize(const SeqNode* head);

SeqLish.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"SeqList.h"

//初始化链表
void Seqinit(SeqNode* head)
{
	head->data = NULL;  //指向动态开辟的数组
	head->sz = 0;       //初始顺序个数为0
	head->capacity = 0; //初始容量为0
}

//顺序表销毁
void SeqDestroy(SeqNode* head)
{
	assert(head); //断言:判断是否为空指针

	free(head->data);
	head->data = NULL;  
	head->sz = 0;   
	head->capacity = 0;
}

//增容
void CheckCapacity(SeqNode* head)
{
	//断言:判断是否为空指针
	assert(head);
	int newcapacity = 0;//新容量
	if (head->sz == head->capacity)
	{
		if (head->capacity == 0)
			newcapacity = head->capacity = 4; //首次扩容为4
		else
			newcapacity = head->capacity * 2; //扩容为原来的2倍
		
		//扩容
		STDataType* tmp = NULL;
		if (head->data == NULL)
			tmp = (STDataType*)malloc(newcapacity * sizeof(STDataType)); //首次扩容
		else
			tmp = (STDataType*)realloc(head->data, sizeof(STDataType) * newcapacity); //再次扩容

		//检测扩容是否成功
		if (tmp == NULL)
		{
			//如果扩容失败就退出程序
			perror(" Capacityfile: ");
			exit(-1);
		}
		//扩容成功
		head->data = tmp;
		head->capacity = newcapacity;
	}
}

//顺序表尾插
void SeqPushBack(SeqNode* head, STDataType x)
{
	assert(head);		  //断言:判断是否为空指针
	CheckCapacity(head);  //检测是否需要扩容
	
	head->data[head->sz] = x;  //要插入的数据
	head->sz++;  //顺序表容量+1
}

//顺序表打印
void Seqprint(const SeqNode* head)
{
	assert(head); //断言:判断是否为空指针
	if (head->sz == 0)
	{
		printf("顺序表为空，无法打印\n");
		return;
	}
	int i = 0;
	for (i = 0; i < head->sz; i++)
	{
		printf("%d ", head->data[i]);
	}
	printf("\n");
}

//顺序表头插
void SeqPushFront(SeqNode* head, STDataType x)
{
	assert(head);//断言:判断是否为空指针
	CheckCapacity(head);  //检测是否需要扩容

	//从前往后递推覆盖
	int i = head->sz - 1;
	for (i; i >= 0; i--)
	{
		head->data[i + 1] = head->data[i]; //将数据【0 - sz-1】向后递推覆盖
	}
	head->data[0] = x; //进行头插
	head->sz++;  //顺序表容量+1
}

//顺序表尾删
void SeqPopBack(SeqNode* head)
{
	assert(head);//断言:判断是否为空指针
	if (head->sz == 0) //判断顺序表是否有元素
	{
		printf("该顺序表为空，无法删除\n");
		return;
	}
	head->sz--;  //顺序表容量-1
}

//顺序表头删
void SeqPopFront(SeqNode* head)
{
	assert(head);//断言:判断是否为空指针
	if (head->sz == 0) //判断顺序表是否有元素
	{
		printf("该顺序表为空，无法删除\n");
		return;
	}
    
	//从后往前递推覆盖
	int i = 0;
	for (i = 0; i > head->sz-1; i--)
	{
		head->data[i] = head->data[i + 1]; //将数据从【1-sz-1】向前覆盖
	}
	head->sz--;  //顺序表容量-1
}

//顺序表查找
int SeqFind(const SeqNode* head, STDataType x)
{
	assert(head);//断言:判断是否为空指针
	if (head->sz == 0) //判断顺序表是否有元素
	{
		printf("该顺序表为空，无法查找\n");
		return -1;
	}
	
	int i = 0;
	for (i = 0; i < head->sz; i++)
	{
		if (head->data[i] == x) //查找到，就返回该元素下标
		{
			return i;
		}
	}
	return -1; //查找失败 返回-1
}


//在顺序表中删除指定下标位置的数据
void SeqErase(SeqNode* head, int pos)
{
	assert(head);//断言:判断是否为空指针
	
	if (pos < 0 || head->sz == 0)
	{
		printf(" 要删除下标非法或者顺序表为空，删除失败\n");
		return ;
	}
	
	int i = pos;
	//将要删除的位置把后面的覆盖过来,最后在减
	for (i; i < head->sz-1; i++)
	{
		head->data[i] = head->data[i+1]; //将【pos+1 - sz-1】的数据向前挪动一个位置
	}
	head->sz--;//顺序表容量-1
}

//在顺序表指定下标位置插入数据
void SeqInsert(SeqNode* head, int pos, STDataType x)
{
	assert(head); //断言:判断是否为空指针
    void Seqmodify(SeqNode* head, int pos, STDataType x);
	if (pos < 0 )
	{
		printf(" 下标非法，删除失败\n");
		return;
	}
	CheckCapacity(head);  //检测是否需要扩容

	//将顺序表【pos - sz-1】从最后一个元素开始依次挪动到后一位
	int i = head->sz-1;
	for (i; i >= pos; i--)
	{
		head->data[i+1] = head->data[i]; //依次挪动到后一位，直到pos位置挪动到后一位
	}
	head->data[pos] = x; //插入数据
	head->sz++;    //顺序表容量+1
}


//修改指定下标的值
void Seqmodify(SeqNode* head, int pos, STDataType x)
{
	assert(head);//断言:判断是否为空指针
	if (pos < 0 || head->sz == 0)
	{
		printf(" 要修改的下标非法或者顺序表为空，修改失败\n");
		return;
	}

	head->data[pos] = x;//修改数据;
}


//查顺序表中有效数据个数
int Seqsize(const SeqNode* head)
{
	assert(head);//断言:判断是否为空指针
	return head->sz; //返回顺序表有效数据个数
}

4 - 静态顺序表全代码

SeqLish.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

#define Max 100
typedef int STDataType;

//静态顺序表
typedef struct SeqListNode
{
	STDataType data[Max]; 
	int sz;    //顺序表数量
	int capacity;  //顺序表容量
}SeqNode;

//初始化
void Seqinit(SeqNode* head);

//增容
void CheckCapacity(SeqNode* head);

//顺序表尾插
void SeqPushBack(SeqNode* head, STDataType x);

//顺序表头插
void SeqPushFront(SeqNode* head, STDataType x);

//顺序表尾删
void SeqPopBack(SeqNode* head);

//顺序表头删
void SeqPopFront(SeqNode* head);

//顺序表打印
void Seqprint(const SeqNode* head);

//顺序表销毁
void SeqDestory(SeqNode* head);

//顺序表查找
int SeqFind(const SeqNode* head, STDataType x);

//在顺序表中删除指定下标位置的数据
void SeqErase(SeqNode* head, int pos);

//在顺序表指定下标位置插入数据
void SeqInsert(SeqNode* head, int pos, STDataType x);

//修改指定下标的值
void Seqmodify(SeqNode* head, int pos, STDataType x);

//查顺序表中有效数据个数
int Seqsize(const SeqNode* head);

SeqLish.c

#include"SeqList.h"

//顺序表初始化
void Seqinit(SeqNode* head)
{
	assert(head);
	head->capacity = 0;
	head->sz = 0;
}

//是否需要增容
void CheckCapacity(SeqNode* head)
{
	assert(head);
	if (head->sz == head->capacity)
	{
		if (head->capacity == Max)
		{
			perror("通讯录已满，无法增容:");
			exit(-1);
		}
		if (head->capacity == 0)
			head->capacity = 4;
		else
		{
			head->capacity *= 2;
			if (head->capacity > Max)
				head->capacity = Max;
		}
	}
}

//顺序表打印
void Seqprint(const SeqNode* head)
{
	assert(head);
	if (head->sz == 0)
	{
		perror("顺序表元素为空,请重新增加元素\n");
		return;
	}
	
	int i = 0;
	for (i = 0; i < head->sz; i++)
	{
		printf("%d ", head->data[i]);
	}
	printf("\n");
}

//顺序表尾插
void SeqPushBack(SeqNode* head, STDataType x)
{
	assert(head);
	CheckCapacity(head);
	head->data[head->sz] = x;
	head->sz++;
}

//顺序表头插
void SeqPushFront(SeqNode* head, STDataType x)
{
	assert(head);
	CheckCapacity(head);
    
	int i = head->sz - 1;
	for (i; i >= 0; i--)
	{
		head->data[i + 1] = head->data[i];
	}
	head->data[0] = x;
	head->sz++;
}

//顺序表尾删
void SeqPopBack(SeqNode* head)
{
	assert(head);
	head->sz--;
}

//顺序表头删
void SeqPopFront(SeqNode* head)
{
	assert(head);
	int i = 0;
	for (i = 1; i < head->sz; i++)
	{
		head->data[i-1] = head->data[i];
	}
	head->sz--;
}

//顺序表销毁
void SeqDestory(SeqNode* head)
{
	head->capacity = 0;
	head->sz = 0;
}

//顺序表查找
int SeqFind(const SeqNode* head, STDataType x)
{
	assert(head);
	if (head->sz == 0)
	{
		perror("顺序表为空\n");
		return -1;
	}
	int i = 0;
	for (i = 0; i < head->sz; i++)
	{
		//找到返回下标
		if (head->data[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//在顺序表中删除指定下标位置的数据
void SeqErase(SeqNode* head, int pos)
{
	assert(head);
	if (head->sz == 0)
	{
		perror("顺序表为空\n");
		return;
	}
	
	int i = pos;
	for (i; i < head->sz-1; i++)
	{
		head->data[i] = head->data[i + 1];
	}
	head->sz--;
}

//在顺序表指定下标位置插入数据
void SeqInsert(SeqNode* head, int pos, STDataType x)
{
	assert(head);
	CheckCapacity(head);
	int i = head->sz - 1;;
	for (i; i >= pos ; i--)
	{
		head->data[i+1] = head->data[i];
	}
	head->data[pos] = x;
	head->sz++;
}

//修改指定下标的值
void Seqmodify(SeqNode* head, int pos, STDataType x)
{
	assert(head);
	if (head->sz == 0)
	{
		perror("顺序表为空,无法修改\n");
		return;
	}
	head->data[pos] = x;
}

//查顺序表中有效数据个数
int Seqsize(const SeqNode* head)
{
	assert(head);
	return head->sz;
}

到了这里，关于【数据结构】一篇带你彻底吃透 顺序表的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【Python】一篇带你掌握数据容器之列表

    【Python】一篇带你掌握数据容器之列表

    目录 前言： 一、列表 1.列表的定义 2.列表的下标索引 3.列表的常用操作 （1）index方法：查找某元素的下标 (2)修改特定位置下标的元素 （3）insert（下标，元素）方法：插入元素 （4）append（元素）方法：追加元素1 （5）extend（其他数据容器）方法：追加元素2 （6）del（列表

    2024年02月05日
    浏览(51)
  • 【Mysql】一篇带你了解数据定义，操作和查询语言

    【Mysql】一篇带你了解数据定义，操作和查询语言

    目录 数据定义语言DDL（Data Definition Language） 一.对数据库的操作 二.对数据表的操作 数据操作语言DML（Data Manipulation Language） 一.添加 insert into 二.删除  delete 三.修改  update 数据查询语言DQL（Data Query Language） 一.查询 select 二. 1.between ... and ...（在....之间） 2.in, exists

    2024年02月12日
    浏览(84)
  • 手把手教你 ，带你彻底掌握八大排序算法【数据结构】

    手把手教你 ，带你彻底掌握八大排序算法【数据结构】

    直接插入排序是一种简单的插入排序法，其基本思想:是把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 可以理解为一遍摸扑克牌，一边进行排序 在待排序的元素中，假设前面n-1(其中n=2)个数

    2024年02月02日
    浏览(60)
  • 【数据结构】一篇文章带你彻底学会《后缀表达式》

    【数据结构】一篇文章带你彻底学会《后缀表达式》

    创作不易，本篇文章如果帮助到了你，还请点赞 关注支持一下♡𖥦)!! 主页专栏有更多知识，如有疑问欢迎大家指正讨论，共同进步！ 🔥c语言系列专栏：c语言之路重点知识整合 🔥 给大家跳段街舞感谢支持！ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ 后缀表

    2024年02月05日
    浏览(55)
  • 【无标题】一篇文章带你彻底理解Java ArrayList数据结构详解

    【无标题】一篇文章带你彻底理解Java ArrayList数据结构详解

    基本概念： ​ **之前创建数组的时候，需要声明提前声明数组的大小，**ArrayList是一个可以动态修改的数组，与普通数组的区别就是没有固定大小的限制，它会动态调整长度。 ​ **ArrayList继承了AbstractList，并实现了List接口。**如下图： **ArrayList 类位于 java.util 包中，**使用前

    2024年02月14日
    浏览(55)
  • 一篇带你精通MPLS

    一篇带你精通MPLS

    MPLS：多协议标签交换 可以基于多种不同的3层协议来生成2.5层的标签信息 包为网络层的PDU，故包交换就是基于IP地址进行数据转发；也就是路由器的路由行为。（路由器和终端基于3层的IP地址数据转发的路由行为） 原始包交换 查两张表 在包交换过程中，数据包每经过一个路

    2024年02月22日
    浏览(47)
  • 数组（一篇带你掌握数组）

    数组（一篇带你掌握数组）

        在之前，我们想要存储一个数据的时候可以创建变量，例如存储一个整形的变量，我们使用int类型的变量来存储，那么如果存储一组相同类型的数据呢？这时我们就引入了 数组 的概念。 目录 一、一维数组的创建和初始化 1.1数组的创建 1.2 数组的初始化 1.3 一维数组的使

    2023年04月08日
    浏览(47)
  • 数据结构与算法之美学习笔记：41 | 动态规划理论：一篇文章带你彻底搞懂最优子结构、无后效性和重复子问题

    数据结构与算法之美学习笔记：41 | 动态规划理论：一篇文章带你彻底搞懂最优子结构、无后效性和重复子问题

    本节课程思维导图： 今天，我主要讲动态规划的一些理论知识。学完这节内容，可以帮你解决这样几个问题：什么样的问题可以用动态规划解决？解决动态规划问题的一般思考过程是什么样的？贪心、分治、回溯、动态规划这四种算法思想又有什么区别和联系？ 什么样的问

    2024年02月02日
    浏览(64)
  • [Linux 基础] 一篇带你了解linux权限问题

    [Linux 基础] 一篇带你了解linux权限问题

    Linux下有两种用户：超级用户（root）、普通用户。 超级用户：可以再linux系统下做任何事情，不受限制 普通用户：在linux下做有限的事情。 超级用户的命令提示符是“#”，普通用户的命令提示符是“ $ ” 命令： su [用户名] 功能： 切换用户。 例如，要从root用户切换到普通用

    2024年02月08日
    浏览(46)
  • 【C语言】-- 一篇带你了解指针，内存，解引用

    【C语言】-- 一篇带你了解指针，内存，解引用

    目录 1、什么是指针？ 1.1 内存 1.2 指针变量 二、指针和指针类型 1、指针类型 2、指针+整数 3、指针的解引用 三、野指针 1、野指针成因 (1) 指针未初始化 (2) 指针越界访问 (3) 指针指向的空间释放 2、如何规避野指针 四、指针运算 1、指针-指针        本篇文章我们来了解C语

    2024年02月16日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包