简单之数组链

最新推荐文章于 2022-03-01 09:38:34 发布
最新推荐文章于 2022-03-01 09:38:34 发布
阅读量424 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liuqian134/article/details/37577373 

#pragma once


#pragma pack(1)


//注意此结构使用之前必须初始化为0
typedef struct _list_data {
char * sHeader;      //必须保留的，这里是表的头指针，指向第一个字符串地址
char * sBacker;
char * sLowest;
char * szListStr;    //必须保留的，这里是整个表内存，注意请勿再改变，初始化必须为0
unsigned int mSize;  //最大字串大小，这里指增加的字符串，注意这里的值一但设置请勿再改变，如同连表固定的值大小,要改变请先关闭表，再重建表
unsigned int nSize;  //必须保留的，这里保存实际有多少个字符串在整个表内
unsigned int tSize;  //必须保留的，这里保存整个表内实际有多少个字节的数据
unsigned int rSize;
} _MemData,*_lpMemData;


#pragma pack()




void __cdecl _minit(_MemData& _mData,size_t _nLen,size_t _uMaxCou); //初始化结构


void __cdecl _mclist(_MemData& _mData,const char * _iString,size_t _uMaxCou); //创建与添加表或表数据


void __cdecl _mrlist(const _MemData& _mData,unsigned int _uIndex,char * _rString); //读取表数据


void __cdecl _mwlist(_MemData& _mData,const char * _rString,unsigned int _uIndex); //修改某项的数据


void __cdecl _mflist(const _MemData& _mData,const char * _fString,unsigned int _iIndex,unsigned int * _oIndex); //快速查找指定的数据


void __cdecl _mslist(_MemData& _mData,const char * _sString,const char * _dString,unsigned int _iIndex,unsigned int * _oIndex); //查找数据并替换


void __fastcall _mdlist(_MemData& _mData,unsigned int _uIndex); //删除指定的数据


void __fastcall _melist(_MemData& _mData); //关闭数据表








#include "stdafx.h"
#include "mlist.h"
#include "almem.h"
#include "memgr.h"




void __cdecl _minit(_MemData& _mData,size_t _nLen,size_t _uMaxCou)
{
if ( &_mData != NULL ) {
_mem_init(_nLen,_uMaxCou);
_memset(&_mData,0,sizeof(_MemData));
_mData.mSize = _nLen;
}
}


void __cdecl _mclist(_MemData& _mData,const char * _iString,size_t _uMaxCou)
{
if (&_mData != NULL && _iString != NULL)
{
if (NULL == _mData.sLowest)
{
_mData.rSize = _uMaxCou;
_mData.szListStr = (char *)_mem_alloc(_mData.mSize * _mData.rSize);


if (_mData.szListStr != NULL)
{
_mData.nSize++;
_mData.tSize += _mData.mSize;
_mData.sHeader = _mData.szListStr; 
_mData.sLowest = _mData.sHeader + (_mData.rSize * _mData.mSize);
_memcpy(_mData.sHeader,_iString,_mData.mSize);
_mData.sBacker = _mData.sHeader + _mData.mSize;
}
}
else if (_mData.sLowest == _mData.sBacker)
{
_mData.rSize += _uMaxCou;
_mData.szListStr = (char *)_mem_alloc(_mData.mSize * _mData.rSize);


if (_mData.szListStr != NULL)
{
_memcpy(_mData.szListStr,_mData.sHeader,_mData.tSize);
_mData.sBacker = _mData.szListStr + _mData.tSize;
_memcpy(_mData.sBacker,_iString,_mData.mSize);
_mData.sBacker += _mData.mSize;
_mData.nSize++;
_mData.tSize += _mData.mSize;
_mem_free(_mData.sHeader);
_mData.sHeader = _mData.szListStr; 
_mData.sLowest = _mData.sHeader + (_mData.rSize * _mData.mSize);
}
}
else
{
_mData.nSize++;
_mData.tSize += _mData.mSize;
_memcpy(_mData.sBacker,_iString,_mData.mSize);
_mData.sBacker += _mData.mSize;
}
}
}


