链表与数组的比较

1 静态数组

2 动态数组

1 静态数组

  1 #define _CRT_SECURE_NO_WARNINGS
  2
  3 #include <stdio.h>
  4 #include <stdlib.h>
  5
  6 //作为静态数组,无法变长,一旦分配内存,就固定了,不可以增加
  7 //外部的内存可以访问,但是外部内存可能被使用,也可能没有被使用
  8 //没有使用的情况下,越界偶尔会成功,还是可能被再次回收利用
  9 //已经使用,必然失败
 10 //a[n]等价于*(a+n);从数组名首地址开始,往下寻址,取出内容,数组不会检测越界
 11 //偶尔会成功,偶然的成功比必然的失败更加可怕,数组不可以越界
 12
 13 main1()
 14 {
 15     int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
 16
 17     printf("%x\n", a);
 18
 19     system("pause");
 20 }
 21
 22 //静态数组,不可以处理较大的数据
 23
 24 main2()
 25 {
 26     int b[1024 * 014 * 10];//默认数组在栈上,最大只能使用1MB
 27
 28     printf("%x\n", b);
 29
 30     system("pause");
 31 }
 32
 33 main3()
 34 {
 35     int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
 36     int i, j;
 37     int length = sizeof(a) / sizeof(int);
 38
 39     for (i = 0;i < length;i++)
 40     {
 41         printf("%d\n", a[i]);
 42     }
 43
 44     int num = 8;//要删除的元素
 45
 46     if (num == a[9])//检测最后一个元素
 47     {
 48         length = length - 1;//删除一个元素,元素在末尾
 49     }
 50     else
 51     {
 52         for (i = 0;i < length - 1;i++)//检测最后一个之前
 53         {
 54             if (a[i] == num)
 55             {
 56                 for (j = i;j < length - 1;j++)//从删除的位置开始,到最后一个全部向前移动
 57                 {
 58                     a[j] = a[j + 1];//逐个向前移动赋值
 59                 }
 60                 length = length - 1;
 61                 break;
 62             }
 63         }
 64     }
 65
 66     printf("尾部删除以后\n");
 67     for (i = 0;i < length;i++)
 68     {
 69         printf("%d\n", a[i]);
 70     }
 71
 72     system("pause");
 73
 74 }
 75
 76 //查询方便
 77 main4()
 78 {
 79     int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
 80     int i;
 81     int flag = 0;
 82     int length = sizeof(a) / sizeof(int);
 83
 84     for (i = 0;i < length;i++)//逐个访问数组每个元素
 85     {
 86         if (a[i] == 7)//查询
 87         {
 88             flag = 1;
 89             break;
 90         }
 91     }
 92
 93     if (flag == 1)
 94     {
 95         printf("找到");
 96     }
 97
 98     system("pause");
 99 }
100
101 //修改方便
102 main()
103 {
104     int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
105     int i;
106     int flag = 0;
107     int length = sizeof(a) / sizeof(int);
108
109     for (i = 0;i < length;i++)//逐个访问数组每个元素
110     {
111         if (a[i] == 7)//查询
112         {
113             flag = 1;
114             a[i] = 9;
115             break;
116         }
117     }
118
119     for (i = 0;i < length;i++)
120     {
121         printf("%d\n", a[i]);
122     }
123
124     system("pause");
125 }
时间: 2024-10-27 10:28:01

链表与数组的比较的相关文章

链表和数组的区别

数组是线性结构,可以直接索引,即要去第i个元素,a[i]即可.链表也是线性结构,要取第i个元素,只需用指针往后遍历i次就可.貌似链表比数组还要麻烦些,而且效率低些. 想到这些相同处中的一些细微的不同处,于是他们的真正不同处渐渐显现了:链表的效率为何比数组低些?先从两者的初始化开始.数组无需初始化,因为数组的元素在内存的栈区,系统自动申请空间.而链表的结点元素在内存的堆区,每个元素须手动申请空间,如malloc.也就是说数组是静态分配内存,而链表是动态分配内存.链表如此麻烦为何还要用链表呢?数组不

将一个已排序的链表或数组转化成一棵平衡二叉树

Problem:Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST. 解题思路:这里要充分利用元素的有序性,来构造一棵平衡二叉树,这样可以避免为了维持二叉树的平衡性,而进行各种旋转操作.可以每次都向树中插入一个序列中的中间元素,这样就可以保证该结点的左子树和右子树含有结点的数目相等(或只相差一个).这样反复操作,就可以构造一颗类完全

