顺序表（更新版）——“数据结构与算法”

2023-05-16

各位CSDN的uu们你们好呀，今天小雅兰又来更新新专栏啦，其实之前我就已经写过了顺序表的内容，只是之前的内容不是最新版的顺序表，现在，我来更新一下最新版的顺序表，下面，就让我们进入更新版的顺序表的世界吧

顺序表和小雅兰之前写的三子棋、扫雷、通讯录一样，分为三个文件：

https://xiaoyalan.blog.csdn.net/article/details/128705747?spm=1001.2014.3001.5502

https://xiaoyalan.blog.csdn.net/article/details/128717749?spm=1001.2014.3001.5502

https://xiaoyalan.blog.csdn.net/article/details/128717749?spm=1001.2014.3001.5502

https://xiaoyalan.blog.csdn.net/article/details/129788167?spm=1001.2014.3001.5502

https://xiaoyalan.blog.csdn.net/article/details/129896970?spm=1001.2014.3001.5502

test.c——测试代码功能

SeqList.c——顺序表的实现

SeqList.h——顺序表的声明

https://xiaoyalan.blog.csdn.net/article/details/129380414?spm=1001.2014.3001.5502

这是小雅兰之前写的顺序表的知识，有兴趣的可以去看看

我们写的是一个动态版的顺序表：

typedef struct SeqList
{
	SLDataType* a;
	int size;//存储的有效数据的个数
	int capacity;//容量
}SL;

把struct SeqList这个结构体重命名为SL

typedef int SLDataType;
把int重命名为SLDataType

写成这样的形式是因为：如果以后想要修改类型，那就直接改int就可以了，如果不这样写， 要改很多个地方，就很麻烦

顺序表的初始化：
//初始化
void SLInit(SL* ps1)
{
	ps1->a = malloc(sizeof(SLDataType) * 4);
	if (ps1 == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps1->size = 0;
	ps1->capacity = 4;
}
动态开辟出4个SLDataType类型的大小的空间

顺序表的销毁：也就是把空间还给操作系统

//销毁
//把空间还给操作系统
void SLDestroy(SL* ps1)
{
	free(ps1->a);
	ps1->a = NULL;
	ps1->size = 0;
	ps1->capacity = 0;
}

打印顺序表的内容：

//打印
void SLPrint(SL* ps1)
{
	int i = 0;
	for (i = 0; i < ps1->size; i++)
	{
		printf("%d ", ps1->a[i]);
	}
	printf("\n");
}

尾插：

ps1->a[ps1->size] = x;
ps1->size++;

在这里，我们需要想一个问题：在尾插的过程中，如果空间不够了该怎么办呢？？？所以在这里，我们还需要一个检查容量的函数，如果容量不够就扩容

//检查容量，容量不够就扩容
void SLCheckCapacity(SL* ps1)
{
	if (ps1->size == ps1->capacity)
	{
		SLDataType* tmp = (SLDataType*)realloc(ps1->a, sizeof(SLDataType) * ps1->capacity * 2);
		//扩上一个二倍大小的容量
		//这个数值可以自己设定，扩多了不好，扩少了也不好
		//所以扩上二倍是最合理的选择
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps1->a = tmp;
		ps1->capacity = ps1->capacity * 2;
	}
}

//尾插
void SLPushBack(SL* ps1, SLDataType x)
{
	SLCheckCapacity(ps1);
	ps1->a[ps1->size] = x;
	ps1->size++;
}

下面，我们来测试一下尾插的功能，看是否成功

int main()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushBack(&s, 5);
	SLPushBack(&s, 6);
	SLPushBack(&s, 7);
	SLPushBack(&s, 8);
	SLPushBack(&s, 9);
	SLPushBack(&s, 10);
	SLPrint(&s);
	SLDestroy(&s);
	return 0;
}

结果发现，尾插的功能非常成功！！！

头插：

需要从后往前挪动数据！！！

若是从前往后挪动数据，就会覆盖，这是绝对不行的
//头插
void SLPushFront(SL* ps1, SLDataType x)
{
	SLCheckCapacity(ps1);
	//挪动数据
	int end = ps1->size - 1;
	while (end >= 0)
	{
		ps1->a[end + 1] = ps1->a[end];//把数据往后挪
		end--;
	}
	ps1->a[0] = x;
	ps1->size++;
}