void __cdecl _mrlist(const _MemData& _mData,unsigned int _uIndex,char * _rString)
{
if( &_mData != NULL && _mData.sHeader != NULL && _uIndex < _mData.nSize ) {
_memcpy(_rString,_mData.sHeader + (_mData.mSize * _uIndex),_mData.mSize);
}
}


void __cdecl _mwlist(_MemData& _mData,const char * _rString,unsigned int _uIndex)
{
if( &_mData != NULL && _mData.sHeader != NULL && _uIndex < _mData.nSize)
{
_mData.szListStr = _mData.sHeader + (_mData.mSize * _uIndex);
_memcpy(_mData.szListStr,_rString,_mData.mSize);
}
}


void __cdecl _mflist(const _MemData& _mData,const char * _fString,unsigned int _iIndex,unsigned int * _oIndex)
{
if ( &_mData != NULL && _mData.sHeader != NULL && _fString != NULL && _iIndex < _mData.nSize )
{
register unsigned int _z = _iIndex;
register unsigned int _x = _z + (((_mData.nSize - _z) / 3U)  + ((_mData.nSize - _z) % 3U)) - 1U;
register unsigned int _y = _x * 2U;


for( ; _y < _mData.nSize; ++_z,++_x,++_y)
{
if( true == _memcmp(_fString,_mData.sHeader + (_mData.mSize * _z),_mData.mSize) )
{
*_oIndex = _z;
return;
}


if( true == _memcmp(_fString,_mData.sHeader + (_mData.mSize * _x),_mData.mSize) )
{
*_oIndex = _x;
return;
}


if( true == _memcmp(_fString,_mData.sHeader + (_mData.mSize * _y),_mData.mSize) )
{
*_oIndex = _y;
return;
}
}
}
*_oIndex = 0x0FFFFFFFF;
}


void __cdecl _mslist(_MemData& _mData,const char * _sString,const char * _dString,unsigned int _iIndex,unsigned int * _oIndex)
{
if( &_mData != NULL && _mData.sHeader != NULL && NULL == _dString )
{
register unsigned int _uIndex;


_mflist(_mData,_sString,_iIndex,&_uIndex);


if( _uIndex != 0x0FFFFFFFF  )
{
*_oIndex = _uIndex;
return;
}
} else if ( &_mData != NULL && _mData.sHeader != NULL && _sString != NULL && _dString != NULL ) 
{
register unsigned int _uIndex;


_mflist(_mData,_sString,_iIndex,&_uIndex);


if( _uIndex != 0x0FFFFFFFF )
{
_mData.szListStr = (char *)_mData.sHeader + (_mData.mSize * _uIndex);
_memcpy(_mData.szListStr,_dString,_mData.mSize);
*_oIndex = _uIndex;
return;
}
}
*_oIndex = 0x0FFFFFFFF;
}


void __fastcall _mdlist(_MemData& _mData,unsigned int _uIndex)
{
if( &_mData != NULL && _mData.sHeader != NULL && _uIndex < _mData.nSize )
{
const unsigned int xSize = _mData.mSize * _uIndex;


_mData.nSize--;
_mData.tSize -= _mData.mSize;
_mData.sBacker -= _mData.mSize;
_mData.szListStr = _mData.sHeader;
_memcpy((_mData.szListStr + xSize),(_mData.sHeader + (xSize + _mData.mSize)),((_mData.nSize - _uIndex) * _mData.mSize));
_memset((_mData.sLowest - _mData.mSize),0,_mData.mSize);
}
}


void __fastcall _melist(_MemData& _mData)
{
if (&_mData != NULL)
_memset(&_mData,0,sizeof(_MemData));
return _mem_dele();
}








