数据结构顺序表和链表(超详细)

2023-11-02

 线性表:

线性表 linear list n 个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使
用的数据结构,常见的线性表:顺序表、链表、栈、队列、字符串 ...
线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,
线性表在物理上存储时,通常以数组和链式结构的形式存储。

顺序表

概念及结构

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

静态顺序表:使用定长数组存储元素。

 动态顺序表:使用动态开辟的数组存储。

 如果将一开始动态开辟的内存填满,则会进行扩容,

扩容分两种情况:

原地扩容:在已开辟的动态内存后进行判断,如果后方内存大小足够扩容到新定义的大小,则在之前开辟的内存后面加上一段,以达到新定义内存大小;

异地扩容:如果在已开辟的动态内存后进行判断,后方的大小不足以扩容到新定义的大小,则会在内存中寻找一块新的足够容纳新定义大小的空间,并将之前的数据拷贝到新空间,再释放之前定义的动态内存空间;

接口实现

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

typedef int SLDateType;

typedef struct SeqList
{
    SLDateType* a;//动态开辟的数组
    int size;    //数据个数
    int capacity;//容量空间大小
}SL;


//初始化
void SLInit(SL* ps);

//释放或销毁
void SLDestroy(SL* ps);

//显示或打印
void SLPrintf(SL* ps);

//尾插
void SLPushBack(SL* ps, SLDateType x);
//尾删
void SLPopBack(SL* ps);
//头插
void SLPushFront(SL* ps, SLDateType x);
//头删
void SLPopFront(SL* ps);

//扩容
void SLCheckDestroy(SL* ps);

//顺序表查找
int SLFind(SL* ps,int n);

// 顺序表在pos位置插入x
void SLInsert(SL* ps, int pos, SLDateType x);

// 顺序表删除pos位置的值
void SLErase(SL* ps, int pos);

//顺序表修改
void SLModify(SL* ps,int pos,SLDateType x);

#define _CRT_SECURE_NO_WARNINGS 1

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


//初始化
void SLInit(SL* ps)
{
    ps->a = (SLDateType*)malloc(sizeof(SLDateType*)*4);
    if (ps->a == NULL)
    {
        perror("malloc failed");
        exit(-1);
    }
    ps->size = 0;
    ps->capacity = 4;
}


//释放或销毁
void SLDestroy(SL* ps)
{
    free(ps->a);
    ps->a = NULL;
    ps->capacity = ps->size = 0;
}


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

//扩容
void SLCheckDestroy(SL* ps)
{
    if (ps->size == ps->capacity)
    {
        SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * 2 * ps->capacity);
        if (tmp == NULL)
        {
            perror("realloc failed");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity *= 2;
    }
}


//尾插

void SLPushBack(SL* ps, SLDateType x)
{
    SLCheckDestroy(ps);

    //ps->a[ps->size] = x;
    //ps->size++;

    SLInsert(ps,ps->size,x);
}

//尾删

void SLPopBack(SL* ps)
{
    assert(ps);


    //温柔型
    //if (ps->size == 0)
    //{
    //    return;
    //}
    
    //暴力型
    //assert(ps->size > 0);

    //ps->size--;

    SLErase(ps, ps->size - 1);
}


//头插

void SLPushFront(SL* ps, SLDateType x)
{
    assert(ps);
    SLCheckDestroy(ps);


    //int i = 0;
    //for (i = 0; i < ps->size ; i++)
    //{
    //    ps->a[ps->size-i] = ps->a[ps->size - i -1];
    //}
    //ps->a[0] = x;
    //ps->size++;


    SLInsert(ps, 0, x);
}

//头删

void SLPopFront(SL* ps)
{
    //防止越界
    assert(ps->size > 0);

    //int i = 0;
    //for (i = 0; i < ps->size - 1; i++)
    //{
    //    ps->a[i] = ps->a[i+1];
    //}
    //ps->size--;

    SLErase(ps, 0);
}

//查找
int SLFind(SL* ps, int n)
{
    int i = 0;
    for (i = 0; i < ps->size; i++)
    {
        if (ps->a[i] == n)
        {
            return i;
        }
    }
    return -1;
}


// 顺序表在pos位置插入x

