C++中有析构函数，用于销毁对象时释放内存，而Java中因为有gc（垃圾回收机制）所以就没有析构函数，但是java有finalize() 方法，两者的用途相近。
具体请参考链接：http://blog.csdn.net/jemasw/article/details/8470480
什么是线性表？
官方定义：线性表是n个数据元素的有限序列
顺序表和链表互为补充；
定义解读：n个（个数），元素（可以是复杂元素对象，也可以是单个数据），有限（有限的），序列（是一个序列集合）
线性表分为两大类：数组和链表
顺序表
前驱：指定元素前一个元素
后继：指定元素的后一个元素
优点：可以通过下标遍历寻址，所以遍历和寻址极为快速。
缺点：插入和删除元素，因为要移动后面的所有元素，所以较为缓慢。
链表
单链表：
单链表，每个节点分为两部分，分别为 数据域 和 指针域
initChainList(); 初始化链表
void destroyList(); 销毁链表，废弃
boolean isListEmpty(); 判断链表是否为空
int listLength(); 获取链表的长度
void clearList(); 清空链表的所有元素
Node listInsertHead(Node node); 插入头节点
Node listInsertTail(Node node); 插入尾节点
Node insertElement(int i, Node node); 指定位置插入节点
Node deleteElement(int i); 删除指定节点
Node getElement(int i); 获取指定位置节点
int elementLocate(Node node); 获取指定节点所在的位置
Node priorElement(Node node); 找到指定节点的前驱
Node nextElement(Node node); 找到指定节点的后继
void listTraverse(); 遍历链表
循环链表
简单的说，就是首尾相连的单链表即尾节点的指针域指向首节点的位置
双向链表
双向链表，每个节点分为三部分，分别为：
前指针域：顺向指向下一个节点的位置
数据域：数据节点
后指针域：逆向指向下一个节点的位置
静态链表
此处附上顺序表的创建代码：
package util;
public class MyList {
//线性表本身
private Object myList[];
//线性表的大小，即最大容量
private int listSize;
//线性表的长度，即线性表中的元素个数
private int myLength;
public MyList() {
super();
}
/**
* 初始化线性表 - 顺序表
* @param size
*/
public MyList(int size) {
listSize = size;
//申请线性表内存
myList = new Object[listSize];
myLength = 0;
}
/**
* 销毁线性表
*/
public void DestroyList(){
myList = null;
}
/**
* 清空线性表元素
*/
public void clearList(){
myLength = 0;
}
/**
* 判断线性表是否为空
* @return
*/
public boolean isListEmpty(){
return myLength == 0 ? true : false;
}
/**
* 获取线性表的元素个数
* @return
*/
public int listLength(){
return myLength;
}
/**
* 获取下标位置的元素
*/
public Object getElement(int i)
{
//需要将i入参进行一定的限制，因为元素存在的位置坐标仅限于0到线性表的个数减一（即0~myLength-1），所以如果i小于0或者i大于等于线性表的长度都判定为获取失败返回null
if(i < 0 || i >= myLength){
return null;
}
return myList[i];
}
/**
* 获取线性表中元素所在的位置（只获取第一个遇到的位置）
* @param element
* @return
*/
public int elementLocate(Object element){
for (int i = 0; i <= myLength; i++){
if (element.equals(myList[i]))
{
return i;
}
}
return -1;
}
/**
* 获取指定元素前驱
* @param element
* @return
*/
public Object priorElement(Object element){
int i = elementLocate(element);
if(i == -1){
//如果i==-1那么则表示当前线性表中没有找到元素，所以直接判定失败，返回null
return null;
}else if(i == 0){
//如果i==0则该元素本身就是第一个元素，前面不可能再有前驱，所以返回null
return null;
}else{
return myList[i - 1];
}
}
/**
* 获取指定元素后缀
* @param element
* @return
*/
public Object nextElement(Object element){
int i = elementLocate(element);
if(i == -1){
return null;
}else if(i == myLength-1){
return null;
}else{
return myList[i + 1];
}
}
/**
* 在指定位置插入元素
* @param i
* @param element
* @return
*/
public Object insertElement(int i, Object element)
{
if(i < 0 || i > myLength)
{
return null;
}
//此处注意要从后向前依次将i后面的元素向后移位
for (int j = myLength-1; j >= i; j--){
//依次把前面的元素向后移位
myList[j + 1] = myList[j];
}
myList[i] = element;
myLength++;
return element;
}
/**
* 删除指定位置元素
* @param i
* @return
*/
public Object deleteElement(int i){
if (i < 0 || i >= myLength){
return null;
}
Object element = myList[i];
//此处注意要从前向后依次将i后面的元素向后移位,不用单独执行删除操作，因为在移位的过程中已经把i坐标的元素给覆盖了
for (int j = i + 1; j < myLength; j++){
//依次把后面的元素向前移位
myList[j - 1] = myList[j];
}
myLength--;
return element;
}
/**
* 遍历线性表中的元素
*/
public void listTraverse(){
for (int i = 0; i <= myLength-1; i++){
System.out.println(myList[i].toString());
}
}
}
此处附上链表的结构代码：
package util;
import test.entity.Node;
public class MyChainList {
private Node myChainList;
private int listLength;
/**
* 初始化链表
*/
public MyChainList() {
//申请节点内存
myChainList = new Node();
myChainList.data = null;
myChainList.next = null;
listLength = 0;
}
/**
* 销毁链表，废弃
*/
public void destroyList(){
clearList();
myChainList = null;
}
/**
* 判断链表是否为空
* @return
*/
public boolean isListEmpty(){
return 0 == listLength ? true :false;
}
/**
* 获取链表的长度
* @return
*/
public int listLength(){
return listLength;
}
/**
* 清空链表的所有元素
*/
public void clearList(){
Node currentNode = myChainList;
//初始节点的下一个节点，为第一个节点，找到第一个节点判断是否为空
while(null != currentNode.next){
Node temp = currentNode.next;
//将当前节点删除
currentNode = null;
//查找下一个节点
currentNode = temp;
}
currentNode.data = null;
currentNode.next = null;
listLength = 0;
}
/**
* 插入头节点
* @param node
* @return
*/
public Node listInsertHead(Node node){
//将第一个元素指向的下一个节点，存放备用
Node temp = myChainList.next;
//从堆内存中申请空间，将数据放入内存
Node newNode = new Node();
if(null == newNode){
return null;
}
newNode.data = node.data;
//让新的节点指向，第一个节点原指向的节点
newNode.next = temp;
//将node节点放入第一个节点的后面
myChainList.next = newNode;
listLength ++;
return newNode;
}
/**
* 插入尾节点
* @param node
* @return
*/
public Node listInsertTail(Node node){
Node currentNode = myChainList;
//重第一个节点开始循环查找下一个节点，知道找到尾节点
while(null != currentNode.next)
{
currentNode = currentNode.next;
}
//从堆内存中申请空间，将数据放入内存
Node newNode = new Node();
if(null == newNode){
return null;
}
newNode.data = node.data;
newNode.next = null;
//将新节点插入尾节点的后面
currentNode.next = newNode;
listLength ++;
return newNode;
}
/**
* 指定位置插入节点
* @param i
* @param node
* @return
*/
public Node insertElement(int i, Node node){
//判断i是否合法
if (i < 0 || i > listLength){
return null;
}
//遍历节点找到 i 位置的上一个节点
Node currentNode = myChainList;
for (int j = 0; j < i; j++){
currentNode = currentNode.next;
}
Node newNode = new Node();
if (null == newNode){
return null;
}
newNode.data = node.data;
//将原位于i位置的节点放入新节点的后面
newNode.next = currentNode.next;
//将新节点，放入i上一个节点的后面
currentNode.next = newNode;
listLength ++;
return newNode;
}
/**
* 删除指定节点
* @param i
* @return
*/
public Node deleteElement(int i){
if (i < 0 || i >= listLength){
return null;
}
//找到第i个节点，和i的上一个节点
Node currentNode = myChainList;
Node currentNodeBefore = null;
for (int j = 0; j <= i; j++){
currentNodeBefore = currentNode;
currentNode = currentNode.next;
}
//将i位置后面的节点，放在i前面节点的后面
currentNodeBefore.next = currentNode.next;
Node temp = currentNode;
currentNode = null;
listLength --;
return temp;
}
/**
* 获取指定位置节点
* @param i
* @return
*/
public Node getElement(int i){
//过滤i的合理范围
if (i < 0 || i >= listLength){
return null;
}
// 找到第i个节点
Node currentNode = myChainList;
for (int j = 0; j <= i; j++){
currentNode = currentNode.next;
}
return currentNode;
}
/**
* 获取指定节点所在的位置
* @param node
* @return
*/
public int elementLocate(Node node){
//循环查找所有节点
Node currentNode = myChainList;
int count = 0;
while(null != currentNode.next){
currentNode = currentNode.next;
//找到链表中第一个与指定节点匹配的节点
if (currentNode.data.equals(node.data)){
//返回当前循环的次数
return count;
}
//每执行一次表示当前位置没有匹配的节点，注意不能放在if前面
count++;
}
return -1;
}
/**
* 找到指定节点的前驱
* @param node
* @return
*/
public Node priorElement(Node node){
//找到 指定节点 和 指定节点的 上一个节点
Node currentNode = myChainList;
Node currentNodeBefore = null;
while(null != currentNode.next){
currentNodeBefore = currentNode;
currentNode = currentNode.next;
//匹配到了第一个与指定节点相同的节点
if (node.data.equals(currentNode.data)){
//如果找到的对象是线性表中的第一个元素，那么他就没有前驱，返回null
if (currentNodeBefore.equals(myChainList)){
return null;
}
return currentNodeBefore;
}
}
return null;
}
/**
* 找到指定节点的后继
* @param node
* @return
*/
public Node nextElement(Node node){
//遍历线性表，找到指定节点
Node currentNode = myChainList;
while(null != currentNode.next){
currentNode = currentNode.next;
//如果找到了元素
if (currentNode.data.equals(node.data)){
//判断该元素是否为线性表中的最后一个元素，最后一个元素没有后缀，直接返回null
if (currentNode.next == null){
return null;
}
return currentNode.next;
}
}
return null;
}
/**
* 遍历链表
*/
public void listTraverse(){
//遍历链表中的所有元素，依次打印出他们的 数据域
Node currentNode = myChainList;
while(null != currentNode.next){
currentNode = currentNode.next;
currentNode.printNode();
}
}
}