int _tmain(int argc, _TCHAR* argv[])
{
char rStr[16] = {0};
char strIn[] = "操作成功！";
char strFind[] = "查找成功！";


unsigned int uIndex = 0U;


_MemData _mdata = {0U};


vector<string> str_vector;


string str = "abcdefghijklmnopqrstuvwxyz0123456789";


int size = 102;


_minit(_mdata,16U,(size * 4U));


clock_t s = clock();


//生成长度大小为6-16之间的随机且不重复字串
for( int i = 0; i < size; i++ )
{
int x = rand() % 16U;


while (x < 6) {
x = rand() % 16U;
}


random_shuffle( str.begin(), str.end() ); 


str_vector.push_back( str.substr( 0,x) );
}


vector<string>::iterator it = unique( str_vector.begin(), str_vector.end() );


str_vector.resize( it - str_vector.begin() );


str_vector.resize( size );


clock_t d = clock();


printf("生成随机字符串 time: %d\r\n",d-s);


s = clock();


for ( register unsigned int i = 0U; i < str_vector.size(); i++ )
_mclist(_mdata,str_vector[ i ].c_str(),101U);


_mwlist(_mdata,strIn,81U); //修改某项数据


//for(register unsigned int i = 0U; i < _mdata.nSize; ++i)
//{
// _mrlist(_mdata,i,rStr);
// printf("%s\r\n",rStr);
//}


d = clock();


printf("插入字符串 time: %d\r\n",d-s);
system("pause.");


s = clock();


_mflist(_mdata,strIn,0U,&uIndex); //查找字符串 uIndex == 0xFFFFFFFF 表明没有找到


printf("%s->%u\r\n",strIn,uIndex);


system("pause.");


_mwlist(_mdata,"修改成功！",uIndex); //修改查找到的数据


for(register unsigned int i = 0U; i < _mdata.nSize; ++i)
{
_mrlist(_mdata,i,rStr);
printf("%s\r\n",rStr);
}


d = clock();


printf("time: %d\r\n",d-s);
system("pause.");


_mdlist(_mdata,uIndex); //删除指定的数据


for(register unsigned int i = 0; i < _mdata.nSize; ++i)
{
_mrlist(_mdata,i,rStr);
printf("%s\r\n",rStr);
}


system("pause.");


_mwlist(_mdata,strFind,92U);
_mslist(_mdata,strFind,NULL,0U,&uIndex); //fNum == 0xFFFFFFFF 表明没有找到
printf("%u\r\n",uIndex);


system("pause.");


for(register unsigned int i = 0U; i < _mdata.nSize; ++i) //查找指定的所有相同的数据，并全部替换
{
_mslist(_mdata,strFind,strIn,i,&uIndex);


if( uIndex == 0x0FFFFFFFF )
break;
}


for(register unsigned int i = 0; i < _mdata.nSize; ++i)
{
_mrlist(_mdata,i,rStr);
printf("%s\r\n",rStr);
}


for(register unsigned int i = 0U; i < _mdata.nSize; ++i)
{
_mrlist(_mdata,i,rStr);


if (i == uIndex)
printf("%s\r\n",rStr);
}


system("pause.");


printf("字节总大小：%d 字符串成员个数：%d 成员字符固定大小：%d\n",_mdata.tSize,_mdata.nSize,_mdata.mSize);
_melist(_mdata); //关闭数据表
system("pause.");
return 0;
}


