链表-顺序存储-Java实现

package com.wrh.lab.dataStructure.linearList;
/**
*
* @author wrh
* the interface of linear list.
*
*/
public interface LinearList<E> {

/**
* identify whether the list is empty or not
* @return true for empty and false for not empty
*/
public boolean isEmpty();

/**
* get the length of the list
* @return the length of the list
*/
public int getLength();

/**
* return the element in  index
* @param index
* @return the element in index
*/
public E get(int index);

/**
*
* @param index
* @param element
* @return the former element
*/
public E set(int index, E element);

/**
* add element after the index
* @param index
* @param element
* @return true for add element success and false for add fail
*/
public boolean add(int index, E element);

/**
* add the element at the end of the list
* @param element
* @return true for success and false for fail
*/
public boolean addLast(E element);

/**
* remove the element at index and return this element
* @param index
* @return
*/
public E remove(int index);

/**
* show the elements in the list
* @return
*/
public void display();

/**
* clear the list
*/
public void clear();
}

package com.wrh.lab.dataStructure.linearList.impl;

import com.wrh.lab.dataStructure.linearList.LinearList;

public class LinearListImpl<E> implements LinearList<E> {

private E[] entry;     //store the element
private int length;    //the length of the linear list
private static final int MAX_SIZE = 50;

// constructor
public LinearListImpl(){}

//constructor
public LinearListImpl(E[] entry){
this.entry = entry;
this.length = entry.length;
}

@Override
public boolean isEmpty() {
boolean isEmpty = false;
if (length == 0){
isEmpty = true;
} else {
isEmpty = false;
}
return isEmpty;
}

@Override
public int getLength() {
return this.length;
}

@Override
public E get(int index) {
if (length > index) {
return entry[index];
} else {
return null;
}
}

@Override
public E set(int index, E element) {
if (length > index) {
E e = entry[index];
entry[index] = element;
return e;
} else {
return null;
}
}

@Override
public boolean add(int index, E element) {
boolean isSuc = false;
if (length > index && length < MAX_SIZE) {
resizeList(entry);
int newPos = index + 1;
for (int i = length; i > newPos; i--) {
entry[i] = entry[i - 1];
}
entry[newPos] = element;
length +=1;
isSuc = true;
} else {
isSuc = false;
}
return isSuc;
}

@Override
public boolean addLast(E element) {
boolean isSuc = false;
if (length < MAX_SIZE) {
resizeList(entry);
entry[length] = element;
length += 1;
isSuc = true;
} else {
isSuc = false;
}
return isSuc;
}

@Override
public E remove(int index) {
if (length > 0) {
E e = entry[index];
for (int i = index; i < length -1; i ++) {
entry[i] = entry[i + 1];
}
length -= 1;
return e;
} else {
return null;
}
}

@Override
public void clear() {
entry = null;
length = 0;
}

@Override
public void display() {
if (length > 0 && length < MAX_SIZE) {
for(int i = 0; i < length; i++) {
System.out.print(entry[i] + " ");
}
} else {
System.out.println("null");
}

}

/**
* resize the list
* @param entry
*/
public void resizeList(E[] entry) {
int resize = length + 1;
Object[] seqList_upp = new Object[resize];
System.arraycopy(entry,0,seqList_upp,0,length);
this.entry = (E[]) seqList_upp;
}

//test the list
public static void main(String[] args) {
Integer[] a = {0,1,2,3,4,5,6,7,8,9};
LinearList<Integer> l = new LinearListImpl<Integer>(a);
System.out.println(l.getLength());
System.out.println(l.get(8));
l.display();
System.out.println();
l.add(3, 12);
System.out.println(l.getLength());
l.remove(2);
System.out.println(l.getLength());
l.display();
l.clear();
System.out.println();
l.display();
}

}