㈠ 數據結構在計算機內存中的表示是指什麼
數據結構在計算機內存中的表示指的是數據的存儲結構。
數據的存儲結構是指數據的邏輯結構在計算機中的表示。數據元素之間的關系有兩種不同的表示方法：順序映象和非順序映象，並由此得到兩種不同的存儲結構：順序存儲結構和鏈式存儲結構。
1、順序存儲方法：
它是把邏輯上相鄰的結點存儲在物理位置相鄰的存儲單元里，結點間的邏輯關系由存儲單元的鄰接關系來體現，由此得到的存儲表示稱為順序存儲結構。順序存儲結構是一種最基本的存儲表示方法，通常藉助於程序設計語言中的數組來實現。
2、鏈接存儲方法：
它不要求邏輯上相鄰的結點在物理位置上亦相鄰，結點間的邏輯關系是由附加的指針欄位表示的。由此得到的存儲表示稱為鏈式存儲結構，鏈式存儲結構通常藉助於程序設計語言中的指針類型來實現。
(1)散列表刪除元素有什麼變化擴展閱讀
順序存儲和鏈接存儲的基本原理：
1、在順序存儲中，每個存儲空間含有所存元素本身的信息，元素之間的邏輯關系是通過數組下標位置簡單計算出來的線性表的順序存儲。
若一個元素存儲在對應數組中的下標位置為i，則它的前驅元素在對應數組中的下標位置為i-1，它的後繼元素在對應數組中的下標位置為i+1。在鏈式存儲結構中，存儲結點不僅含有所存元素本身的信息，而且含有元素之間邏輯關系的信息。
2、數據的鏈式存儲結構可用鏈接表來表示。其中data表示值域，用來存儲節點的數值部分。Pl，p2，…，Pill(1n≥1)均為指針域，每個指針域為其對應的後繼元素或前驅元素所在結點(以後簡稱為後繼結點或前驅結點)的存儲位置。
通過結點的指針域(又稱為鏈域)可以訪問到對應的後繼結點或前驅結點，若一個結點中的某個指針域不需要指向其他結點，則令它的值為空（NULL）。
在數據的順序存儲中，由於每個元素的存儲位置都可以通過簡單計算得到，所以訪問元素的時間都相同；而在數據的鏈接存儲中，由於每個元素的存儲位置保存在它的前驅或後繼結點中，只有當訪問到其前驅結點或後繼結點後才能夠按指針訪問。
㈡ 散列表起什麼作用．請通俗的給出個例子
散列表是一種數據結構，通過散列函數（也就是 hash 函數）將輸入映射到一個數字，一般用映射出的數字作為存儲位置的索引。數組在查找時效率很高，但是插入和刪除卻很低。而鏈表剛好反過來。設計合理的散列函數可以集成鏈表和數組的優點，在查找、插入、刪除時實現 O(1) 的效率。散列表的存儲結構使用的也是數組加鏈表。執行效率對比可以看下圖 1.3：
散列表的主要特點：
將輸入映射到數字
2.不同的輸入產生不同的輸出
3.相同的輸入產生相同的輸出
4. 當填裝因子超過閾值時，能自動擴展。填裝因子 = 散列表包含的元素數 / 位置總數，當填裝因子 =1，即散列表滿的時候，就需要調整散列表的長度，自動擴展的方式是：申請一塊舊存儲容量 X 擴容系數的新內存地址，然後把原內存地址的值通過其中的 key 再次使用 hash 函數計算存儲位置，拷貝到新申請的地址。
5. 值呈均勻分布。這里的均勻指水平方向的，即數組維度的。如果多個值被映射到同一個位置，就產生了沖突，需要用鏈表來存儲多個沖突的鍵值。極端情況是極限沖突，這與一開始就將所有元素存儲到一個鏈表中一樣。這時候查找性能將變為最差的 O(n)，如果水平方向填充因子很小，但某些節點下的鏈表又很長，那值的均勻性就比較差。
㈢ 散列表和二叉樹的優缺點對比，如何在這兩種數據結構中選擇
散列表是一種數據結構，通過散列函數（也就是 hash 函數）將輸入映射到一個數字，一般用映射出的數字作為存儲位置的索引。數組在查找時效率很高，但是插入和刪除卻很低。而鏈表剛好反過來。設計合理的散列函數可以集成鏈表和數組的優點，在查找、插入、刪除時實現 O(1) 的效率。散列表的存儲結構使用的也是數組加鏈表。執行效率對比可以看下圖 1.3：
散列表的主要特點：1.將輸入映射到數字2.不同的輸入產生不同的輸出3.相同的輸入產生相同的輸出4. 當填裝因子超過閾值時，能自動擴展。填裝因子 = 散列表包含的元素數 / 位置總數，當填裝因子 =1，即散列表滿的時候，就需要調整散列表的長度，自動擴展的方式是：申請一塊舊存儲容量 X 擴容系數的新內存地址，然後把原內存地址的值通過其中的 key 再次使用 hash 函數計算存儲位置，拷貝到新申請的地址。5. 值呈均勻分布。這里的均勻指水平方向的，即數組維度的。如果多個值被映射到同一個位置，就產生了沖突，需要用鏈表來存儲多個沖突的鍵值。極端情況是極限沖突，這與一開始就將所有元素存儲到一個鏈表中一樣。這時候查找性能將變為最差的 O(n)，如果水平方向填充因子很小，但某些節點下的鏈表又很長，那值的均勻性就比較差。
㈣ 簡述刪除散列表的某個結點應如何操作
舉個簡單的例子：
有一百個數字1－100，隨機產生20個，求20個不重復的數的和。
例如：1，1，1，1，1，1，1，1，1，1，2，2，3，6，3，2，3，2，3，2
則20個不重復的數的和＝1＋2＋3＋6＝12
main()
{
int num;
while(循環20次)
{
num = GetNumber();//得到一個隨機數字
掃面鏈表；
if(鏈表裡面沒有這個數字)
{
把得到的數字加到鏈表裡；
result＋＝ num；
}
}
}
上面的思想是，每次得到一個數字，讓它和鏈表裡的數字依依比較，如果連表裡面沒有，就把它直接加到連表裡。如果連表裡的東西多了的話，那麼就要比較很多次，很浪費時間。
如果用哈西表的話，就可以通過查找表，一次就確定數字是否重復：
main()
{
int num;
int hash[101];//初始化都等於0
while(循環20次)
{
num = GetNumber();//得到一個隨機數字
if(hash[num]==0)
{
hash[num]=1；
result＋＝ num；
}
}
}
㈤ 數據結構 散列表
散列表是一種數據結構，通過散列函數（也就是 hash 函數）將輸入映射到一個數字，一般用映射出的數字作為存儲位置的索引。數組在查找時效率很高，但是插入和刪除卻很低。而鏈表剛好反過來。設計合理的散列函數可以集成鏈表和數組的優點，在查找、插入、刪除時實現 O(1) 的效率。散列表的存儲結構使用的也是數組加鏈表。執行效率對比可以看下圖 1.3：
散列表的主要特點：1.將輸入映射到數字2.不同的輸入產生不同的輸出3.相同的輸入產生相同的輸出4. 當填裝因子超過閾值時，能自動擴展。填裝因子 = 散列表包含的元素數 / 位置總數，當填裝因子 =1，即散列表滿的時候，就需要調整散列表的長度，自動擴展的方式是：申請一塊舊存儲容量 X 擴容系數的新內存地址，然後把原內存地址的值通過其中的 key 再次使用 hash 函數計算存儲位置，拷貝到新申請的地址。5. 值呈均勻分布。這里的均勻指水平方向的，即數組維度的。如果多個值被映射到同一個位置，就產生了沖突，需要用鏈表來存儲多個沖突的鍵值。極端情況是極限沖突，這與一開始就將所有元素存儲到一個鏈表中一樣。這時候查找性能將變為最差的 O(n)，如果水平方向填充因子很小，但某些節點下的鏈表又很長，那值的均勻性就比較差。
㈥ 關於散列表，散列函數的兩個問題。
散列表是一種數據結構，通過散列函數（也就是 hash 函數）將輸入映射到一個數字，一般用映射出的數字作為存儲位置的索引。數組在查找時效率很高，但是插入和刪除卻很低。而鏈表剛好反過來。設計合理的散列函數可以集成鏈表和數組的優點，在查找、插入、刪除時實現 O(1) 的效率。散列表的存儲結構使用的也是數組加鏈表。執行效率對比可以看下圖 1.3：
散列表的主要特點：
將輸入映射到數字
2.不同的輸入產生不同的輸出
3.相同的輸入產生相同的輸出
4. 當填裝因子超過閾值時，能自動擴展。填裝因子 = 散列表包含的元素數 / 位置總數，當填裝因子 =1，即散列表滿的時候，就需要調整散列表的長度，自動擴展的方式是：申請一塊舊存儲容量 X 擴容系數的新內存地址，然後把原內存地址的值通過其中的 key 再次使用 hash 函數計算存儲位置，拷貝到新申請的地址。
5. 值呈均勻分布。這里的均勻指水平方向的，即數組維度的。如果多個值被映射到同一個位置，就產生了沖突，需要用鏈表來存儲多個沖突的鍵值。極端情況是極限沖突，這與一開始就將所有元素存儲到一個鏈表中一樣。這時候查找性能將變為最差的 O(n)，如果水平方向填充因子很小，但某些節點下的鏈表又很長，那值的均勻性就比較差。
㈦ 散列查找的散列表的運算
設用HashMaxSize常量表示待定義的散列表類型的長度。假定採用開放定址法,其散列表類型用hashlist1表示,類型定義為：
typedef ElemType hashlist1[HashMaxSize];
若採用鏈接表，其散列表類型用hashlist2表示
Lnode 定義如下：
struct Lnode
{
ElemType data;
Lnode *next;
}
在類型為hashlist1的散列表上進行的運算
初始化散列表
void InitHashList (hashlist1 HT)
{
//把散列表HT中每一單元的關鍵字key域都置空
for(int i=0;i<HashMaxSize;i++)
HT[i].key=NullTag; //NullTag常量表示空標志，
}
清空一個散列表
void ClearHashList (hashlist1 HT)
{
//把散列表HT中每一單元的關鍵字key域都置空
for(int i=0;i<HashMaxSize;i++)
HT[i].key=NullTag;
}
向散列表中插入一個元素
int Insert (hashlist1 HT,int m,ElemType item)
{
//向長度為m的散列表HT中插入一個元素item
int d=H(item.key,m);
int temp=d;
while(HT[d].key != NullTag)
{
//當d單元不空時繼續向後查找空位置
d=(d+1)%m;
if(d==temp) return 0;
}
HT[d]=item; //將新元素插入到下標為d的位置
return 1;
} //返回1表示插入成功
從散列表中查找一個元素
int Search (hashlist1 HT,int m, ElemType item)
{
//從長度為m的散列表HT中查找關鍵字為item.key的一個元素
int d=H(item.key, m);
int temp=d;
while(HT[d].key!=NullTag)
{
//當散列地址中的關鍵字域不為空則循環
if(HT[d].key==item.key) return d; //查找成功則反回下標d
else d=(d+1)%m;
if(d==temp) return -1; //查找失敗反回-1
}
return -1;
}
從散列表中刪除一個元素
int Delete (hashlist1 HT,int m, ElemType item)
{
//從長度為m的散列表HT中刪除關鍵字為item.key的一個元素
int d=H(item.key, m);
int temp=d;
while(HT[d].key!=NullTag)
{
if(HT[d].key==item.key)
{
HT[d].key=DeleteTag;//DeleteTag常量為一刪除標記
return 1;
}
else d=(d+1)%m; //繼續向後探查
if(d==temp) return 0;
}
return 0; //刪除失敗返回0
}
在類型為hashlist2的散列表上進行的運算
類型定義：
struct Lnode
{
ElemType data;
Lnode *next;
}
typedef LNode * hashlist2[HashMaxSize];
初始化散列表
void InitHashList(hashlist2 HT)
{
//把散列表HT中每一元素均置為空標志
for(int i=0;i<HashMaxSize;i++)
HT[i].i=NULL;
}
清空一個散列表
void ClearHashList(hashlist2 HT)
{
//清除HT散列表,即回收每個單鏈表中的結點
LNode * p;
for(int i=0;i<HashMaxSize;i++)
{
p=HT[i];
while(p!=NULL)
{
HT[i]=p->next;
delete p;
p=HT[i];
}
}
}
向散列表中插入一個元素
int Insert(hashlist2 HT,int m,ElemType item)
{
//向長度為m的帶連接的散列表HT中插入一個元素item
int d=Hash(item.key,m);
LNode *p=new LNode;//為新元素分配存儲結點
if(p==NULL) return0;
p->data=item;//把新結點插入到d單鏈表的表頭
p->next=HT[d];
HT[d]=p;
return 1;
}
從散列表中查找一個元素
ElemType* Search(hashlist2 HT,int m,ElemType item)
{
//從長度為m的帶鏈接的散列表HT中查找元素
int d=Hash(item.key,m);
LNode* p=HT[d];
while(p!=NULL)
{
if(p->data.key==item.key) return &(p->data);
else p=p->next;
}
return NULL; //查找失敗返回空指針
}
從散列表中刪除一個元素
int Delete(hashlist2 HT,int m,ElemType item)
{
//從長度為m的帶鏈接的散列表HT中刪除元素
int d=Hash(item.kye,m);
LNode* p=HT[d],* q;
if (p==NULL) return 0;
if (p->data.key==item.key)
{
HT[d]=p->next;
delete p;
return 1;
}
//從第二個結點起查找被刪除的元素
q=p->next;
while(q!=NULL)
{
if(q->data.key)==item.key）
{
p->next=q->next;
delete q;
return 1;
}
else
{
p=q;q=q->next;
}
}
//返回0表示刪除失敗;
return 0;
}
㈧ List 、Set、 Map有什麼區別和聯系
1、List介面對Collection進行了簡單的擴充，它的具體實現類常用的有ArrayList和LinkedList。
你可以將任何東西放到一個List容器中，並在需要時從中取出。ArrayList從其命名中可以看出它是一種類似數組的形式進行存儲，因此它的隨機訪問速度極快，而LinkedList的內部實現是鏈表，它適合於在鏈表中間需要頻繁進行插入和刪除操作。在具體應用時可以根據需要自由選擇。
前面說的Iterator只能對容器進行向前遍歷，而ListIterator則繼承了Iterator的思想，並提供了對List進行雙向遍歷的方法。
2、Set介面也是Collection的一種擴展，而與List不同的時，在Set中的對象元素不能重復，也就是說你不能把同樣的東西兩次放入同一個Set容器中。它的常用具體實現有HashSet和TreeSet類。
HashSet能快速定位一個元素，但是你放到HashSet中的對象需要實現hashCode()方法，它使用了前面說過的哈希碼的演算法。而TreeSet則將放入其中的元素按序存放，這就要求你放入其中的對象是可排序的，這就用到了集合框架提供的另外兩個實用類Comparable和Comparator。
一個類是可排序的，它就應該實現Comparable介面。有時多個類具有相同的排序演算法，那就不需要在每分別重復定義相同的排序演算法，只要實現Comparator介面即可。
集合框架中還有兩個很實用的公用類：Collections和Arrays。Collections提供了對一個Collection容器進行諸如排序、復制、查找和填充等一些非常有用的方法，Arrays則是對一個數組進行類似的操作。
3、Map是一種把鍵對象和值對象進行關聯的容器，而一個值對象又可以是一個Map，依次類推，這樣就可形成一個多級映射。
對於鍵對象來說，像Set一樣，一個Map容器中的鍵對象不允許重復，這是為了保持查找結果的一致性;如果有兩個鍵對象一樣，那你想得到那個鍵對象所對應的值對象時就有問題了，可能你得到的並不是你想的那個值對象，結果會造成混亂，所以鍵的唯一性很重要，也是符合集合的性質的。
當然在使用過程中，某個鍵所對應的值對象可能會發生變化，這時會按照最後一次修改的值對象與鍵對應。對於值對象則沒有唯一性的要求。你可以將任意多個鍵都映射到一個值對象上，這不會發生任何問題（不過對你的使用卻可能會造成不便，你不知道你得到的到底是那一個鍵所對應的值對象）。
Map有兩種比較常用的實現：HashMap和TreeMap。HashMap也用到了哈希碼的演算法，以便快速查找一個鍵，TreeMap則是對鍵按序存放，因此它便有一些擴展的方法，比如firstKey(),lastKey()等，你還可以從TreeMap中指定一個范圍以取得其子Map。
鍵和值的關聯很簡單，用pub(Object key,Object value)方法即可將一個鍵與一個值對象相關聯。用get(Object key)可得到與此key對象所對應的值對象
(8)散列表刪除元素有什麼變化擴展閱讀：
解疑：
1、什麼是Iterator
一些集合類提供了內容遍歷的功能，通過java.util.Iterator介面。這些介面允許遍歷對象的集合。依次操作每個元素對象。當使用 Iterators時，在獲得Iterator的時候包含一個集合快照。通常在遍歷一個Iterator的時候不建議修改集合本省。
2、Iterator與ListIterator有什麼區別？
Iterator：只能正向遍歷集合，適用於獲取移除元素。ListIerator：繼承Iterator，可以雙向列表的遍歷，同樣支持元素的修改。
3、什麼是HaspMap和Map？
Map是介面，Java 集合框架中一部分，用於存儲鍵值對，HashMap是用哈希演算法實現Map的類。
4、HashMap與HashTable有什麼區別？對比Hashtable VS HashMap
兩者都是用key-value方式獲取數據。Hashtable是原始集合類之一（也稱作遺留類）。HashMap作為新集合框架的一部分在Java2的1.2版本中加入。它們之間有一下區別：
● HashMap和Hashtable大致是等同的，除了非同步和空值（HashMap允許null值作為key和value，而Hashtable不可以）。
● HashMap沒法保證映射的順序一直不變，但是作為HashMap的子類LinkedHashMap，如果想要預知的順序迭代（默認按照插入順序），你可以很輕易的置換為HashMap，如果使用Hashtable就沒那麼容易了。
● HashMap不是同步的，而Hashtable是同步的。
● 迭代HashMap採用快速失敗機制，而Hashtable不是，所以這是設計的考慮點。
5、在Hashtable上下文中同步是什麼意思？
同步意味著在一個時間點只能有一個線程可以修改哈希表，任何線程在執行hashtable的更新操作前需要獲取對象鎖，其他線程等待鎖的釋放。
6、什麼叫做快速失敗特性
從高級別層次來說快速失敗是一個系統或軟體對於其故障做出的響應。一個快速失敗系統設計用來即時報告可能會導致失敗的任何故障情況，它通常用來停止正常的操作而不是嘗試繼續做可能有缺陷的工作。當有問題發生時，快速失敗系統即時可見地發錯錯誤告警。
在Java中，快速失敗與iterators有關。如果一個iterator在集合對象上創建了，其它線程欲「結構化」的修改該集合對象，並發修改異常 （） 拋出。
7、怎樣使Hashmap同步？
HashMap可以通過Map m = Collections.synchronizedMap（hashMap）來達到同步的效果。
8、什麼時候使用Hashtable，什麼時候使用HashMap
基本的不同點是Hashtable同步HashMap不是的，所以無論什麼時候有多個線程訪問相同實例的可能時，就應該使用Hashtable，反之使用HashMap。非線程安全的數據結構能帶來更好的性能。
如果在將來有一種可能—你需要按順序獲得鍵值對的方案時，HashMap是一個很好的選擇，因為有HashMap的一個子類 LinkedHashMap。所以如果你想可預測的按順序迭代（默認按插入的順序），你可以很方便用LinkedHashMap替換HashMap。
反觀要是使用的Hashtable就沒那麼簡單了。同時如果有多個線程訪問HashMap，Collections.synchronizedMap（）可以代替，總的來說HashMap更靈活。
9、為什麼Vector類認為是廢棄的或者是非官方地不推薦使用？或者說為什麼我們應該一直使用ArrayList而不是Vector
你應該使用ArrayList而不是Vector是因為默認情況下你是非同步訪問的，Vector同步了每個方法，你幾乎從不要那樣做，通常有想要同步的是整個操作序列。同步單個的操作也不安全（如果你迭代一個Vector，你還是要加鎖，以避免其它線程在同一時刻改變集合）。
而且效率更慢。當然同樣有鎖的開銷即使你不需要，這是個很糟糕的方法在默認情況下同步訪問。你可以一直使用Collections.sychronizedList來裝飾一個集合。
事實上Vector結合了「可變數組」的集合和同步每個操作的實現。這是另外一個設計上的缺陷。Vector還有些遺留的方法在枚舉和元素獲取的方法，這些方法不同於List介面，如果這些方法在代碼中程序員更趨向於想用它。
盡管枚舉速度更快，但是他們不能檢查如果集合在迭代的時候修改了，這樣將導致問題。盡管以上諸多原因，Oracle也從沒宣稱過要廢棄Vector。
㈨ Excel刪除圖表中的某個數據系列，則產生此圖表系列的原始數據有什麼變化
1、首先在電腦中打開excel工作簿，選中單元格內容，選擇插入-柱形圖-二維柱形圖，如圖所示。
㈩ 哈希表有什麼好處
散列表是一種數據結構，通過散列函數（也就是 hash 函數）將輸入映射到一個數字，一般用映射出的數字作為存儲位置的索引。數組在查找時效率很高，但是插入和刪除卻很低。而鏈表剛好反過來。設計合理的散列函數可以集成鏈表和數組的優點，在查找、插入、刪除時實現 O(1) 的效率。散列表的存儲結構使用的也是數組加鏈表。執行效率對比可以看下圖 1.3：
散列表的主要特點：
1.將輸入映射到數字
2.不同的輸入產生不同的輸出
3.相同的輸入產生相同的輸出
4. 當填裝因子超過閾值時，能自動擴展。填裝因子 = 散列表包含的元素數 / 位置總數，當填裝因子 =1，即散列表滿的時候，就需要調整散列表的長度，自動擴展的方式是：申請一塊舊存儲容量 X 擴容系數的新內存地址，然後把原內存地址的值通過其中的 key 再次使用 hash 函數計算存儲位置，拷貝到新申請的地址。
5. 值呈均勻分布。這里的均勻指水平方向的，即數組維度的。如果多個值被映射到同一個位置，就產生了沖突，需要用鏈表來存儲多個沖突的鍵值。極端情況是極限沖突，這與一開始就將所有元素存儲到一個鏈表中一樣。這時候查找性能將變為最差的 O(n)，如果水平方向填充因子很小，但某些節點下的鏈表又很長，那值的均勻性就比較差。