线性结构的顺序表实现 Java版

package com.list;

/**
* 顺序表的方法行为接口
* @author liangguojun
*
* @param <T>
*/
public interface SQList<T> {
/**
* 返回顺序表的长度
*
* @return 返回顺序表的长度
*/
public int getLength();

/**
* 插入节点，默认插入的数据放在顺序表的后面，插入的数据不能为空
*
* @param e
*            需要插入的数据结构
* @return 成功插入则返回true否则返回false
*/
public boolean insert(T e);

/**
* 在指定的位置插入数据元素，插入的数据不能为空
*
* @param e
*            需要插入的数据元素
* @param index
*            需要插入的下标值
* @return 成功插入则返回true，否则返回false
*/
public boolean insert(T e, int index);

/**
* 删除数据，成功删除则返回删除的该元素，否则返回null， 默认删除列表第一个出现的元素
*
* @param e
*            需要删除的数据
* @return 返回已经被删除的数据元素，若删除失败则返回null
*/
public T remove(T e);

/**
* 删除指定下标的数据节点，下标删除成功则返回删除的数据，否则返回null
*
* @param index
* @return
*/
public T remove(int index);

/**
* 返回指定下标的数据元素，下标溢出则返回null
*
* @param index
*            指定下标
* @return 返回指定下标的元素
*/
public T getData(int index);

/**
* 返回指定元素的下标，若不存在这个元素则返回-1
*
* @param e
*            指定的数据元素
* @return 返回指定数据元素的下标值
*/
public int getIndex(T e);

/**
* 判断线性表是否为空
*
* @return 线性表为空则返回true，否则返回false
*/
public boolean isEmpty();

/**
* 清空线性表的数据
*/
public void clear();
}

package com.list;
/**
* 数组实现顺序表
* @author liangguojun
*
* @param <T>
*/
public class ArrayList<T> implements SQList<T> {
private int lengtha;
private Object[] data;

/**
* 创建一个大小为size的顺序表
*
* @param size
*            顺序表的大小
*/
public ArrayList(int size) {
lengtha = 0;
data = new Object[size];
}

/**
* 默认的构造函数，创建大小为64的默认的顺序表
*/
public ArrayList() {
this(64);
}

@Override
public int getLength() {
return lengtha;
}

@Override
public boolean insert(T e) {
// 假如插入的时候插入的数据为空，或者数组已经满了，则返回false
if (lengtha >= data.length || e == null)
return false;
// 插入数据
data[lengtha] = e;
lengtha++;
return true;
}

@Override
public boolean insert(T e, int index) {
// 插入的数据不为空，插入的下标为有效值，数组还没满，则插入数据
if (e != null && lengtha < data.length && index <= data.length
&& index >= 0) {
// 把插入地方的数值全部向后移动一位
for (int i = lengtha + 1; i > index; i--) {
data[i] = data[i - 1];
}
// 插入数据
data[index] = e;
// 长度加1
lengtha++;
return true;
}
// 插入失败
return false;
}

@Override
public T remove(T e) {
if (e != null) {
T tmp;
for (int i = 0; i < lengtha; i++) {
tmp = (T) data[i];
if (e.equals(tmp)) {
// 把删除的元素的位置之后的元素向前移动一位
for (int j = i; j < lengtha; j++) {
data[j] = data[j + 1];
}
// 顺序表数据元素减1
lengtha--;
// 返回删除的元素
return tmp;
}
}
}
return null;
}

@Override
public T remove(int index) {
if (index >= 0 && index <= lengtha) {
// 临时变量用来保存删除了的变量。
T tmp = (T) data[index];
// 把删除的元素的位置之后的元素向前移动一位
for (int j = index; j < lengtha; j++) {
data[j] = data[j + 1];
}

// 顺序表数据元素减1
lengtha--;
// 返回删除的元素
return tmp;
}
return null;
}

@Override
public T getData(int index) {
if (index > lengtha || index < 0)
return null;
return (T) data[index];
}

@Override
public int getIndex(T e) {
if (e != null) {
T tmp;
// 遍历顺序表的数据，查找该元素
for (int i = 0; i < lengtha; i++) {
tmp = (T) data[i];
// 如果找到该元素，则返回该元素的下标值
if (e.equals(tmp))
return i;
}
}
return -1;
}

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

@Override
public void clear() {
lengtha = 0;
}

//测试
public static void main(String[] args) {
ArrayList<Long> test = new ArrayList<>();
Long[] t = { 1L, 2L, 3L, 4L, 5L, 2L, 123L, 4L, 52L, 3L, 23L };
for (int i = 0; i < t.length; i++) {
test.insert(t[i]);
}
System.out
.println("数组的长度：" + t.length + "\n顺序表的长度：" + test.getLength());

System.out.println("查找数据值为52的下标：" + test.getIndex(1231321L));
System.out.println("删除数据值为52的下标：" + test.remove(21315L));
System.out.println("删除下标为2的数据元素：" + test.remove(10));
for (int i = 0; i < test.getLength(); i++) {
System.out.print(" " + test.getData(i));
}

System.out.println("\n插入数据：" + test.insert(32L, 9));
test.clear();
for (int i = 0; i < test.getLength(); i++) {
System.out.print(" " + test.getData(i));
}
System.out.println("空吗？" + test.isEmpty());
}
}

