精华内容
下载资源
问答
  • 关于删除和查找:在数组删除或添加一个元素,为了内存的连续性,需要变动此增加元素索引之后的所有元素,在链表中则只需要断开和连接 数组扩容:数组在定义时需要分配连续的内存空间,扩容时的操作是将整个数组...

    数组:一种线性表数据结构

     线性表是指:每个数据只有前后两个方向的关联,常见的有数组,栈,链表,队列

    与之相对应的非线性表有树,堆,图

    关于删除和查找:在数组中删除或添加一个元素,为了内存的连续性,需要变动此增加元素索引之后的所有元素,在链表中则只需要断开和连接

    线性 数据结构

    数组扩容:数组在定义时需要分配连续的内存空间,扩容时的操作是将整个数组复制一份并重新分配新的内存空间,所以如果在定义数组是能确定数据的长度,尽量直接定义固定长度的数组,这样可以省掉很多次内存申请和数据搬移的操作,减少代码执行时需要消耗的时间

    此等观众,才有幸见证我的来临

    数组索引为什么从0开始:首先,数组内存的寻址公式如下:

    a[i]_address = base_address + i * data_type_size

    data_type_size是数组元素的大小,比如int型就是4个字节,那么从这个公式看来,我们通常所说的下标更准确的说法应该是offset,“偏移”,从0开始的话正好数组第一个元素的地址就是起始地址,从1开始的话会多一层减法运算

    二维数组:二维数组在内存中的本质其实也是一维数组,只不过数组的每个元素又是一个数组,比如arr[3][3]就可以看出一个length=3的一维数组,一个m*n的二维数组,其寻址公式为:

    a[i][j]_address = base_address + (i *n+j)* data_type_size

     

    展开全文
  • 数据结构八大类型的总结及应用数据结构八大类型的总结及应用数组概念及优缺点数组的应用栈概念应用队列概念链表概念及优...数组的添加某个元素,和删除某个元素的操作比较复杂,需要修改该位置后面的所有元素。 数组

    数据结构八大类型的总结及应用(上)

    本篇博客只总结了一半的内容,后一半的链接给各位送上:
    https://blog.csdn.net/weixin_44593531/article/details/107453932

    数组

    概念及优缺点

    数组是可以再内存中连续存储多个元素的结构,在内存中的分配也是连续的,数组中的元素通过数组下标进行访问。

    优点十分明显,根据数组的索引可以快速的查找元素和遍历数组。

    缺点表现在以下三个方面:

    1. 数组的大小一般在创建的时候就已经定义好了。
    2. 数组的添加某个元素,和删除某个元素的操作比较复杂,需要修改该位置后面的所有元素。
    3. 数组只能存放一种类型的数据。

    在这里插入图片描述

    数组的应用

    我们通过一个C语言程序来总结数组结构的适用范围

    对一个数组进行冒泡排序和选择排序

    int main()
    {
    	int a[] = {2,5,8,0,9,6};
    	int n= sizeof(a)/sizeof(a[0]); 
    	//冒泡排序从大到小 
    	for(int i=0;i<n-1;i++)
    	{
    		for(int j=0;j<n-1-i;j++){
    			if(a[j]<a[j+1]){
    				int x = a[j];
    				a[j] = a[j+1];
    				a[j+1] = x;
    			}
    		}
    	}
    	//选择排序从小到大 
    	int tmp = 0;
        for (int i=1;i<n;i++) {
            int j = i - 1;
            if (a[i] < a[j]) {
                tmp = a[i];
                a[i] = a[j];
                while (tmp < a[j-1]) {
                    a[j] = a[j-1];
                    j--;
                }
                a[j] = tmp;
            }
        }
    	return 0;
    } 
    
    

    我们可以看到,如果在实现需要频繁的迅速的遍历或者查找元素功能,且很少增加和删除的情况下,数组是非常有效的。但是通过对概念的了解,数组存放在一片连续的地址空间上,因而一般用来处理数量相对较小的数据,也就是对内存空间要求不大时,我们使用数组来操作。

    概念

    栈是一种特殊的线性表,仅能在线性表的一端操作,栈顶允许操作,栈底不允许操作。 栈的特点是:先进后出,或者说是后进先出,从栈顶放入元素的操作叫入栈,取出元素叫出栈。
    在这里插入图片描述

    应用

    用C语言链表来实现栈操作

    typedef struct Link{
    	int elem;
    	struct Link *next;
    }link;//结构体创建 
    
    link * initStack(){
    	link * stack = (link*)malloc(sizeof(link));
    	return stack;
    }//新建一个栈 ,令其指针永远指向栈顶元素,元素的指针指向下一元素 
    
    void inStack(int elem, link *stack) {
    	link *temp = stack;
    	if(temp->next == NULL){//如果栈内没有元素就直接添加到栈顶 
    		link * d = (link*)malloc(sizeof(link));
    		d = temp->next;
    		d->elem = elem;
    		d->next = NULL;
    	}else{//否则添加到栈顶,并将新元素指向之前的栈顶 
    		link * s = (link*)malloc(sizeof(link));
    		s->next = temp->next
    		temp->next = s;
    		s->elem = elem;
    	}
    }//入栈 
    
    void outStack(link *stack){
    	link *temp = stack;
    	if(temp->next == NULL){
    		printf("The stack is empty!");
    	}else{
    		printf("%d",temp->next);
    	}
    }//输出栈顶元素 
    
    void deleteStackElem(link *stack){
    	link *temp = stack;
    	if(temp->next == NULL){
    		printf("The stack is empty!");
    	}else{
    		link *s = temp->next;
    		temp->next = s->next;
    		s->next = NULL;
    		free(s);
    	}
    }//删除栈顶元素 
    

    队列

    概念

    队列与栈一样,也是一种线性表,不同的是,队列可以在头一端添加元素,在尾一端取出元素,也就是:先进先出。从一端放入元素的操作称为入队,取出元素为出队。
    在这里插入图片描述

    typedef struct Link{
    	int elem;
    	struct Link *next;
    }link;//结构体创建 
    
    link * initQueue{
    	link *front = (link*)malloc(sizeof(link));
    	link *rear = (link*)malloc(sizeof(link));
    } //初始化两个指针分别指向入队口和出队口 
    
    void addElem(int elem,link *front,link *rear){
    	link *add = (link*)malloc(sizeof(link));
    	link *temp = rear;
    	if(temp->next == NULL){
    		temp->next = add;
    		add->next = elem;
    		front->next = add;
    	} else{
    		temp->next->next = add;
    		add->elem = elem;
    		temp->next = add;
    	}
    }//入队 
    
    void delElem(link *front,link *rear){
    	link *temp = front;
    	if(temp->next == NULL){
    		printf("The queue is empty!");
    	}else{
    		link *elem = temp->next
    		temp->next = elem->next;
    		free(elem);
    	}
    }//出队 
    

    链表

    概念及优缺点

    链表是物理存储单元上非连续的、非顺序的存储结构,数据元素的逻辑顺序是通过链表的指针地址实现,根据指针的指向,链表能形成不同的结构,例如单链表,双向链表,循环链表等。

    单链表:
    每一个结点被分成两个部分,第一个部分是用来存放数据的,称为数据域,第二个部分是用来存放指针的,称为指针域,该位置所存放的指针指向的是下一个结点的地址。

    一般链表中都存在一个头结点,该结点是不存放数据的,也就是说该结点的数据域为NULL,另外还存在一个尾结点,这个结点的指针域为空,也就是不指向下一个结点,因为它不存在下一个。首元结点指的是第一个存放数据的结点,头指针指向的是头结点。
    在这里插入图片描述

    双向链表:
    在传统链表中我们寻找下一个结点是否方便,但是如果要追溯前面的结点是比较困难的。因此双向链表提供了反向遍历的能力。其秘密在于每个结点有两个指向其他结点的引用,一个指向前继结点,一个指向后继结点。下图显示了双向链表:在这里插入图片描述
    每个结点包括前指针、数据、后指针三部分。前指针指向前一个结点,后指针指向后一个结点,对于头结点,前指针为NULL,对于尾结点来时后指针为NULL。

    循环链表:
    循环链表就是在单链表的基础上,尾结点指向头结点,如下图所示:
    在这里插入图片描述

    链表的优点:

    • 方便添加和删除元素

    链表的缺点

    • 查找相对困难

    链表的应用及适用范围

    C语言对单链表进行增删改查操作:

    typedef struct Link{
    	int elem;
    	struct Link *next;
    }link;//创建结构体
    
    link * initLink(int n){
    	int x;
        link * p=(link*)malloc(sizeof(link));
        link * temp=p;
        for (int i=0; i<n; i++) {
            link *a=(link*)malloc(sizeof(link));
            scanf("%d",&x);
            a->elem=x;
            a->next=NULL;
            temp->next=a;
            temp=temp->next;
        }
        return p;
    } //新建
    
    void addElem(int elem, int index,link *p) {
    	link *temp = p;
    	link *a=(link*)malloc(sizeof(link));
    	for(int i=0;i<index;i++){
    		temp = temp->next;
    	}
    	a->elem = elem;
    	a->next = temp->next;
    	temp->next = a;
    }//增加 
    
    link * delElem(link * p,int add){
        link * temp=p;
        for (int i=0; i<add; i++) {
            temp=temp->next;
        }
        link * del=temp->next;
        temp->next=temp->next->next;
        free(del);
        return p;
    }//删除 
    
    void modifyElem(link *p,int index,int elem){
    	link *temp = p;
    	for(int i = 0;i<index;i++){
    		temp = temp->next;
    	}
    	temp->elem = elem;
    } 
    
    void getElem(link *p, int index){
    	link *temp = p;
    	for(int i = 0;i<index;i++){
    		temp = temp->next;
    	}
    	printf("%d\n",temp->elem);
    } //查找 
    
    void display(link *p){
    	link *temp=p;
    	while(temp){
    		printf("%d",temp->next->elem);
    		temp=temp->next;
    	}
    	printf("\n");
    }//遍历 
    

    我们可以看到,在链表的初始化中不需要确定容量,所以后面可以进行元素的增加和删除,而且删除和增加操作都非常方便只需要改变指针所指向的值就好,但是,链表的查找却不是很简单,因为他需要从头结点开始遍历一直到找到该数据,相比数组而言,无法通过索引进行寻找,因此,我们一般在需要频繁的增加和删除的情况下使用链表。

    展开全文
  • 数组和链表

    2020-02-25 21:37:29
    数组: 定义:存储同一种类型多个元素的容器 ...D:再将y元素及x元素所有元素赋值给新数组 删除元素(同上) 链表: 定义:用一个链子将多个结点连起来的数据 特点:查找慢,增删快 查找:不...

    数组:

    定义:存储同一种类型多个元素的容器

    特点:查找快,增删慢

    查找:直接根据索引值即可

    增加元素(假设在x元素元素后加入y元素):
    A:新建一个数组,长度比原数组大1
    B:遍历原数组,找到x元素位置
    C:将原数组里x元素及x元素前面的元素都赋给新数组
    D:再将y元素及x元素后的所有元素赋值给新数组
    删除元素(同上)

    链表:

    定义:用一个链子将多个结点连起来的数据

    特点:查找慢,增删快

    查找:不管找哪个,都要从头开始

    增加元素(在x元素后增加y元素):
    A:新建一个临时变量temp
    B:将x元素地址位置的值赋值给temp
    C:将y元素的地址值赋值给x元素地址位置值
    D:将temp值赋值给y元素的地址位置值
    删除元素(删除x元素):
    将x元素地址位置值给x前一个元素地址位置值即可

    展开全文
  • 如上图当一个循环的数组中包含 1 2 3 4 5需要删除 当循环删除2绿色的框,数组长度就变成4个,所有2后面的都会依次往前顶上去。导致下一次循环到3时,他删除的就是紫色的框的值就会跳过蓝色的框,这样依次下去就会...
    当使用for循环顺序删除数组或者我之前遇到的问题使用Python操作Excel中需
    要循环删除空列,会导致一次性删除不完。
    原因是当我用for循环时候是用的索引循环。当我删除一个循环中的值时,索引
    长度会变短,会往前递进。导致无法一次性循环删除。
    

    在这里插入图片描述 在这里插入图片描述

    如上图当一个循环的数组中包含 1 2 3 4 5需要删除 当循环删除2后绿色的框,数组长
    度	就变成4个,所有2后面的都会依次往前顶上去。导致下一次循环到3时,他删除的
    就是	紫色的框的值就会跳过蓝色的框,这样依次下去就会导致不会一次性删除索要删
    除的数	据。 解决这个办法可以投机取巧,不要从第一位开始循环,可以从最后一位,
    倒着循	环删除,就可以解决问题了。Python中倒着循环代码如下:
    
     for i in range(10,0,-1): #0<i<=10 步长-1 
     print(i)
    
    展开全文
  • 数组与链表的区别

    2016-12-12 14:01:42
    缺点:而对于数组插入和删除操作,则效率会比较低,在第一个位置进行插入数据,其余数据就需要依次向移动,而第一个数据进行删除,则需要所有数据全部向前移,这样的话,就会推出第二种结构,链表结构。...
  • 1、数据存储结构分为顺序存储、链接存储、索引存储、散列存储。 2、数组属于顺序存储,用一段连续的内存位置来存储。 3、链表属于链接存储,用一组任意的存储单元来存储,不要求物理上相邻。 抽象: 1、顺序存储可以...
  • 数组和链表的区别

    万次阅读 2015-04-10 17:31:24
     数组结构在通过索引进行查询数据时效率比较高,而对于数组插入和删除操作,则效率会比较低,在第一个位置进行插入数据,其余数据就需要依次向移动,而第一个数据进行删除,则需要所有数据全部向前移,这样的话,...
  • JavaScript 数组的力量隐藏在数组方法中。 1. javaScript常用数组方法 顺序方法名功能返回值...并把所有其他元素“位移”到更低的索引返回被删除数据YES5-5reverse()反转数组中的元素返回反转后数组YES5-6sor...
  • 数组-二分查找

    2017-02-23 11:55:53
    优点:查询速度比无序数组快 缺点:删除慢,因为数据项必须向前移动来填补已删除数据项的洞 增加慢,需要移动大于增加数所对用索引后面的所有值  *   * @author Administrator  *  */ /**  * @author ...
  • 为什么数组比链表查询速度更快?

    千次阅读 2020-07-11 14:46:25
    而且你如果想在数组中间进行插入和删除,每次必须搬移后面的所有数据以保持连续,时间复杂度 O(N)。 链表因为元素不连续,而是靠指针指向下一个元素的位置,所以不存在数组的扩容问题;如果知道某一元素的
  • 接下来,对调整的n个数据重新排查,再次找出n个数据中最大的那个,然后重复以上操作,直到将所有符合要求的数据都找出来; 另一方面,设定锚点存放的是每个数据段p的最小的值,p段里面还有p_段,要筛选出最小的n个...
  • 数据结构基础了解

    2020-07-08 21:34:35
    删除数据数组删除数组,为了保证数组中数据在内存中的连续性,从删除位置起,后面所有数据都会向前移动一位; 数组适合查询和修改,不适合增加和删除; 栈:线性表的实现,栈顶允许操作,栈底不允许操作;先进...
  • 数据结构体系复构

    2020-08-09 16:12:17
    1、数组 数组是可以再内存中连续存储多个元素的结构,在内存中的分配也是连续的,数组中的...数组的大小固定无法扩容 数组只能存储一种数据类型 添加、删除的操作慢(原因:要移动其他元素) 适用: 频繁查询。对存储
  • 重拾数据结构(一)

    2017-02-21 01:41:42
    1.链表与数组,统称线性表 ...(2)链表删除元素只需要改变后继和前驱,数组需要将删除元素后所有元素迁移一位  需要通过getElement获取元素然后删除,此时链表与数组操作耗时无法确定 (3)链表添加元素改变
  • Java数据结构分类

    2018-04-18 17:24:55
    数组结构:数组结构在通过索引进行查询数据时效率比较高,而对于数组插入和删除操作,则效率会比较低,在第一个位置进行插入数据,其余数据就需要依次向移动,而第一个数据进行删除,则需要所有数据全部向前移,...
  • Array: 数组,开辟连续存储的内存存储数据.Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大的,因为这需要重排数组中的所有数据 优点: 1.查询速度快,可以利用索引快速查询到对象 2.类型安全,支持值类型...
  • 数据结构的存储方式 数据结构的存储方式只有两种:数组(顺序存储)和链表(链式存储)。 ...而且你如果想在数组中间进行插入和删除,每次必须搬移后面的所有数据以保持连续,时间复杂度 O(N)。 链
  • 链表与数组的相爱相杀 线性表有两种存储方式—链表和数组 数组,所有的元素都连续的存储于一段内存中,且每个元素占用的内存大小相同,所以数组具备了...数组删除元素时,要将被删除元素之后的所有元素都向前移动...
  • 数据结构

    2020-08-14 12:33:24
    数组:每个元素有个正的索引值(以0开始) Insert-----给定索引位置插入元素 Get-----返回给定索引位置的元素 Delete-----删除给定索引位置的元素 Size----获取组内所有元素的总数 堆栈:LIFO工作原理,(撤销...
  • 散列数据 可以快速插入和取用在散列表上插入、删除和取用数据非常快,但是查找数据却效率低下js散列表基于数组设计,理想情况散列函数会将每一个键值映射为唯一的数组索引数组长度有限制,更现实的策略是将键...
  • 数组是最常用的数据结构,数组的特点是长度固定,可以用下标索引,并且所有的 元素的类型都是一致的。 列表 列表和数组很相似,只不过它的大小可以改变。列表一般都是通过一个固定大小的 数组来实现的,并且会在需要...
  • 转载自labuladong 1. 数据结构的存储方式 ...而且你如果想在数组中间进行插入和删除,每次必须搬移后面的所有数据以保持连续,时间复杂度 O(N)。 链表:因为元素不连续,而是靠指针指向下一个元素的位置,所以不
  • 关于数据结构的总结

    2020-12-08 22:41:11
    ⽽且你如果想在数组中间进⾏插⼊和删除,每次必须搬移⾯的所有数据以保持连续,时间复杂度 O(N)。 链表:因为元素不连续,⽽是靠指针指向下⼀个元素的位置,所以不存在数组的扩容问题;如果知道某⼀元素的前驱和...
  • 在单台机器上实现TB级的数据对比之数据合并 整体思路 在上一章节,我介绍了如何对切分数据进行并行...在原始排序文件中读取所有文件的首行数据,并记录到以文件索引为下标的数组中。就叫它srcDataList 在目标排
  • Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大,因为这需要重排数组中的所有数据, (因为删除数据以后, 需要把后面所有的数据前移) 缺点: 数组初始化必须指定初始化的长度, 否则报错 例如: int[] ...
  • Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大,因为这需要重排数组中的所有数据,(因为删除数据以后, 需要把后面所有的数据前移) 缺点: 数组初始化必须指定初始化的长度, 否则报错 例如: int[] a...
  • 因为往list集合里插入或删除数据时,会伴随着后面数据的移动,所有插入删除数据速度慢。 ArrayList ArrayList是基于数组的,在初始化ArrayList时,会构建空数组(Object[] elementData={})。ArrayL...
  • Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大,因为需要重排数组中的所有数据,(因为删除数据以后,需要把后面所有的数据前移) 缺点:数组初始化必须指定初始化的长度,否则报错。 例如: ...
  • Day 01 数据结构 ...而且你如果想在数组中间进行插入和删除,每次必须搬移后面的所有数据以保持连续,增删时间复杂度 O(N)、改查时间复杂度 O(1) 链表 链式存储 因为元素不连续,而是靠指针指向下一
  • Java List.remove/removeAll删除元素java种list.remove删除索引从0开始,删除了元素,这个元素后面的都会集体左移,因此list的元素数据量会发生变化,这个很重要,操作不当会出现数组越界问题;removeall是删除...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 166
精华内容 66
关键字:

数组删除索引后所有数据