銷毀存儲空間

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 引用。