package com.list;

/**
* 链表的节点类
*
* @author liangguojun
*
* @param <T>
*            数据类型
*/
public class Node<T> {

private T data;
private Node<T> next;

public Node(T data, Node<T> next) {
this.data = data;
this.next = next;
}

public Node() {
this(null, null);
}

public T getData() {
return data;
}

public void setData(T e) {
data = e;
}

public Node<T> getNext() {
return next;
}

public void setNext(Node<T> next) {
this.next = next;
}
}

package com.list;

/**
* 单链表
* @author liangguojun
*
* @param <T>
*/
public class LinkedList<T> implements SQList<T> {
private Node<T> heard;

/**
* 创建一个单链表
*/
public LinkedList() {
heard = new Node<>();
}

@Override
public int getLength() {
if (heard.getNext() != null) {
// 临时变量
Node<T> tmp = heard.getNext();
// 计算链表的长度
int length = 0;
// 遍历整个单链表
while (tmp != null) {
length++;
tmp = tmp.getNext();
}
return length;

}
return 0;
}

@Override
public boolean insert(T e) {

if (e != null) {
// 默认情况下，插入到链表的最后面一个节点
Node<T> tmp = heard;
// 遍历到最后的节点
while (tmp.getNext() != null) {
tmp = tmp.getNext();
}
// 插入节点
tmp.setNext(new Node<T>(e, null));
return true;
}
return false;
}

@Override
public boolean insert(T e, int index) {
if (e != null && index >= 0) {
Node<T> tmp = heard;
int count = 0;
// 找到需要插入的位置，如果找不到该位置则插入到最后面
while (count < index && tmp.getNext() != null) {
tmp = tmp.getNext();
count++;
}
// 插入数据
tmp.setNext(new Node<T>(e, tmp.getNext()));
return true;
}
return false;
}

@Override
public T remove(T e) {
if (e != null && heard.getNext() != null) {
Node<T> tmp = heard;
Node<T> rem = tmp.getNext();
while (rem != null) {
if (e.equals(rem.getData())) {
tmp.setNext(rem.getNext());
return rem.getData();
}
tmp = rem;
rem = rem.getNext();
}

}
return null;
}

@Override
public T remove(int index) {
if (index >= 0) {
int ind = 0;
Node<T> tmp = heard;
// 定位到要删除的节点的下标值
while (ind != index && tmp.getNext() != null) {

ind++;
tmp = tmp.getNext();
}
// 假如找到该节点，删除它
if (ind == index) {
Node<T> t = tmp.getNext();
tmp.setNext(t.getNext());
return t.getData();
}
}
return null;
}

@Override
public T getData(int index) {
if (index >= 0 && heard.getNext() != null) {
int ind = 0;
Node<T> tmp = heard.getNext();
// 定位到要删除的节点的下标值
while (ind != index && tmp.getNext() != null) {
tmp = tmp.getNext();
ind++;
}
return tmp.getData();
}
return null;
}

@Override
public int getIndex(T e) {
if (e != null && heard.getNext() != null) {
Node<T> tmp = heard.getNext();
int ind = 0;
// 定位该下标
while (tmp != null) {
if (e.equals(tmp.getData()))
return ind;
ind++;
tmp = tmp.getNext();
}
}
return -1;
}

@Override
public boolean isEmpty() {
if (heard.getNext() == null)
return true;
return false;
}

@Override
public void clear() {
heard.setNext(null);
}

public static void main(String[] args) {
LinkedList<Long> test = new LinkedList<>();
Long[] t = { 1L, 2L, 3L, 4L, 5L, 2L, 123L, 4L, 52L, 3L, 23L };
for (int i = 0; i < t.length; i++) {
test.insert(t[i]);
}
for (int i = 0; i < test.getLength(); i++) {
System.out.print(" " + test.getData(i));
}
System.out.println("\n数组的长度：" + t.length + "\n顺序表的长度："
+ test.getLength());
//
System.out.println("查找数据值为52的下标：" + test.getIndex(12332456L));
System.out.println("删除数据值为52的下标：" + test.remove(52L));
System.out.println("删除下标为2的数据元素：" + test.remove(9));
for (int i = 0; i < test.getLength(); i++) {
System.out.print(" " + test.getData(i));
}

System.out.println("\n插入数据：" + test.insert(32L, 2));
test.clear();
for (int i = 0; i < test.getLength(); i++) {
System.out.print(" " + test.getData(i));
}
System.out.println("空吗？" + test.isEmpty());
}
}