void SLInsert(SL* ps, int pos, SLDateType x)
{
    assert(ps);
    //=0相当于头插,=size等于尾插
    assert(pos >= 0 && pos <= ps->size);

    SLCheckDestroy(ps);

    int start = ps->size - 1 ;
    while (start >= pos)
    {
        ps->a[start + 1] = ps->a[start];
        start--;
    }
    ps->a[pos] = x;
    ps->size++;
}


// 顺序表删除pos位置的值

void SLErase(SL* ps, int pos)
{
    assert(ps);

    assert(pos >= 0 && pos < ps->size);

    int begin = pos + 1;
    while (begin < ps->size)
    {
        ps->a[begin - 1] = ps->a[begin];
        begin++;
    }
    ps->size--;
}

//顺序表修改
void SLModify(SL* ps, int pos, SLDateType x)
{
    assert(ps);
    assert(pos >= 0 && pos < ps->size);

    ps->a[pos];
}

 值得注意的是:

如果没有使用温柔型或者暴力型判断,可能会发生数组越界,但是一般情况下,编译器不会报错,因为编译器只在数组两天的特定位置放置了越界标记,需要触发才会报错,触发一般是在编译结束时到数组越界标记访问,此时越界了,但没有在此处赋值,也不会报错。

顺序表总结:

缺点:

1.头部和中部插入和删除效率不高O(n);

2.空间不足时,扩容有一定的消耗(尤其是异地扩容)如:开辟空间,拷贝,释放旧空间;

3.扩容逻辑,可能存在空间浪费(200个,但是只用110个)。

优点:

1.尾插尾删足够快;

2.下标的随机访问和修改。

链表

链表的概念及结构:

概念:链表是一种物理存储结构上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。

特点:按需申请释放

逻辑上分析链表如图:

 值得注意:

1.上图,链式结构在逻辑上是连续的,在物理上不一定是连续的;

2.现实中的结点一般是在堆上申请;

3.堆上申请的空间,可能连续,也可能不连续。 

物理上分析链表如下: 

1.单向链表的实现:

// 1 、无头 + 单向 + 非循环链表增删查改实现
typedef int SLTDateType ;
typedef struct SListNode
{
SLTDateType data ;
struct SListNode * next ;
} SListNode ;
// 动态申请一个结点
SListNode * BuySListNode ( SLTDateType x );
// 单链表打印
void SListPrint ( SListNode * plist );
// 单链表尾插
void SListPushBack ( SListNode ** pplist , SLTDateType x );
// 单链表的头插
void SListPushFront ( SListNode ** pplist , SLTDateType x );
// 单链表的尾删
void SListPopBack ( SListNode ** pplist );
// 单链表头删
void SListPopFront ( SListNode ** pplist );
// 单链表查找
SListNode * SListFind ( SListNode * plist , SLTDateType x );
// 单链表在 pos 位置之后插入 x
// 分析思考为什么不在 pos位置之前插入?
void SListInsertAfter ( SListNode * pos , SLTDateType x );
// 单链表删除 pos 位置之后的值
// 分析思考为什么不删除 pos 位置?
void SListEraseAfter ( SListNode * pos );
//销毁
void SListDestory ( SListNode** phead );

 // 动态申请一个结点

