1. 有没有线性表的顺序存储程序，12的基本操作，初始化，销毁，清空，判断是否为空，插入，删除，定位查找。。
#include<ds1.h>
#define LIST_INIT_SIZE 100 //线性表存储空间初始分配量
#define LISTINCREMENT 10 //空间不够时的分配增量
#define ElemType int
typedefstruct{
ElemType *elem; //存储空间基址
intlength; //当前长度
intlistsize; //当前分配的存储容量
}SqList;
//初始化
Status InitList_Sq(SqList *L){
//分配一段连续空间
L->elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L->elem)exit(_OVERFLOW);
L->length = 0;
L->listsize = LIST_INIT_SIZE;
returnOK;
}
//在位置i 插入一个元素e
Status ListInsert_Sq(SqList *L,inti,ElemType e){
if(i<1||i>L->length+1) returnERROR;
if(L->length>=L->listsize){//存储空间已满，增加分配
ElemType* newbase=(ElemType*)realloc(L->elem,
(L->listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase) exit(_OVERFLOW);
L->elem = newbase;
L->listsize+=LISTINCREMENT;
}
ElemType* q= &(L->elem[i-1]);//插入位置
for(ElemType* p=&(L->elem[L->length-1]);p>=q;--p)
*(p+1)=*p;
*q=e;
++L->length;
returnOK;
}
//删除位置i的元素，并将该元素返回为e
Status ListDelet_Sq(SqList *L,inti,ElemType *e){
if((i<1)||(i>L->length))returnERROR;
ElemType* p=&(L->elem[i-1]);//删除位置
*e=*p;
ElemType* q=L->elem+L->length-1;
for(++p;p<=q;++p) *(p-1)=*p;
--L->length;
returnOK;
}
//摧毁
Status DestroyList_Sq(SqList *L){
L->length=0;
L->listsize=0;
free(L->elem);
returnOK;
}
//清空
Status ClearList_Sq(SqList *L){
L->length=0;
returnOK;
}
2. mvp activity 因内存不足被销毁怎么处理
可腾讯手机管家小火箭清理加速内存，小火箭手机加速功能，实现便捷启动手机加速、防止误操作，同时还提升了手机加速的乐趣，通过火箭一飞冲天，燃烧掉后台进程，从而完成加速。在设置中更改为火箭悬浮窗之后，按住火箭会提示用户将它拖到屏幕底部，拖到屏幕底部后会出现一个火箭一飞冲天的动画，而且还会显示关闭了多少个进程，并在手机任务栏底部产生一团烟雾，整个动画非常逼真、有趣。
3. c++，什么叫销毁对象，什么叫释放内存，两者有什么区别int *a = new int；申请的i
对象 翻译过来的词，实际上 它指 “具体的东西”。例如声明 一个 class, 它只是 描述 此物 特征，没有 建立 一个 具体的 东西。只有 告知和构建 “某某” 是 “这 class” 的 对象，“某某”才是 具体的东西。class 的 对象 含 私有变量，公有变量，函数等等。销毁对象时，要调它的销毁函数，拆毁了它。
释放内存 用于 一般 变量，结构等，通过动态分配得到的空间。
例如 int *a = new int; 释放内存 后 *a 还存在，只是失去了 数据存放空间。
4. 电脑在哪里清理内存垃圾
这个一般来说你得下载电脑管家才可以的，一般的电脑管家你才可以进行这个内存的清理的，所以你最好还是可以去下载一个软件什么的，这个是可以的。下面是关于内存的(4)销毁存储空间扩展阅读。
发展
计算机诞生初期并不存在内存条的概念。最早的内存是以磁芯的形式排列在线路上，每个磁芯与晶体管组成的一个双稳态电路作为一比特（BIT）的存储器。
每一比特都要有玉米粒大小，可以想象一间机房只能装下不超过百k字节左右的容量。后来才出现了焊接在主板上的集成内存芯片，以内存芯片的形式为计算机的运算提供直接支持。
那时的内存芯片容量都特别小，最常见的莫过于256K×1bit、1M×4bit。虽然如此，但对于那时的运算任务来说却绰绰有余了。[3]
内存条
内存芯片的状态一直沿用到286初期。鉴于它存在着无法拆卸更换的弊病，这对计算机的发展造成了现实的阻碍。
有鉴于此，内存条便应运而生了。将内存芯片焊接到事先设计好的印刷线路板上，电脑主板上也改用内存插槽。这样，把内存难以安装和更换的问题彻底解决了。[3]
在80286主板发布之前，内存没有被世人重视。这个时候的内存直接固化在主板上，容量只有64 ～256KB。对于当时PC所运行的工作程序来说，这种内存的性能以及容量足以满足当时软件程序的处理需要。
随着软件程序和新一代80286硬件平台的出现，程序和硬件对内存性能提出了更高要求。为了提高速度并扩大容量，内存必须以独立的封装形式出现，因而诞生了“内存条”的概念。[3]
80286主板刚推出时，内存条采用了SIMM（Single In-lineMemory Moles，单边接触内存模组）接口，容量为30pin、256kb，必须是由8 片数据位和1 片校验位组成1 个bank。
5. 怎样才能把储存空间清理干净。
主流的数据销毁技术，主要有数据删除、物理销毁等。“删除（Delete）”是删除数据最便捷的方法，如大家熟悉的右键删除。它实际上并没有真正的把数据从硬盘上删除，只是将文件的索引删除而已。这种方法是最不安全的，只能欺骗普通使用者。现在有很多专门进行数据恢复的软件，普通用户即可在网上下载软件恢复此类数据。
与此类似的是，磁盘格式化（Format）也不能彻底消除磁盘上的数据。格式化仅仅是为操作系统创建一个全新的空的文件索引，将所有的扇区标计为未使用状态，让操作系统认为硬盘上没有文件。因此，格式化后的硬盘数据也是可以恢复的，也就意味着数据的不安全。
目前主流的数据销毁方式，是对删除文件所占用的盘空间进行多次多规则的重复擦写。我们知道，由于磁盘可重复使用，前面的数据被后面的数据覆写后，前面的数据被不原的概率就大大降低了，随着被覆写次数的增多，能够被还原的可能性就趋于零。
6. JAVA虚拟机内存分配与回收机制
[转帖] Java 中的堆和栈
简单的说：
Java把内存划分成两种：一种是栈内存，一种是堆内存。
在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。
当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
堆内存用来存放由new创建的对象和数组。
在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。
在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。
引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。
具体的说：
栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等 指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时 动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本 类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
int a = 3;
int b = 3；
编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。这时，如果再令a=4；那么编译器 会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这 种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。
String是一个特殊的包装类数据。可以用：
String str = new String("abc");
String str = "abc";
两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。
而第二种是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”。
比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
可以看出str1和str2是指向同一个对象的。
String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false
用new的方式是生成不同的对象。每一次生成一个。
因此用第二种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已. 这种写法有利与节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。
另一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的 对象。只有通过new()方法才能保证每次都创建一个新的对象。 由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。
java中内存分配策略及堆和栈的比较
2.1 内存分配策略
按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.
静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允 许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求.
栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知 的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知 的栈一样,栈式存储分配按照先进后出的原则进行分配。
静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时 模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释 放.
2.2 堆和栈的比较
上面的定义从编译原理的教材中总结而来,除静态存储分配之外,都显得很呆板和难以理解,下面撇开静态存储分配,集中比较堆和栈:
从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的，栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的:
在编程中，例如C/C++中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶 向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程 序运行时进行的,但是分配的大小多少是确定的,不变的,而这个"大小多少"是在编译时确定的,不是在运行时.
堆是应用程序在运行的时候请求操作系统分配给自己内存，由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间，因此用堆的效率非常低.但是堆的 优点在于,编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面 向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定.在C++中，要求创建一个对象时，只需用 new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存.当然，为达到这种灵活性，必然会付出一定的代价:在堆里分配存储空间时会花 掉更长的时间！这也正是导致我们刚才所说的效率低的原因,看来列宁同志说的好,人的优点往往也是人的缺点,人的缺点往往也是人的优点(晕~).
2.3 JVM中的堆和栈
JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说，它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。
我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译 原理中的活动纪录的概念是差不多的.
从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域，该区域具有先进后出的特性。
每一个Java应用都唯一对应一个JVM实例，每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程 共享.跟C/C++不同，Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在堆栈中分配,也 就是说在建立一个对象时从两个地方都分配内存，在堆中分配的内存实际建立这个对象，而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。
转自:http://www.anyuok.cn/showbbs.asp?bd=22&id=142&totable=1
呵呵,在看到你的问题前10分钟才看的这个文章...
7. 怎么清除内存卡的东西
很多时候，手机内存卡慢慢的满了，但又不知道手机内存卡的内存都用到哪去了？甚至有冲动想直接格式化掉SD卡后重新再来，具体方法如下：
1）首先，点击“设置”进入后点击“存储”。
2）进入“存储”后，往下拉，可以查看到手机可用空间，如果要格式化SD卡，直接点击“格式化SD卡”，最后再确认一次即可。
关于手机怎么格式化SD卡，就为介绍到这里，方法非常简单，另外我们还可以将手机连接上电脑，在电脑上格式化SD卡也相当方便，
最后提醒大家，格式化手机SD卡会清空所有手机数据，格式化前，请注意备份数据，如果勿删与格式化了。
提醒：如没必要的话，可以尝试清除手机中的缓存，释放手机中的内存。
内存卡充当硬盘驱动器、主板和显卡等硬件上的数据与处理器之间的桥梁。
所有电脑数据都是通过内存芯片和处理器传输到处理器上处理的，有些朋友可能会想为什么不直接与处理器，和处理器交换数据呢？
事实上，只要我们知道内存，内存读取速度和存储速度是最快的，直接和主板数据总线交换速度非常慢，
我们也可以看一下内存作为数据缓存区，有一个缓存区，也更有利于计算机数据处理的速度。
但重要的是要注意，很多主板不支持高频率1600 MHZ的记忆，比如很多低价H61主板只能支持高达1333 MHZ的内存，并安装时需要特别看一下主板都支持，
如果您想要使用高频率的内存，主板最好选择芯片组更好，支持高频内存主板，很多的朋友如果你不注意这些，
造成主板不支持高频，高频可以被内存频率降低处理，但这可能会导致内存不稳定或无法启动等等，总之我们需要多加注意了。
8. 顺序表、链表清空和销毁
我正好在学数据结构，以下是我的理解，自以为还比较靠谱。你参考着看吧。
ClearList只是把线性表中原来存储元素的空间中存的那些元素都清除了，类似于把原线性表改成一个空的线性表，但这个线性表是确实存在的。
而Destroy是把整个线性表占的空间都释放了，这个线性表结构都不存在了，下次想做一个线性表只能重新初始化。
下面是我在老师给的课件找到的粗略算法：
顺序表的：
销毁线性表L
void DestroyList(SqList*L)
{
if (L->elem) free(L->elem); //释放线性表占据的所有存储空间
}
清空线性表L
void ClearList(SqList*L)
{
L->length=0; //将线性表的长度置为0
}
链表的：
销毁链表L
void DestoryList(LinkList *L)
{
NODE *p;
while (L->head){ //依次删除链表中的所有结点
p=L->head; L->head=L->head->next;
free(p);
}
}
清空链表L
void ClearList(LinkList *L)
{
NODE *p;
while (L->head->next){
p=L->head->next; //p指向链表中头结点后面的第一个结点
L->head->next=p->next; //删除p结点
free(p); //释放p结点占据的存储空间
}
}
具体的在C环境编程实现的话还要加工下的。
希望能给你点启发！
9. 哪些情况会内存泄漏
1、资源释放问题
。 Android 程序代码的问题，长期保持某些资源，如 Context、Cursor、IO 流的引用，资源得不到释放造成内存泄露。
2、对象内存过大问题
保存了多个耗用内存过大的对象（如 Bitmap、XML 文件），造成内存超出限制。
3、static 关键字的使用问题
static 是 Java 中的一个关键字，当用它来修饰成员变量时，那么该变量就属于该类，而不是该类的实例。所 以用 static 修饰的变量，它的生命周期是很长的，如果用它来引用一些资源耗费过多的实例（Context 的情况最 多），这时就要谨慎对待了。
public class ClassName { private static Context mContext; //省略 }
1
1
以上的代码是很危险的，如果将 Activity 赋值到 mContext 的话。那么即使该 Activity 已经 onDestroy，但是由 于仍有对象保存它的引用，因此该 Activity 依然不会被释放。
我们举 Android 文档中的一个例子。
private static Drawable sBackground;
@Override protected void onCreate(Bundle state) {
super.onCreate(state);
TextView label = new TextView(this); //getApplicationContext label.setText("Leaks are bad");
if (sBackground == null) {
sBackground = getDrawable(R.drawable.large_bitmap);
}
label.setBackgroundDrawable(sBackground); setContentView(label);
}
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
sBackground 是一个静态的变量，但是我们发现，我们并没有显式的保存 Context 的引用，但是，当 Drawable 与 View 连接之后，Drawable 就将 View 设置为一个回调，由于 View 中是包含 Context 的引用的，所以，实际 上我们依然保存了 Context 的引用。这个引用链如下： Drawable->TextView->Context 所以，最终该 Context 也没有得到释放，发生了内存泄露。
针对 static 的解决方案
① 应该尽量避免 static 成员变量引用资源耗费过多的实例，比如 Context。
② Context 尽量使用 ApplicationContext，因为 Application 的 Context 的生命周期比较长，引用它不会 出现内存泄露的问题。 ③ 使用 WeakReference 代替强引用。比如可以使用 WeakReference mContextRef;
4、线程导致内存溢出
线程产生内存泄露的主要原因在于线程生命周期的不可控。我们来考虑下面一段代码。
。
public class MyActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
new MyThread().start();
}
private class MyThread extends Thread{
@Override
public void run() {
super.run(); //do somthing while(true)
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
这段代码很平常也很简单，是我们经常使用的形式。我们思考一个问题：假设 MyThread 的 run 函数是一个很费 时的操作，当我们开启该线程后，将设备的横屏变为了竖屏，一 般情况下当屏幕转换时会重新创建 Activity，按照我 们的想法，老的 Activity 应该会被销毁才对，然而事实上并非如此。 由于我们的线程是 Activity 的内部类，所以 MyThread 中保存了 Activity 的一个引用，当 MyThread 的 run 函 数没有结束时，MyThread 是不会被销毁的，因此它所引用的老的 Activity 也不会被销毁，因此就出现了内存泄露的 问题。有些人喜欢用 Android 提供的 AsyncTask，但事实上 AsyncTask 的问题更加严重，Thread 只有在 run 函数不结 束时才出现这种内存泄露问题，然而 AsyncTask 内部的实现机制是运用了 ThreadPoolExcutor,该类产生的 Thread 对 象的生命周期是不确定的，是应用程序无法控制的，因此如果 AsyncTask 作为 Activity 的内部类，就更容易出现内存 泄露的问题。
针对这种线程导致的内存泄露问题的解决方案：
第一、将线程的内部类，改为静态内部类（因为非静态内部类拥有外部类对象的强引用，而静态类则不拥有）。
第二、在线程内部采用弱引用保存 Context 引用。