来测试一下头插的功能：

//头插测试
void TestSeqList2()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushFront(&s, 5);
	SLPushFront(&s, 6);
	SLPushFront(&s, 7);
	SLPushFront(&s, 8);
	SLPushFront(&s, 9);
	SLPrint(&s);
	SLDestroy(&s);
}

尾删：

直接把size--就可以了
//尾删
void SLPopBack(SL* ps1)
{
	ps1->size--;
}

来测试一下尾删的功能：

//尾删测试
void TestSeqList3()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushFront(&s, 5);
	SLPushFront(&s, 6);
	SLPushFront(&s, 7);
	SLPushFront(&s, 8);
	SLPushFront(&s, 9);
	SLPrint(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPrint(&s);
	SLDestroy(&s);
}

但是这个尾删仍然有点问题，需要检查一下：

//尾删
void SLPopBack(SL* ps1)
{
	//温柔的检查
	if (ps1->size == 0)
	{
		return;
	}
	ps1->size--;
}

//尾删
void SLPopBack(SL* ps1)
{
    //暴力的检查
	assert(ps1->size > 0);
	ps1->size--;
}

头删：

//头删
void SLPopFront(SL* ps1)
{
	//暴力检查
	assert(ps1->size > 0);
	int start = 0;
	while (start < ps1->size - 1)
	{
		ps1->a[start] = ps1->a[start + 1];
		start++;
	}
	ps1->size--;
}

来测试一下头删的功能：

//头删测试
void TestSeqList4()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushFront(&s, 5);
	SLPushFront(&s, 6);
	SLPushFront(&s, 7);
	SLPushFront(&s, 8);
	SLPushFront(&s, 9);
	SLPrint(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPrint(&s);
	SLPopFront(&s);
	SLPopFront(&s);
	SLPopFront(&s);
	SLPrint(&s);
	SLDestroy(&s);
}

在中间位置插入数据：

//在中间位置(pos)插入数据
void SLInsert(SL* ps1, int pos, SLDataType x)
{
	SLCheckCapacity(ps1);
	int end = ps1->size - 1;
	while (end >= pos)
	{
		ps1->a[end + 1] = ps1->a[end];
		end--;
	}
	ps1->a[pos] = x;
	ps1->size++;
}

写了这个函数的功能之后，我们就可以把之前写的头插和尾插修改一下：

//尾插
void SLPushBack(SL* ps1, SLDataType x)
{
   SLInsert(ps1, ps1->size, x);
}

//头插
void SLPushFront(SL* ps1, SLDataType x)
{
   SLInsert(ps1, 0, x);
}

但是，这个在中间插入数据的代码还是有点问题;

//中间插数据测试
void TestSeqList5()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushFront(&s, 5);
	SLPushFront(&s, 6);
	SLPushFront(&s, 7);
	SLPushFront(&s, 8);
	SLPushFront(&s, 9);
	SLPrint(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPrint(&s);
	SLPopFront(&s);
	SLPopFront(&s);
	SLPopFront(&s);
	SLPrint(&s);
	SLInsert(&s, 2, 30);
	SLPrint(&s);
	SLInsert(&s, 20, 300);
	SLPrint(&s);
	SLDestroy(&s);
}

从此运行结果可知：越界是不会报错的！！！但是它的的确确越界了！！！

所以把代码改进为：

//在中间位置(pos)插入数据
void SLInsert(SL* ps1, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps1->size);
	SLCheckCapacity(ps1);
	int end = ps1->size - 1;
	while (end >= pos)
	{
		ps1->a[end + 1] = ps1->a[end];
		end--;
	}
	ps1->a[pos] = x;
	ps1->size++;
}

在中间位置删除数据：

//在中间位置(pos)删除数据
void SLErase(SL* ps1, int pos)
{
	assert(pos >= 0 && pos < ps1->size);
	assert(ps1->size > 0);//可有可无
	int start = pos + 1;
	while (start <= pos + 1)
	{
		ps1->a[start - 1] = ps1->a[start];
		start++;
	}
	ps1->size--;
}

同样，有了这个功能之后，可以把头删和尾删修改一下：

//头删
void SLPopFront(SL* ps1)
{
   SLErase(ps1, 0);
}