package com.list;

/**
* 循环链表类
*
* @author liangguojun
*
* @param <T>
*            使用泛型来表示数据类型
*/
public class CirList<T> implements SQList<T> {
private Node<T> head;

// 循环链表，最后一个节点都指向头节点
public CirList() {
head = new Node<>();
head.setNext(head);
}

@Override
public int getLength() {
if (head.getNext() != head) {
Node<T> tmp = head;
int count = 0;
// 遍历整个循环单链表
while (tmp.getNext() != head) {
count++;
tmp = tmp.getNext();

}
return count;
}
return -1;
}

@Override
public boolean insert(T e) {
if (e != null) {
Node<T> tp = head;
while (tp.getNext() != head) {
tp = tp.getNext();
}
// 插入元素
tp.setNext(new Node<>(e, head));
return true;
}
return false;
}

@Override
public boolean insert(T e, int index) {
if (e != null && index >= 0) {
Node<T> tmp = head;
int ind = -1;
// 查找需要插入的下标值，若找不到则插入链表的最后一个节点之后
while (ind < index && tmp.getNext() != head) {
ind++;
tmp = tmp.getNext();
}
// 插入节点
tmp.setNext(new Node<T>(e, head));
return true;
}
return false;
}

@Override
public T remove(T e) {
if (e != null) {
Node<T> tmp = head;
Node<T> rem = tmp.getNext();
// 查找该元素，有则删除，没有则返回null
while (rem.getNext() != head) {
// 若找到该元素，则删除第一个出现的这个元素
if (e.equals(rem.getData())) {
tmp.setNext(rem.getNext());
return rem.getData();
}
tmp = tmp.getNext();
rem = rem.getNext();
}

}
return null;
}

@Override
public T remove(int index) {
if (index >= 0) {
Node<T> tmp = head;
int in = 0;
while (in < index && tmp.getNext() != head) {
in++;
tmp = tmp.getNext();
}
// 找到并删除指定下标的元素
if (in == index) {
Node<T> t = tmp.getNext();
tmp.setNext(t.getNext());
return t.getData();
}
}
return null;
}

@Override
public T getData(int index) {
if (index >= 0 && head.getNext() != head) {
int ind = 0;
Node<T> tmp = head.getNext();
// 定位到要删除的节点的下标值
while (ind != index && tmp != head) {
tmp = tmp.getNext();
ind++;
}
return tmp.getData();
}
return null;
}

@Override
public int getIndex(T e) {
if (e != null) {
int index = -1;
Node<T> tmp = head;
while (tmp.getNext() != head) {
tmp = tmp.getNext();
index++;
if (e.equals(tmp.getData()))
return index;
}
}
return -1;
}

@Override
public boolean isEmpty() {
if (head.getNext() == head)
return true;
return false;
}

@Override
public void clear() {
head.setNext(head);

}

public static void main(String[] args) {
CirList<Long> test = new CirList<>();
Long[] t = { 1L, 2L, 3L, 4L, 5L, 2L, 123L, 4L, 52L, 3L, 23L };
for (int i = 0; i < t.length; i++) {
test.insert(t[i]);
}
System.out.println("真的么？" + test.getData(10));
for (int i = 0; i < test.getLength(); i++) {
System.out.print(" " + test.getData(i));
}
System.out.println("\n数组的长度：" + t.length + "\n顺序表的长度："
+ test.getLength());
// //
System.out.println("查找数据值为52的下标：" + test.getIndex(52L));
System.out.println("删除数据值为52的下标：" + test.remove(52L));
System.out.println("删除下标为2的数据元素：" + test.remove(2));
for (int i = 0; i < test.getLength(); i++) {
System.out.print(" " + test.getData(i));
}
//
System.out.println("\n插入数据：" + test.insert(32L, 2));
test.clear();
for (int i = 0; i < test.getLength(); i++) {
System.out.print(" " + test.getData(i));
}
System.out.println("空吗？" + test.isEmpty());
}

}

package com.list;