SListNode* BuySListNode(SLDataType x)
{

	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

 // 单链表打印

void SListPrint(SListNode* phead)
{
	SListNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

 特别需要注意的是

 

 

上面两张图中,图一说明改变成员,要用成员的指针,

图二说明改变成员的指针,要用成员的指针的指针(二级指针) 

// 单链表尾插

void SListPushBack(SListNode** phead, SLDataType x)
{
	assert(phead);
	SListNode* newnode = BuySListNode(x);

	if (*phead == NULL)
	{
		// 改变的结构体的指针,所以要用二级指针
		*phead = newnode;
	}
	else
	{
		SListNode* tail = *phead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		// 改变的结构体,用结构体的指针即可
		tail->next = newnode;
	}

}

// 单链表的头插

void SListPushFront(SListNode** phead, SLDataType x)
{
	assert(phead);
	SListNode* newnode = BuySListNode(x);
	newnode->next = *phead;
	*phead = newnode;
}

// 单链表的尾删

void SListPopBack(SListNode** phead)
{
	assert(phead);
	//0个
	assert(*phead);

	//1个或以上
	if ((*phead)->next == NULL)
	{
		free(*phead);
		*phead = NULL;
	}
	else
	{
		SListNode* tail = *phead;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
		
	}
}

// 单链表头删

void SListPopFront(SListNode** phead)
{
	assert(phead);
	assert(*phead);
	
	SListNode* newnode = (*phead)->next;
	free(*phead);
	*phead = newnode;
}

//查找

SListNode* SListFind(SListNode* phead, SLDataType x)
{
	SListNode* newnode = phead;
	while (newnode)
	{
		if (newnode->data == x)
		{
			return newnode;
		}
		
			newnode = newnode->next;
		
	}
	return NULL;
}

//在pos之后插入x 

void SListInsertAfter(SListNode* pos, SLDataType x)
{
	assert(pos);

	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
	

}

//在pos之前插x

void SLTInsert(SListNode** phead, SListNode* pos, SLDataType x)
{
	assert(pos);
	//方法一
	if (pos == *phead)
	{
		SListPushFront(phead, x);
	}
	else
	{
		SListNode* tail = *phead;
		while (tail->next != pos)
		{
			tail = tail->next;
		}
		SListNode* newnode = BuySListNode(x);
		tail->next = newnode;
		newnode->next = pos;
	}
	
	//方法二
	//SListNode* tail = *phead;
	//while (newnode->next == NULL)
	//{ 
	//	if (*phead == pos)
	//	{
	//		newnode->next = tail;
	//		*phead = newnode;
	//	}
	//	if (tail->next == pos)
	//	{
	//		newnode->next = tail->next;
	//		tail->next = newnode;
	//	}
	//	else
	//	{
	//		tail = tail->next;
	//	}

	//}
}

// 删除pos位置

void SLTErase(SListNode** phead, SListNode* pos)
{
	assert(phead);
	assert(pos);
	SListNode* tail = *phead;
	if (*phead == pos)
	{
		SListPopFront(phead);
		//*phead = pos->next;
		//return;
	}
	while (tail->next != pos->next)
	{
		if (tail->next == pos)
		{
			tail->next = tail->next->next;
		}
		else
		{
			tail = tail->next;
		}
	}
	free(pos);
	//pos = NULL;//形参不改变实参,在调用外面置空
}

// 删除pos的后一个位置

void SLTEraseAfter(SListNode* pos)
{
	assert(pos);
	assert(pos->next);//如果pos没有下一个,报错

	
	SListNode* postNext = pos->next;
	pos->next = pos->next->next;
	free(postNext);
	postNext = NULL;
}

//销毁 

void SListDestory(SListNode** phead)
{
	assert(phead);

	SListNode* cur = *phead;
	while (cur)
	{
		SListNode* node = cur->next;
		free(cur);
		cur = node;
	}

	*phead = NULL;
}

 替换发删除:

下一个节点的值给pos,然后删除pos->next的节点。

2.双向链表的实现:

// 2 、带头 + 双向 + 循环链表增删查改实现
typedef int LTDataType ;
typedef struct ListNode
{
LTDataType _data ;
struct ListNode * next ;
struct ListNode * prev ;
} ListNode ;
// 创建返回链表的头结点 .
ListNode * ListCreate ();
// 双向链表销毁
void ListDestory ( ListNode * plist );
// 双向链表打印
void ListPrint ( ListNode * plist );
// 双向链表尾插
void ListPushBack ( ListNode * plist , LTDataType x );
// 双向链表尾删
void ListPopBack ( ListNode * plist );
// 双向链表头插
void ListPushFront ( ListNode * plist , LTDataType x );
// 双向链表头删
void ListPopFront ( ListNode * plist );
// 双向链表查找
ListNode * ListFind ( ListNode * plist , LTDataType x );
// 双向链表在 pos 的前面进行插入
void ListInsert ( ListNode * pos , LTDataType x );
// 双向链表删除 pos 位置的结点
void ListErase ( ListNode * pos );

 // 创建返回链表的头结点

ListNode* BuyLTNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->data = x;
	node->next = NULL;
	node->prev = NULL;

	return node;
}


// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* head = BuyLTNode(0);
	head->next = head;
	head->prev = head;
	return head;
}

// 双向链表打印

// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* node = pHead->next;
	while (node != pHead)
	{
		printf("%d->",node->data);
		node = node->next;
	}
	printf("NULL\n");
}

// 双向链表在pos的前面进行插入

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = BuyLTNode(x);
	ListNode* oldnode = pos->prev;
	newnode->prev = oldnode;
	oldnode->next = newnode;
	newnode->next = pos;
	pos->prev = newnode;

}

