㈠ 数据结构在计算机内存中的表示是指什么
数据结构在计算机内存中的表示指的是数据的存储结构。
数据的存储结构是指数据的逻辑结构在计算机中的表示。数据元素之间的关系有两种不同的表示方法：顺序映象和非顺序映象，并由此得到两种不同的存储结构：顺序存储结构和链式存储结构。
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)，如果水平方向填充因子很小，但某些节点下的链表又很长，那值的均匀性就比较差。