/**
* 双向链表的节点类
* @author liangguojun
*
* @param <T> 数据类型
*/
public class DoubleNode<T> {
private T data;
private DoubleNode<T> next;
private DoubleNode<T> previous;

public DoubleNode(T data, DoubleNode<T> previous, DoubleNode<T> next) {
this.data = data;
this.next = next;
this.previous = previous;
}

public DoubleNode() {
this(null);
}

public DoubleNode(T data) {
this(data, null, null);
}

public void setNext(DoubleNode<T> next) {
this.next = next;
}

public void setPrevious(DoubleNode<T> previous) {
this.previous = previous;
}

public T getData() {
return data;
}

public DoubleNode<T> getNext() {
return next;
}

public DoubleNode<T> getPrevious() {
return previous;
}

public void setData(T data) {
this.data = data;
}
}

package com.list;
/**
* 双向链表
* @author liangguojun
*
* @param <T>
*/
public class DoubleList<T> implements SQList<T> {

private DoubleNode<T> head;

public DoubleList() {
this.head = new DoubleNode<>();
}

@Override
public int getLength() {
if (this.head != null) {
int count = 0;
DoubleNode<T> tmp = head.getNext();
// 遍历双向链表
while (tmp != null) {
count++;
tmp = tmp.getNext();
}
return count;
}
return -1;
}

@Override
public boolean insert(T e) {
if (e != null) {
DoubleNode<T> tmp = head;
while (tmp.getNext() != null) {
tmp = tmp.getNext();
}
// 插入节点
tmp.setNext(new DoubleNode<T>(e, tmp, null));
return true;
}
return false;
}

@Override
public boolean insert(T e, int index) {
if (e != null && index >= 0) {
DoubleNode<T> tmp = head;
int ind = 0;
while (ind < index && tmp.getNext() != null) {
ind++;
tmp = tmp.getNext();
}
// 插入数据
if (ind == index || tmp.getNext() == null) {
DoubleNode<T> p = new DoubleNode<T>(e, tmp, tmp.getNext());
if (tmp.getNext() != null)
tmp.getNext().setPrevious(p);
tmp.setNext(p);
return true;
}

}
return false;
}

@Override
public T remove(T e) {
if (e != null) {
DoubleNode<T> tmp = head;
while (tmp.getData() != e && head.getNext() != null) {
tmp = tmp.getNext();
}
// 删除节点
if (e.equals(tmp.getData())) {
tmp.getNext().setPrevious(tmp.getPrevious());
tmp.getPrevious().setNext(tmp.getNext());
return tmp.getData();
}
}
return null;
}

@Override
public T remove(int index) {
if (index >= 0) {
DoubleNode<T> tmp = head.getNext();
int ind = 0;
while (ind < index && tmp != null) {
tmp = tmp.getNext();
ind++;
}
// 删除节点
if (ind == index) {
if (tmp.getNext() != null)
tmp.getNext().setPrevious(tmp.getPrevious());
tmp.getPrevious().setNext(tmp.getNext());
return tmp.getData();
}

}
return null;
}

@Override
public T getData(int index) {
if (index >= 0) {
DoubleNode<T> tmp = head.getNext();
int ind = 0;
while (ind < index && tmp != null) {
tmp = tmp.getNext();
ind++;
}
// 返回指定下标节点的数据
if (ind == index) {
return tmp.getData();
}

}
return null;
}

@Override
public int getIndex(T e) {
if (e != null) {
DoubleNode<T> tmp = head;
int ind = -1;
while (!e.equals(tmp.getData()) && tmp != null) {
ind++;
tmp = tmp.getNext();
}
if (e.equals(tmp.getData())) {
return ind;
}
}
return -1;
}

@Override
public boolean isEmpty() {
if (head != null) {
return head.getNext() == null ? true : false;
}
return true;
}

@Override
public void clear() {
this.head.setNext(null);
}

//测试用
public static void main(String[] args) {
Long[] test = { 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L };
DoubleList<Long> t = new DoubleList<>();
for (int i = 0; i < test.length; i++) {
t.insert(test[i]);

}
for (int i = 0; i < t.getLength(); i++) {
System.out.print(" " + t.getData(i));
}

System.out.println("\n长度是：" + t.getLength() + "\n数组长度是：" + test.length);
// t.clear();
System.out.println("是否为空？：" + t.isEmpty());
System.out.println("插入数据：" + t.insert(22L, 9));
// System.out.println("删除数据：" + t.remove(9));
System.out.println("删除数据：" + t.remove(1L));
System.out.println("返回下标值" + t.getIndex(5L));
for (int i = 0; i < t.getLength(); i++) {
System.out.print(" " + t.getData(i));
}
}
}