liuqian134
关注
1.6编程基础之一维数组(10题)--题目 有链接.pdf
06-09
这个题目是一个简单的数学和逻辑问题。通过读取苹果树上每个苹果的高度以及陶陶能够伸手够到的最大高度，我们可以确定陶陶能够摘到的苹果数量。这个过程涉及到数组的遍历和基本的数学运算。读取到高度数据后，程序...
js数组相减简单示例【删除a数组所有与b数组相同元素】
10-15
其核心思想是，遍历数组b中的每一个元素，再分别在数组a中查找是否有与之相同的元素，如果找到，则将这个元素从数组a中删除。这个过程需要特别注意的是，每次从数组a中删除一个元素后，其后面的元素会向前移动，因此...
数组链表
出尘的博客
04-06 124
链表太麻烦了 acm一般用数组，简化链表 静态链表 int p[N],a[N];//p指针，a数据 for(i=1;i<n;i++)p[i]=i+1;p[n]=1;//初始化 p[i]=p[p[i]];//删去p[i] 还有报数的一些注意： 1,删掉的哪一个，就在前面一个停，为i，删p[i] 2,刚开始时是i=n，则p[i]=1，算一次就是算1号，这才正确 ...
数组和链表
naumy的博客
05-26 483
数组和链表 1.链表 1.1链表是什么 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分： 一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多， 但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺
数组总结以及数组链表
weixin_43541094的博客
08-11 152
a
用数组简单模拟串行进位链
oliveevilo的专栏
01-06 806
#include using namespace std; int * array_carry_chain(int * a,int * b,int n); int main() { int a [10] = {0,0,0,0,1,1,1,0,0,1}; int b [10] = {0,1,0,0,0,0,1,0,1,1}; //1001000100 int * c = ar
数组 链表
lxp199741的博客
08-11 839
数组： 结构在通过索引进行查询数据是效率比较高，而对于数组插入和删除操作则效率比较低，在第一个位置进行插入数据时，其它数据就需要依次后移，而删除一个数据，则该数据后的数据全部前移。 链表： 为了保证数据插入和删除不会影响其它数据的移动，保证线性开销，所以引出了链表。每个值都不会连续进行存储。链表是由一系列节点组成，每一个节点都有一个链点，就是next链。而next链则会执行下一个node引用...
kayer.rar_java 数组链接
09-24
这个过程可能涉及到遍历数组、计算元素之和以及创建新的结果数组。对于初学者来说，这是一个基础但重要的概念，有助于理解数据结构和基本算法。 在Java中，数组的链接通常通过以下几种方式实现： 1. 使用循环：遍历...
thinkPHP简单遍历数组方法分析
12-19
本篇文章将深入探讨在ThinkPHP框架中如何简单地遍历数组，以及与之相关的`cookie`、`session`、`数组`、`方法`等概念。 首先，我们看一个简单的ThinkPHP中的数组遍历实例： ```php $array = array( array('id' =>...
基于二维数组和十字链表的Apriori算法 数组和链表.docx
04-18
### 基于二维数组和十字链表的Apriori算法 #### 一、引言 Apriori算法是一种广泛应用于数据挖掘领域的经典算法，主要用于发现频繁项集和关联规则。传统的Apriori算法虽然简单易懂，但在处理大规模数据集时存在两个...
数组的链式使用
gogopaner的博客
07-04 713
数组的链式使用 // 数组方法之中，有不少返回的还是数组，所以可以链式使用。 var users = [ {name: 'tom', email: 'tom@example.com'}, {name: 'peter', email: 'peter@example.com'} ]; users .map(function (user) { return user.email; }) .filter(function (email) { return /
多个数组链接成一个数组_数组与链接列表–数组与链接列表之间的区别
culing2941的博客
09-17 438
多个数组链接成一个数组Ever wondered, How data is stored inside the computer’s memory? You can’t just throw data into the memory without making proper structure for the data. 曾经想过，如何将数据存储在计算机内存中？ 您不能不为数据建立适当的结构就...
数组和链表的详细介绍
xiaomao_wxj的博客
03-01 6216
基本数据结构——数组、链表
链接数组的四种方法（把两个数组链接成一个数组）
gplihf的博客
08-18 1万+
首先定义两个数组，这边以int数组为例 int[] arrayList={9,5,3,2,0,4}; int[] arrayList2={1,6,8,7}; 方法一、ArrayUtils.addAll()方法，引入包：org.apache.commons.lang3.ArrayUtils; int[] tempArrayList = ArrayUtils.addAll(arrayList,
数组仿真链表以及效率的对比说明
cprimesplus的博客
09-12 608
今天读了几篇张新华编写的《算法竞赛宝典》一书第三部，有了一些心得。 了解链表的创建后，我们可以使用数组来模拟链表的相关操作（尽可能开辟一个较大内存，因为数组仿真不具备链表动态开辟内存的特点）。对于每个“链结”，用linkNum[i]来存放数组元素的值，linkPos[i]来存放下一个元素的地址（其实也就是下一个元素的位置）。 代码： //数组仿真链表 #include&lt;stdio....
数组与链表——异同分析
Sudouble的专栏
04-05 1364
近期开始看《图解算法》，虽然很早以前就接触过算法这块的，但还是不得不惊叹作者的功力，巧妙地借助漫画的形式和相关的例子把复杂的原理讲得如此有趣和透彻。这里将先跳过大O（时间复杂度、空间复杂度）相关部分的介绍，以及关于最佳、平均、最坏情况下复杂度的估计方法。 内存 首先是介绍内存的概念，一般来说，数据都是经硬盘加载到内存后才可以进行后续处理（把硬盘空间大小当成内存空间大小的请面壁思过...
0xffffffff是多少?
ZoeyZY的博客
11-19 1万+
转载：https://blog.youkuaiyun.com/yew1eb/article/details/8718190?locationNum=1&amp;fps=1
数组、链表、堆栈和队列
热门推荐
amork的专栏
02-14 2万+
数据结构：是指相互之间存在一种或多种特定关系的数据元素的集合。听起来是不是很抽象，简单理解：数据结构就是描述对象间逻辑关系的学科。比如：队列就是一种先进先出的逻辑结构，栈是一种先进后出的逻辑结构，家谱是一种树形的逻辑结构！（初学数据结构的时候很不理解为什么有“栈”这个东西；队列很容易理解---无论购物就餐都需要排队；栈可以认为就是个栈道---只允许一个人通过的小道，而且只能从一端进入，然后再从这端
删除数组中的元素——链条
最新发布
01-22
### 如何在编程语言中实现从数组删除元素 #### 使用数组结构删除元素 当涉及到数组时，由于其特性决定了大小不可变，在原地直接移除某个元素意味着要调整后续元素的位置以填补空缺。对于一维数组而言，一旦确定了待删除的目标位置，则需将此位置之后的所有元素向前移动一位来覆盖被删去的空间[^1]。 ```python def remove_element_from_array(arr, target_index): if not 0 <= target_index < len(arr): raise IndexError("Target index out of range.") new_arr = [] for i in range(len(arr)): if i != target_index: new_arr.append(arr[i]) return new_arr ``` 上述Python函数展示了如何构建一个新的列表`new_arr`而不包含指定索引处的元素，从而实现了逻辑上的“删除”。 #### 利用链表结构执行删除操作 不同于数组，单向链表是由节点组成的集合，每个节点保存着指向下一个节点的链接地址以及自身的数据域。因此，在链表内进行元素删除并不涉及大量位移工作；只需改变指针方向即可完成目标节点及其前后关系的有效断开与重组[^2]。 下面是一个简单的Go语言例子用于说明怎样在一个已知头结点head且不含循环引用的单链表里定位并摘除值等于给定参数value的第一个匹配项： ```go type ListNode struct { Val int Next *ListNode } func deleteNode(head *ListNode, value int) *ListNode { dummy := &ListNode{Next: head} prev, curr := dummy, head for curr != nil && curr.Val != value { prev, curr = curr, curr.Next } if curr != nil { // Found the node to be deleted. prev.Next = curr.Next } return dummy.Next } ``` 这段代码首先引入了一个哨兵节点dummy作为辅助手段以便处理特殊情况下的头部变更问题，接着遍历整个链条直至找到符合条件的节点或到达末端为止。最后一步则是通过修改前驱prev的next字段跳过当前curr所指向的对象，进而达到物理意义上的去除效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值