链表和数组的区别在哪里 【微软面试100题 第七十八题】

题目要求: 链表和数组的区别在哪里? 题目分析: 数组静态分配内存,链表动态分配内存: 数组预先定义长度,链表预先无需管理长度: 数组在内存中连续,链表可能连续: 数组元素在栈区,链表元素在堆区: 数组利用下标定位,时间复杂度为O(1),链表定位元素时间复杂度O(n): 数组插入或删除元素的时间复杂度O(n),链表的时间复杂度O(1): 数组相对更省空间,存储一个元素链表还需要存储一个next指针: 数组排序相对比链表简单.

链表补充及链表和数组的区别

初稿:2017-11-19 13:05:57 4种链表 不循环单链表:加头结点,使得插入删除操作相同,不必特别处理插入或删除的是第一个位置的情况. 循环单链表:引用参数是最后一个结点的指针pTail,这样既能迅速找到首结点pHead = pTail->next,也能迅速获取表尾. 不循环双向链表:p所指结点后插入结点q.  q->next = p->next; p->next->pre = q; p->next = q; q->pre = p; 循环双向链表:引用

33-算法训练 安慰奶牛 - 对象数组排序,对象链表转数组

算法训练 安慰奶牛 时间限制:1.0s   内存限制:256.0MB 问题描述 Farmer John变得非常懒,他不想再继续维护供奶牛之间供通行的道路.道路被用来连接N个牧场,牧场被连续地编号为1到N.每一个牧场都是一个奶牛的家.FJ计划除去P条道路中尽可能多的道路,但是还要保持牧场之间 的连通性.你首先要决定那些道路是需要保留的N-1条道路.第j条双向道路连接了牧场Sj和Ej(1 <= Sj <= N; 1 <= Ej <= N; Sj != Ej),而且走完它需要Lj的时间.

链表和数组的区别在哪里?

二者都属于一种数据结构 从逻辑结构来看 1. 数组必须事先定义固定的长度(元素个数),不能适应数据动态地增减的情况.当数据增加时,可能超出原先定义的元素个数:当数据减少时,造成内存浪费:数组可以根据下标直接存取. 2. 链表动态地进行存储分配,可以适应数据动态地增减的情况,且可以方便地插入.删除数据项.(数组中插入.删除数据项时,需要移动其它数据项,非常繁琐)链表必须根据next指针找到下一个元素 从内存存储来看 1. (静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小 2. 链表从

面试-链表和数组的区别

相关资料:1.http://blog.csdn.net/kedark/article/details/549155772.http://blog.csdn.net/wqsys/article/details/7656650 数组:1.将元素在内存中连续存放.2.每个元素占用内存相同.3.通过下标迅速访问数组中任何元素.4.增加.删除一个元素需移动大量元素.5.需要快速访问数据,很少或不插入和删除元素,应用数组.6.(静态)数组从栈中分配空间, 对于程序员方便快速,但自由度小.7.内存占用空间是固

数据结构:快状链表(数组链表联合)

#include <iostream> #define _MAX_ 10 using namespace std; //块状链表. struct MyNode { //按理说每块数据的数组长度应该是根号N到2倍的根号N之间,暂时 //我为了测试就使用100个左右的数据. int *data; int size;//大小. int currentIndex;//当前下标. MyNode *prev; MyNode *next; MyNode() :prev(NULL), next(NULL) {

C# 数据结构 线性表(顺序表 链表 IList 数组)

线性表 线性表是最简单.最基本.最常用的数据结构.数据元素 1 对 1的关系,这种关系是位置关系. 特点 (1)第一个元素和最后一个元素前后是没有数据元素,线性表中剩下的元素是近邻的,前后都有元素. (2)线性表中的元素是有限的(List),线性表中的数据类型一致. (3)线性表表示方法 L={a1,a2,a3,a4…….an},L=(D,R) (4)每一个元素都有前驱和后继,第一个元素只有后继,最后一个元素只有前驱. 实例 例如:1-100的整数是一个线性表 {“zhangsan”, “lis

C语言链表中数组实现数据选择排序,升序、降序功能主要难点

链表排序讲解: head指针指向链表的头结点,是找到整个链表的唯一依据,如果head指针丢失,整个链表就找不到了. head存储的是第一个节点的地址,head->next存储的是第二个节点的地址:  任意一个节点p的地址,只能通过它前一个节点的next来求得. 单向链表的选择排序图示: ---->[1]---->[3]---->[2]...---->[n]---->[NULL](原链表) head   1->next  3->next  2->next