// 双向链表删除pos位置的节点

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* oldnode = pos->prev;
	oldnode->next = pos->next;
	pos->next->prev = oldnode;
	free(pos);
}

// 双向链表尾插

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListInsert(pHead,x);
}

// 双向链表头插

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListInsert(pHead->next,x);
}

// 双向链表尾删

// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	//
	assert(pHead->next != pHead);
	ListErase(pHead->prev);
}

// 双向链表头删

// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	//
	assert(pHead->next != pHead);
	ListErase(pHead->next);
}

// 双向链表查找

// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* node = pHead->next;
	while(node != pHead)
	{
		if (node->data == x)
		{
			return node;
		}
		node = node->next;
	}
	return NULL;
}

// 双向链表销毁

// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* oldnode = pHead->next;
	while (oldnode != pHead)
	{
		ListNode* oldnode1 = oldnode->next;
		free(oldnode);
		oldnode = oldnode1;
	}
	free(pHead);
	printf("销毁完成!\n");
}

链表和顺序表的区别: 

缓存利用率:

 以上就是个人学习线性表的个人见解和学习的解析,欢迎各位大佬在评论区探讨!

感谢大佬们的一键三连! 感谢大佬们的一键三连! 感谢大佬们的一键三连! 

                                             

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

数据结构顺序表和链表(超详细) 的相关文章

  • 如果没有抽象成员,基类是否应该标记为抽象?

    如果一个类没有抽象成员 可以将其标记为抽象吗 即使没有实际理由直接实例化它 除了单元测试 是的 将不应该实例化的基类显式标记为抽象是合理且有益的 即使在没有抽象方法的情况下也是如此 它强制执行通用准则来使非叶类抽象 它阻止其他程序员创建该类
  • System.IO.FileNotFoundException:找不到网络路径。在 Windows 7 上使用 DirectoryEntry 对象时出现异常

    我正在尝试使用 DirectoryEntry 对象连接到远程 Windows 7 计算机 这是我的代码 DirectoryEntry obDirEntry new DirectoryEntry WinNT hostName hostName
  • 如何将嵌套组框中的单选按钮设置为与该组框外部的单选按钮相同的组[重复]

    这个问题在这里已经有答案了 我有 winform 应用程序 NET 4 0 有没有办法手动设置一组单选按钮 我有四个单选按钮 其中两个位于组框内 另外两个位于该框外 如何将它们全部设置为同一组 这可能已经在另一篇文章中得到了回答 听起来是一
  • 运行 Azure 函数时路径中存在非法字符

    我有一个 Azure 函数 它已经运行了一整天 大约二十分钟前 当我尝试单击 Visual Studio 中的运行按钮时 开始出现错误 它成功构建 然后在启动时显示并错误 仅指出 路径中的非法字符 Visual Studio 我检查了 gi
  • 将海量列表传递给 MVC3 中的 View

    ASP NET MVC 新手 现在使用 MVC3 和 Razor 我对将对象从控制器传递到视图感到困惑 具体来说 我正在尝试 MVC3 和 Rob Conery 有趣的 Massive http blog wekeroad com help
  • 使用加密c#导出PKCS8中的CngKey

    如何将 CngKey 导出到 PKCS 8 并加密 static void Main string args CngKeyCreationParameters ckcParams new CngKeyCreationParameters E
  • RigidBody2D 冻结 X 位置

    我想知道是否有一种方法可以使用 Unity 的 RigidBody2D 来模拟以下代码行 而不是使用普通的 RigidBody rigidbody constraints RigidbodyConstraints FreezePositio
  • 不使用 C# 解析器获取字段的行号

    我想获取类型字段的行 s 要获取方法中语句的第 行 非常简单 Type type typeof MyClass MethodInfo methodInfo type GetMethod SomeMethod int token method
  • Swagger 不生成 swagger.json

    我在一个解决方案中拥有 asp net core MVC 项目和单独的 WebApi 项目 我按照 github 上的文档添加了 swagger 这是我的 mvc 项目的 Startup cs public void ConfigureSe
  • 为什么 C# 中 Encoding.ASCII != ASCIIEncoding.Default ?

    为什么 C 中 Encoding ASCII ASCIIEncoding Default 这是因为ASCIIEncoding源自于Encoding where Default定义为
  • 忽略正则表达式匹配的空格

    我需要匹配 8 个或更多数字 其序列可以包含空格 例如 以下所有内容都是有效匹配 12345678 1 2345678 12 3 45678 1234 5678 12 34567 8 1 2 3 4 5 6 7 8 此刻我有 d 8 但这只
  • 如何使用 Git 子模块和 CMake 处理传递依赖冲突?

    我们有许多 Git 存储库 有些包含我们自己的代码 有些包含稍作修改的第三方库代码 简化的依赖图如下所示 executable A v library B v v library C 所以可执行文件有两个依赖项library C 一种是直接
  • 将 Blend 行为添加到 DatePicker 时出现问题

    我正在尝试向 DatePicker 控件添加 Blend 行为 以将 MVVM Light RelayCommand 绑定到 DateChanged 事件 如下所示
  • minidump stackwalk 与 gdb 回溯

    我的 Firefox 中有一个漏洞触发器 CVE 2018 18492 它会崩溃并给出 SIGSEGV 我用过breakpadminidump stackwalk从崩溃时生成的小型转储文件中获取其堆栈跟踪 我得到如下内容 Thread 0
  • 如何确保我们读取 boost::child 进程中的所有行

    我在上面看到了下面的代码boost child文档页面 其中解释了如何读取子进程的输出 http www boost org doc libs 1 64 0 doc html boost process tutorial html http
  • 如何将位写入文件?

    如何使用 c net 将位 而不是字节 写入文件 我很坚持它 Edit 我正在寻找一种不同的方法 将每 8 位写为一个字节 一次可以写入的最小数据量是一个字节 如果您需要写入单独的位值 例如 二进制格式需要 1 位标志 3 位整数和 4 位
  • _bstr_t 内存泄漏

    我有一个 C 代码 但它没有正确释放内存 告诉我哪里错了 这是我的代码 1 void MyClass MyFunction void 2 3 for int i 0 i
  • OpenCV RGB转灰度

    我正在做一个视频监控项目 我看不到从 RGB 到灰度的转换 我为灰色设置了黑色窗口 你能帮我解决这个问题吗 附代码 另外 如何获得当前帧和前一帧之间的差异 多谢 宜兰 include stdafx h include
  • 在运行时检查 GCC 版本

    我需要找出 C 程序执行过程中 运行时 可用的 系统中安装的 GCC 版本 主要版本和次要版本 意思是 以编程方式提取可用 gcc 的版本 就像我在 shell 中输入 gcc version 一样 但在 c 程序中 The GNUC an
  • 游戏网络射弹实施/概念问题[关闭]

    Closed 这个问题是无关 help closed questions 目前不接受答案 我正在尝试找到某种解决方案来解决同步射弹射击和游戏网络的常见问题 但我不确定什么是最合适的 这是一款 2D 动作横向卷轴游戏 带有多个射弹 没有即时攻

