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

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(使用前将#替换为@)

数据结构与算法

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

以OpenGL/ES视角介绍gfx-hal(Vulkan) Shader/Program接口使用

文档列表见 Rust 移动端跨平台复杂图形渲染项目开发系列总结目录背景 The right way to tackle this in Vulkan is to use resource descriptors A descriptor
数据结构中常见的树（BST二叉搜索树、AVL平衡二叉树、RBT红黑树、B-树、B+树、B*树）

原文 http blog csdn net sup heaven article details 39313731 数据结构中常见的树 BST二叉搜索树 AVL平衡二叉树 RBT红黑树 B 树 B 树 B 树转载 2014年09月16日
netty handler的执行顺序（3）

2019独角兽企业重金招聘Python工程师标准 gt gt gt 今天解决2个问题 1 handler在pipeline当中究竟是如何存储的 2 在遍历handler的过程中会根据event的不同调用不同的handler 这一点是如何
4399 C++笔试题

1 写出一个函数取到链表中倒数第二个节点双链表 node getSec List mylist return mylist m tail gt m prev m prev为链表前指针单链表 node getSec List mylis
findBug 错误修改指南

FindBugs错误修改指南 1 EC UNRELATED TYPES Bug Call to equals comparing different types Pattern id EC UNRELATED TYPES type EC c
JavaScript实现数据结构 -- 链表

文章目录链表链表的特点链表和数组的区别 JS模拟链表遍历链表插入节点删除节点链表应用删除链表中的节点 leetcode 237 思路代码反转链表 leetcode 206 思路代码链表链表和数组一样是有多个元素组成
逆波兰表达式求值（C语言实现）

实验项目从文本文件输入任意一个语法正确的中缀表达式显示并保存该表达式利用栈结构把上述中缀表达式转换成后缀表达式并显示栈的状态变化过程和所得到的后缀表达式利用栈结构对上述后缀表达式进行求值并显示栈的状态变化过程和最终结
SDUT--OJ《数据结构与算法》实践能力专题训练6 图论

A 数据结构实验之图论一基于邻接矩阵的广度优先搜索遍历 Description 给定一个无向连通图顶点编号从0到n 1 用广度优先搜索 BFS 遍历输出从某个顶点出发的遍历序列同一个结点的同层邻接点节点编号小的优先遍历 Input
亚利桑那州立大学周纵苇：研习 U-Net ——现有的分割网络创新

雷锋网AI研习社按经典的 Encoder Decoder 结构在目标分割问题中展现出了举足轻重的作用然而这样一个相对固定的框架使得模型在感受野大小和边界分割精度两方面很难达到兼顾本次公开课讲者以 U Net 为案例分析总结现有的分
UE4命令行使用，解释

命令行在外部从命令行运行编辑项目 1 导航到您的 LauncherInstall VersionNumber Engine Binaries Win64 目录中 2 右键单击上 UE4Editor exe 的可执行文件并选择创建快捷方式
图 - Java实现无向带权图的邻接矩阵表示法

图 Java实现无向带权图的邻接矩阵表示法 1 图 1 1 图的介绍图 Graph 是一种复杂的非线性表结构图中的元素我们就叫做顶点 vertex 图中的一个顶点可以与任意其他顶点建立连接关系我们把这种建立的关系叫做边 edge 跟顶
数据结构——计算节点个数和二叉树高度（C语言版）

摘自数据结构计算节点个数和二叉树高度 C语言版作者正弦定理发布时间 2020 12 12 23 27 09 网址 https blog csdn net chinesekobe article details 111086664
堆栈01--用两个栈实现队列

堆栈01 用两个栈实现队列 jz05 题目概述解析参考答案注意事项说明题目概述算法说明用两个栈来实现一个队列完成队列的Push和Pop操作队列中的元素为int类型测试用例队列先进先出输入 1 2 输出 1 2 解析
数据结构与算法-列表(双向链表)设计及其排序算法

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

Linux 内核中的 Device Mapper 机制尹洋在读博士生尹洋中科院计算所国家高性能计算机工程技术研究中心的在读博士生主要从事服务部署和存储资源管理以及Linux块设备一级的开发和研究工作简介本文结合具体代码对 L
时间复杂度+常见复杂度解释

前言算法的效率虽然计算机能快速的完成运算处理但实际上它也需要根据输入数据的大小和算法效率来消耗一定的处理器资源要想编写出能高效运行的程序我们就需要考虑到算法的效率算法的效率主要由以下两个复杂度来评估时间复杂度评估执行程序所
基数排序代码实现

详情请看排序总结传送门 https blog csdn net m0 52711790 article details 121914543 基数排序的知识点我就不贴出来相信都能搜到对应概念解释下面就直接上代码代码解释其实也很清晰了
Leetcode2661. 找出叠涂元素

Every day a Leetcode 题目来源 2661 找出叠涂元素解法1 哈希题目很绕理解题意后就很简单由于矩阵 mat 中每一个元素都不同并且都在数组 arr 中所以首先我们用一个哈希表 hash 来存储 mat 中每
【数据结构】单链表的定义和操作

目录 1 单链表的定义 2 单链表的创建和初始化 3 单链表的插入节点操作 4 单链表的删除节点操作 5 单链表的查找节点操作 6 单链表的更新节点操作 7 完整代码嗨我是 Filotimo 很高兴与大家相识希望我的博客能对你有所帮助
浅谈归并排序：合并 K 个升序链表的归并解法

在面试中遇到了这道题如何实现多个升序链表的合并这是 LeetCode 上的一道原题题目具体如下用归并实现合并 K 个升序链表 LeetCode 23 合并K个升序链表给你一个链表数组每个链表都已经按升序排列请你将所有链表合并到

随机推荐

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 下面

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

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

随机推荐

热门标签