//尾删
void SLPopBack(SL* ps1)
{
   SLErase(ps1, ps1->size - 1);
}

测试一下从中间删除数据的功能：

//中间删数据测试
void TestSeqList6()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushFront(&s, 5);
	SLPushFront(&s, 6);
	SLPushFront(&s, 7);
	SLPushFront(&s, 8);
	SLPushFront(&s, 9);
	SLPrint(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPopBack(&s);
	SLPrint(&s);
	SLPopFront(&s);
	SLPopFront(&s);
	SLPopFront(&s);
	SLPrint(&s);
	SLInsert(&s, 2, 30);
	SLPrint(&s);
	SLErase(&s, 3);
	SLPrint(&s);
	SLDestroy(&s);
}

查找：

//查找
//找到了返回下标，找不到返回-1
int SLFind(SL* ps1, SLDataType x)
{
	int i = 0;
	for (i = 0; i < ps1->size; i++)
	{
		if (ps1->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

修改：

//修改
void SLModify(SL* ps1, int pos, SLDataType x)
{
	assert(pos >= 0 && pos < ps1->size);
	ps1->a[pos] = x;
}

下面，浅浅附上一波源代码：

SeqList.c的内容

#include"SeqList.h"
//初始化
void SLInit(SL* ps1)
{
	assert(ps1);
	ps1->a = malloc(sizeof(SLDataType) * 4);
	if (ps1 == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps1->size = 0;
	ps1->capacity = 4;
}
//销毁
//把空间还给操作系统
void SLDestroy(SL* ps1)
{
	assert(ps1);
	free(ps1->a);
	ps1->a = NULL;
	ps1->size = 0;
	ps1->capacity = 0;
}
//打印
void SLPrint(SL* ps1)
{
	assert(ps1);
	int i = 0;
	for (i = 0; i < ps1->size; i++)
	{
		printf("%d ", ps1->a[i]);
	}
	printf("\n");
}
//检查容量，容量不够就扩容
void SLCheckCapacity(SL* ps1)
{
	assert(ps1);
	if (ps1->size == ps1->capacity)
	{
		SLDataType* tmp = (SLDataType*)realloc(ps1->a, sizeof(SLDataType) * ps1->capacity * 2);
		//扩上一个二倍大小的容量
		//这个数值可以自己设定，扩多了不好，扩少了也不好
		//所以扩上二倍是最合理的选择
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps1->a = tmp;
		ps1->capacity = ps1->capacity * 2;
	}
}
//在中间位置(pos)插入数据
void SLInsert(SL* ps1, int pos, SLDataType x)
{
	assert(ps1);
	assert(pos >= 0 && pos <= ps1->size);
	SLCheckCapacity(ps1);
	int end = ps1->size - 1;
	while (end >= pos)
	{
		ps1->a[end + 1] = ps1->a[end];
		end--;
	}
	ps1->a[pos] = x;
	ps1->size++;
}
//在中间位置(pos)删除数据
void SLErase(SL* ps1, int pos)
{
	assert(ps1);
	assert(pos >= 0 && pos < ps1->size);
	assert(ps1->size > 0);//可有可无
	int start = pos + 1;
	while (start <= pos + 1)
	{
		ps1->a[start - 1] = ps1->a[start];
		start++;
	}
	ps1->size--;
}
//尾插
void SLPushBack(SL* ps1, SLDataType x)
{
	assert(ps1);
	/*SLCheckCapacity(ps1);
	ps1->a[ps1->size] = x;
	ps1->size++;*/
	SLInsert(ps1, ps1->size, x);
}
//头插
void SLPushFront(SL* ps1, SLDataType x)
{
	assert(ps1);
	//SLCheckCapacity(ps1);
	挪动数据
	//int end = ps1->size - 1;
	//while (end >= 0)
	//{
	//	ps1->a[end + 1] = ps1->a[end];//把数据往后挪
	//	end--;
	//}
	//ps1->a[0] = x;
	//ps1->size++;
	SLInsert(ps1, 0, x);
}
//尾删
void SLPopBack(SL* ps1)
{
	assert(ps1);
	温柔的检查
	//if (ps1->size == 0)
	//{
	//	return;
	//}
	//ps1->size--;
	//暴力的检查
	/*assert(ps1->size > 0);
	ps1->size--;*/
	SLErase(ps1, ps1->size - 1);
}
//头删
void SLPopFront(SL* ps1)
{
	assert(ps1);
	//暴力检查
	assert(ps1->size > 0);
	int start = 0;
	while (start < ps1->size - 1)
	{
		ps1->a[start] = ps1->a[start + 1];
		start++;
	}
	ps1->size--;
	//SLErase(ps1, 0);
}
//查找
//找到了返回下标，找不到返回-1
int SLFind(SL* ps1, SLDataType x)
{
	assert(ps1);
	int i = 0;
	for (i = 0; i < ps1->size; i++)
	{
		if (ps1->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
//修改
void SLModify(SL* ps1, int pos, SLDataType x)
{
	assert(ps1);
	assert(pos >= 0 && pos < ps1->size);
	ps1->a[pos] = x;
}

SeqList.h的内容

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//动态顺序表
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;
	int size;//存储的有效数据的个数
	int capacity;//容量
}SL;
//初始化
void SLInit(SL* ps1);
//销毁
//把空间还给操作系统
void SLDestroy(SL* ps1);
//打印
void SLPrint(SL* ps1);
//尾插
void SLPushBack(SL* ps1,SLDataType x);
//尾删
void SLPopBack(SL* ps1);
//头插
void SLPushFront(SL* ps1, SLDataType x);
//头删
void SLPopFront(SL* ps1);
//在中间位置(pos)插入数据
void SLInsert(SL* ps1, int pos, SLDataType x);
//在中间位置(pos)删除数据
void SLErase(SL* ps1, int pos);
//查找
//找到了返回下标，找不到返回-1
int SLFind(SL* ps1, SLDataType x);
//修改
void SLModify(SL* ps1, int pos, SLDataType x);

test.c的内容

void menu()
{
	printf("***********************************************************\n");
	printf("1、尾插数据             2、尾删数据\n");
	printf("\n");
	printf("3、头插数据             4、头删数据\n");
	printf("\n");
	printf("5、在任意位置插入数据（位置3插入20）\n");
	printf("\n");
	printf("6、在任意位置删除数据              \n");
	printf("\n");
	printf("7、查找某个数据的位置，并删除它     \n");
	printf("\n");
	printf("8、删除顺序表中有的 某个数据        \n");
	printf("\n");
	printf("9、打印数据                       \n");
	printf("\n");
	printf("-1、退出                          \n");
	printf("\n");
	printf("***********************************************************\n");

}

int main()
{
	printf("*************  欢迎大家来到动态顺序表的测试  **************\n");
	int option = 0;
	SL s;
	SLInit(&s);
	do
	{
		menu();
		printf("请输入你的操作：>");
		scanf_s("%d", &option);
		int sum = 0;
		int x = 0;
		int y = 0;
		int z = 0;
		int pos = 0;
		int w = 0;
		switch (option)
		{
		case 1:
			printf("请依次输入你要尾插的数据：，以-1结束\n");
			scanf_s("%d", &sum);
			while (sum != -1)
			{
				SLPushBack(&s, sum);    // 1.尾插
				scanf_s("%d", &sum);
			}
			break;
		case 2:
			SLPopBack(&s);             // 2.尾删
			break;
		case 3:
			scanf_s("%d", &x);
			SLPushFront(&s, x);       // 3.头插
			break;
		case 4:
			SLPopFront(&s);           // 4.头删
			break;
		case 5:
			SLInsert(&s, 3, 20);     // 5.在任意位置插入数据
			break;
		case 6:
			SLErase(&s, 3);          // 6.在任意位置删除数据
			break;
		case 7:
			printf("请输入要删除序列的中的某个数字\n");
			scanf_s("%d", &z);
			y = SLFind(&s, z);        // 7.查找某个数字的位置，并且删除它
			printf("%d的位置在%d处： \n", z, y);
			if (y != -1)
			{
				SLErase(&s, y);
			}
			break;
		case 8:
			printf("请输入要删除序列的中的数字\n");  //8.删除顺序表中 所有的 某个数据 
			scanf_s("%d", &w);
			pos = SLFind(&s, w, 0);
			while (pos != -1)
			{
				SLErase(&s, pos);
				pos = SLFind(&s, w, pos);
			}
			break;
		case 9:
			SLPrint(&s);
			break;
		default:
			if (option == -1)
			{
				exit(0);  // 退出程序 
			}
			else
			{
				printf("输入错误，请重新输入\n");
			}
			break;

		}
	} while (option != -1);   // 退出程序
	SLDestroy(&s);
	return 0;
}

好啦，小雅兰今天的顺序表的更新版的内容就到这里啦，继续加油刷题和学习算法噢！！！

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

数据结构与算法

顺序表（更新版）——“数据结构与算法” 的相关文章

数据结构中常见的树（BST二叉搜索树、AVL平衡二叉树、RBT红黑树、B-树、B+树、B*树）

原文 http blog csdn net sup heaven article details 39313731 数据结构中常见的树 BST二叉搜索树 AVL平衡二叉树 RBT红黑树 B 树 B 树 B 树转载 2014年09月16日
50个c/c++源代码网站

C C 是最主要的编程语言这里列出了50名优秀网站和网页清单这些网站提供c c 源代码这份清单提供了源代码的链接以及它们的小说明我已尽力包括最佳的C C 源代码的网站这不是一个完整的清单您有建议可以联系我我将欢迎您的建议以
LeetCode83: 删除排序链表中的重复元素

给定一个已排序的链表的头 head 删除所有重复的元素使每个元素只出现一次返回已排序的链表示例 1 输入 head 1 1 2 输出 1 2 示例 2 输入 head 1 1 2 3 3 输出 1 2 3 提示链表中节点数目在范围
白盒测试相关的一些知识

在白盒测试中可以使用各种测试方法进行测试下面这篇文章可能比较枯燥如果不乐意读可以先收藏如果在你的工作中真遇到白盒测试的话可以回过头再来看看还是值得读一读一般来说白盒测试时要考虑以下5个问题 1 测试中尽量先用自动化工具来
用 Java 实现的八种常用排序算法

八种排序算法可以按照如图分类前置知识 1 算法稳定性在一个序列中能保证两个相等的数经过排序之后其在序列的前后位置顺序不变 A1 A2 排序前 A1 在 A2 前面排序后 A1 还在 A2 前面 2 时间复杂度时间复杂度是用于衡
常用的十种算法--马踏棋盘算法

1 马踏棋盘算法介绍马踏棋盘算法也被称为骑士周游问题将马随机放在国际象棋的 8 8 棋盘 Board 0 7 0 7 的某个方格中马按走棋规则马走日字进行移动要求每个方格只进入一次走遍棋盘上全部 64 个方格 2 马踏棋盘算法
SDUT--OJ《数据结构与算法》实践能力专题训练6 图论

A 数据结构实验之图论一基于邻接矩阵的广度优先搜索遍历 Description 给定一个无向连通图顶点编号从0到n 1 用广度优先搜索 BFS 遍历输出从某个顶点出发的遍历序列同一个结点的同层邻接点节点编号小的优先遍历 Input
循环单链表（C语言版）

前言小可爱们本次一起来看看循环单链表吧嘻嘻一循环单链表的定义循环单链表是单链表的另一种形式其结构特点链表中最后一个结点的指针域不再是结束标记而是指向整个链表的第一个结点从而使链表形成一个环和单链表相同循环链表也有带头结
Hash映射理解

先说数组数组优点之一能通过索引很快定位到值 hashmap 就是利用了数组这个优点对比线性映射定义一个数组数组的元素是结构体结构体包括一对键值伪代码表示 a 0 struct Bill 5 a 1 struct KK 6
数据结构与算法书籍推荐

学习数据结构与算法还是很有必要看几本相关的书籍但根据不同基础的人合适看的书也不一样因此针对不同层次不同语言的人推荐几本市面上口碑不错的书 1 入门级针对刚入门的同学建议不要急着去看那些经典书像算法导论算法这些比较经
链表面试题（一）：反转链表的算法实现

关于链表的考察链表是面试里面经常涉及到的考点因为链表的结构相比于Hashmap Hashtable Concurrenthashmap或者图等数据结构简单许多对于后者更多面试的侧重点在于其底层实现比如Hashmap中Entry
算法问题实战策略

算法问题实战策略基本信息作者韩具宗万译者崔盛一出版社人民邮电出版社ISBN 9787115384621上架时间 2015 2 4出版日期 2015 年3月开本 16开页码 738版次 1 1 内容简介算法问题实战策略本书收录
人工智能概念

人工智能概念人工智能就是用人工方法在机器计算机上实现的智能或称机器智能即是研究如何用计算机来表示和执行人类的智能活动以模拟人脑所从事的推理学习思考和规划等思维活动并解决需要人类的智力才能处理的复杂问题如医疗诊断管理决策
数据结构与算法-列表(双向链表)设计及其排序算法

0 概述本文主要涵盖列表双向链表的设计及其排序算法的总结列表是一种典型的动态存储结构其中的数据分散为一系列称作节点 node 的单位节点之间通过指针相互索引和访问为了引入新节点或删除原有节点只需在局部调整少量相关节点之间的
Leetcode1094. 拼车

Every day a Leetcode 题目来源 1094 拼车解法1 差分数组对于本题设 a i 表示车行驶到位置 i 时车上的人数我们需要判断是否所有 a i 都不超过 capacity trips i 相当于把 a 中下标从
数组实现循环队列（增设队列大小size）

目录一前言 1 如何实现循环 2 如何判断队列为空 3 如何判断队列为满二循环队列的结构定义三循环队列的创建及其初始化四入队五出队六取队头元素七取队尾元素八循环队列判空九循环队列判满十循环队列销毁一
C++ AVL树(四种旋转,插入)

C AVL树四种旋转插入一 AVL树的概念及性质二我们要实现的大致框架 1 AVL树的节点定义 2 AVL树的大致框架三插入 1 插入逻辑跟BST相同的那一部分 2 修改平衡因子
浅谈归并排序：合并 K 个升序链表的归并解法

在面试中遇到了这道题如何实现多个升序链表的合并这是 LeetCode 上的一道原题题目具体如下用归并实现合并 K 个升序链表 LeetCode 23 合并K个升序链表给你一个链表数组每个链表都已经按升序排列请你将所有链表合并到
高精度运算合集，加减乘除，快速幂，详细代码，OJ链接

文章目录零前言一加法高精度加法步骤 P1601 A B 二减法高精度减法步骤
最大流-Dinic算法，原理详解，四大优化，详细代码

文章目录零前言一概念回顾可略过 1 1流网络 1 2流 1 3最大流 1 4残留网络 1 5增广路

随机推荐

C语言——十进制转换十六进制

请编写程序 xff0c 输入十进制数 xff0c 输出对应的十六进制数输入格式十进制非负整数输出格式对应的十六进制非负整数要求 xff1a 十六进制数中的字母均为大写形式输入样哩 5050 输出样例 13BA 代码输入 xff1
如何编写头文件及使用Makefile

头文件中应该写什么 xff1a 头文件可能会被任意源文件包含 xff0c 意味着头文件中的内容可能会在多个目标文件中存在 xff0c 要保证合并时不要冲突重点 xff1a 头文件只编写声明语句 xff0c 不能有定义语句全局变量声明函
剖析Linux内存中的/proc/meminfo参数

PROC MEMINFO之谜 proc meminfo是了解Linux系统内存使用状况的主要接口 xff0c 我们最常用的 free vmstat 等命令就是通过它获取数据的 xff0c proc meminfo所包含的信息比 free 等
看完秒懂：Linux DMA mapping机制分析

说明 xff1a Kernel版本 xff1a 4 14ARM64处理器 xff0c Contex A53 xff0c 双核使用工具 xff1a Source Insight 3 5 xff0c Visio 1 概述 DMA xff08 D
linux网络编程-多进程实现TCP并发服务器

服务端流程步骤 socket函数创建监听套接字lfd bind函数将监听套接字绑定ip和端口 listen函数设置服务器为被动监听状态 xff0c 同时创建一条未完成连接队列 xff08 没走完tcp三次握手流程的连接 xff09 xff0
Linux内核中断下半部工作队列（work queue）

工作队列work queue 工作队列 xff08 work queue xff09 是中断下半部的一种实现机制 xff0c 主要用于耗时任务处理 xff0c 由内核线程代表进程执行工作队列运行于进程上下文 xff0c 因此允许阻塞运行
手把手带你部署Ceph集群

前言 xff1a Ceph作为开源的分布式文件系统 xff0c 可以轻松地将存储容量扩展到PB以上并拥有不错的性能 Ceph提供对象存储块存储和文件系统三种存储方式 xff0c 如果不想花时间安装ceph xff0c 可以通过ceph d
Linux 内核安全增强—— stack canary

一背景知识 aarch64的函数栈 1 栈生长方向与push pop操作栈是一种运算受限的线性表入栈的一端为栈顶 xff0c 另一端则为栈底其生长方向和操作顺序理论上没有限定而在aarch64平台上栈是向低地址方向增长的 STA
Linux下Makefile的简单编写与使用

Makefile 一个工程文件中的源文件可能有很多 xff0c 并且不同的功能模块等都放在不同的目录中 xff0c 常规的编译已经不能高效化的处理这样的问题 xff0c 而Makefile就是为解决这一问题而来 Makefile一旦写好
STM32 USART 串口DMA收发注意事项

正常情况这里不介绍目录 1 低波特率情况 xff0c 接收信号可能会出现干扰 2 波特率300时 xff0c DMA接收无法工作 3 波特率1200时DMA发送 4 具体现象如下环境 xff1a 主频72M STM32F103C8 注意
STM32学习笔记———几种简单传感器的数据读取

引言传感器正如计算机的眼睛从广义上讲 xff0c 传感器就是一种能感知外界信息 xff0c 并将这些信息按照一定规律转换成可用的电信号或其他形式的输出信号的装置 xff0c 达到对信息的存储 xff0c 传输 xff0c 控制的目的本
基于STM32F103C8T6的USART1串口的中断接收

一串口介绍二项目所需硬件 1 USB转串口模块三项目代码一串口介绍 USART Universal Synchronous Asynchronous Receiver Transmitter 通用同步异步串行接收发送器 U
第5讲—寄存器编程

编程方式两种 xff0c 一种是寄存器编程 xff0c 一种是函数库编程什么是寄存器 stm32芯片 61 ARM内核生产Cortex内核 43 st公司 xff08 在内核基础上 xff09 开发stm32 寄存器是用来地址操作的寄存
C语言运行HTTP代码示例

include lt iostream gt include lt algorithm gt include lt cstring gt include 34 curl curl h 34 usingnamespace std static
在Linux上实现HTTP请求

在Linux上实现HTTP请求是一种非常有用的技能 xff0c 有时候我们需要从Web服务器获取数据 xff0c 而不是使用浏览器发起网络调用 HTTP是一种常用的网络协议 xff0c 可以用于在Linux上实现HTTP请求要在Linux
Linux下设置堆栈系统参数

Linux系统下有几个与堆栈相关的系统参数 xff1a 1 ulimit s xff1a 此参数用于限制进程的堆栈大小可以使用该命令来查看和更改进程的堆栈大小限制 2 proc sys kernel stack protect xff1a
Leetcode每日一题——“消失的数字”

各位CSDN的uu们你们好呀 xff0c 今天 xff0c 小雅兰又开新专栏了 xff0c 以后会在Leetcode上面进行刷题 xff0c 尽量每天写一道 xff0c 请大家监督我 xff01 xff01 xff01 好啦 xff0c 让
Leetcode每日一题——“轮转数组”

各位CSDN的uu们你们好呀 xff0c 今天 xff0c 小雅兰的内容是轮转数组 xff0c 下面 xff0c 让我们进入轮转数组的世界吧小雅兰之前其实就已经写过了字符串旋转的问题了 xff1a C语言刷题 xff08 7 xff09
Python一行命令搭建HTTP服务器并外网访问【内网穿透】

文章目录 1 前言2 本地http服务器搭建2 1 Python的安装和设置2 2 Python服务器设置和测试 3 cpolar的安装和注册3 1 Cpolar云端设置3 2 Cpolar本地设置 4 公网访问测试5 结语转载自远程内网
顺序表（更新版）——“数据结构与算法”

各位CSDN的uu们你们好呀 xff0c 今天小雅兰又来更新新专栏啦 xff0c 其实之前我就已经写过了顺序表的内容 xff0c 只是之前的内容不是最新版的顺序表 xff0c 现在 xff0c 我来更新一下最新版的顺序表 xff0c 下面

顺序表（更新版）——“数据结构与算法”

顺序表（更新版）——“数据结构与算法” 的相关文章

随机推荐

热门标签