随机推荐

  • 低功耗蓝牙MESH基础知识

    一 MESH VS 点对点 大多数蓝牙低功耗设备使用一对一简单点对点网络拓扑结构来进行相互间的通信 在蓝牙核心规格中 这称为 微微网 想象一下 智能手机已经建立了与心率监测仪的点对点连接 并可借此传输数据 同样的智能手机也可以建立与其他设备
  • gettimeofday 获取毫秒时间溢出问题

    之前为了测试C中代码执行消耗的时间 所以写了这么一个函数 long long getmstime timeval tv gettimeofday tv NULL return tv tv sec 1000 tv tv usec 1000 之
  • 使用Hutool向第三方的接口发起请求

    使用Hutool工具请求第三方接口遇到的一篮子问题 1 请求第三方接口的几种方式 1 1 使用HttpUtil请求 返回String类型的JSON串 一般用在请求普通的页面情况下 返回的结果是JSON格式 但是如果出现了404 504错误
  • newInstance过时

    在今天使用反射的newInstance 时候发现 jdk9版本将class newInstance 过时 Class stack1 Class forName Stack Stack stack2 Stack stack1 getConst
  • leetcode 300. Longest Increasing Subsequence

    leetcode 300 Longest Increasing Subsequence 题目 Given an unsorted array of integers find the length of longest increasing
  • PHP中小型民宿酒店管理系统源码

    PHP中小型民宿酒店管理系统源码 近年来 民宿酒店行业以其独特的住宿体验和个性化服务受到越来越多旅行者的青睐 为了提高运营效率 改善客户体验 许多中小型民宿酒店开始引入管理系统 本文将介绍一款基于PHP开发的中小型民宿酒店管理系统源码 帮助
  • Axure动态布局,中部加入滚动条

    1 将部件设置为动态面板 然后再部件属性和样式中使用按需显示纵向滚动条 2 可以很好的处理因为内部页面过大挤占低端内容的问题
  • 解决Excel打开CSV文件中文乱码问题

    CSV打开乱码的处理方法 方法一 Excel的数据导入功能 方法二 CSV打开乱码的处理方法 CSV是用UTF 8编码的 而EXCEL是ANSI编码 由于编码方式不一致导致出现乱码 明白了原因之后 我们只需要把CSV文件的编码方式修改成与E
  • 第5章 数组 第3题

    题目 编写一个程序 输入一个字符串 输出其中每个字符在字母表中的序号 对于不是英文字母的字符 输出0 例如 输入为 acbf8g 输出为1 3 2 6 0 7 代码 include
  • 基础练习—矩阵乘法

    题目描述 给定一个N阶矩阵A 输出A的M次幂 M是非负整数 例如 A 1 2 3 4 A的2次幂 7 10 15 22 输入 第一行是一个正整数N M 1 lt N lt 30 0 lt M lt 5 表示矩阵A的阶数和要求的幂数 接下来N
  • excel或txt格式坐标到面图层(python)

    背景 现有如下图所示的多个界址点坐标 excel格式或txt格式 需求 根据大量界址点坐标转换为界址点坐标对应的面shp图层 解决思路 一 为方便处理首先将txt文件或excel文件转换为csv文件 逗号分割符 二 为方便理解和使用 我们将
  • python numpy的学习

    0 引入numpy import numpy as np 1 将list变成np a 1 2 3 4 5 6 b np array a 将list变成array a shape 2 3 2行3列 a shape 0 2 获取行数 a sha
  • 攻防世界之WEB新手练习区(更新至11)

    攻防世界之WEB新手练习区 目录 001 view source 002 get post 003robots 004backup 005cookie 006disable button 007simple js 008xff refere
  • FTDI FT2232H在嵌入式教学中的应用

    FT2232H是FTDI chip在2012年发布的一款高速USB转串行通信的协议转换芯片 作为第五代USB协议转串行总线通信协议的芯片 完全符合USB2 0规范 480Mb s 并且可以依靠编程的方式配置成为串行或者并行的其他总线接口规范
  • Pycharm无法正常安装第三方库的时候,有以下几条应对方法

    1 首先检查自己的环境变量是否配置正确 点击setting 点击 Python Interpreter 点击Add Interpreter 配置完毕之后再试一次从这里下载 如果还不行的话可以换其他方法 2 从cmd或Pycharm Term
  • 什么是EL表达式

    EL表达式 expression language 即表达语言 它是为了便于存取数据而定义的一种语言 JSP2 0之后才成为一种标准 形式 以 开头 以 结尾 通过PAGE指令来说明是否支持EL表达式 具体举例 声明可以使用EL表达式 如果
  • 【腾讯云 TDSQL-C Serverless 产品测评】全面测评TDSQL-C Mysql Serverless

    全面测评TDSQL C Mysql Serverless 文章目录 全面测评TDSQL C Mysql Serverless 前言 什么是TDSQL C Mysql Serverless 初始化 TDSQL C Mysql Serverle
  • 前车之覆,后车之鉴——开源项目经验谈

    前车之覆 后车之鉴 开源项目经验谈 本文发表于 程序员 2005年第2期 随着开源文化的日益普及 参与开源 似乎也变成了一种时尚 一时间 似乎大家都乐于把自己的代码拿出来分享了 就在新年前夕 我的一位老朋友 一位向来对开源嗤之以鼻的J2EE
  • 毕设 ssd tf_gpu2 predict.py 备份代码

    如图 代码所属 https github com bubbliiiing ssd tf2 怕到时候改坏了 unbelievable 不是 import time import cv2 import numpy as np import te
  • 数据结构顺序表和链表(超详细)

    线性表 线性表 linear list 是 n 个具有相同特性的数据元素的有限序列 线性表是一种在实际中广泛使 用的数据结构 常见的线性表 顺序表 链表 栈 队列 字符串 线性表在逻辑上是线性结构 也就说是连续的一条直线 但是在物理结构上并