Java实现数据结构----线性表，单链表
线性表
线性表是n个类型相同的数据元素的有限序列，通常记作（a0,a1,a2…an）、
特点：
- 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
- 线性结构有两种不同存储结构，即，顺序结构（数组）和链式结构（链表），顺序存储的线性表为顺序表，顺序表中的存储元素是连续的
- 链式存储的现行表成为链表，链表中的储存元素不一定是连续的，元素节点中存放的数据元素以及相邻元素的地址信息
接口信息
public interface Liner {
//获取表大小，即数据元素的个数
public int size();
//判断是否为空
public boolean isEmpty();
//获取
public Object get(int i);
//判断线性表是否包括数据元素obj
public boolean contains(Object obj);
//返回数据元素obj在线性表中的序号
public int indexOf(Object obj);
//将元素obj插入到线性表末尾
public void add(Object index);
//将元素obj插入到index位置
public void add(int index,Object obj);
//删除序号为index的元素
public Object remove(int index) ;
}
自定义异常
public class MyArrayIndexOutOfBoundsException extends RuntimeException{
public MyArrayIndexOutOfBoundsException() {
super();
// TODO Auto-generated constructor stub
}
public MyArrayIndexOutOfBoundsException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
}
实现类
import java.util.ArrayList;
import java.util.Arrays;
public class LinerTable implements Liner {
private Object[] elementData;// 底层是个数组，目前未分配长度
private int size;// 不是数组分配的空间，是元素的个数
public LinerTable() {
// 没有指定长度，默认长度4
this(4);
// 没有指定长度，长度是0
// elementData =new Object[]{};
}
/**
* @param initialCapacity
* 指定数组的初始长度
*/
public LinerTable(int initialCapacity) {
// 给数组分配指定的数量的空间
elementData = new Object[initialCapacity];
// 指定顺序表的元素个数
//
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public Object get(int i) {
if (i < 0 || i >= size) {
throw new MyArrayIndexOutOfBoundsException("数组索引越界异常" + i);
}
return elementData[i];
}
public boolean contains(Object obj) {
if (isEmpty()) {
return false;
}
for (int i = 0; i < size; i++) {
if (obj.equals(elementData[i])) {
return true;
}
}
return false;
}
public int indexOf(Object obj) {
for (int i = 0; i < size; i++) {
if (obj.equals(elementData[i])) {
return i;
}
}
return -1;
}
public void add(Object index) {
// 数组满了，扩容
if (size == elementData.length) {
// 船舰一个新的数组，长度旧数组长度的2 倍
Object[] newArr = new Object[elementData.length * 2];
// 将就数组的数据拷贝到新数组
for (int i = 0; i < size; i++) {
newArr[i] = elementData[i];
}
// 让elementData指向新数组
elementData = Arrays.copyOf(elementData, elementData.length * 2);
}
// 给数组赋值
elementData[size] = index;
// 元素加一
size++;
}
public void add(int index, Object obj) {
if (index < 0 || index > size) {
throw new MyArrayIndexOutOfBoundsException("数组索引越界异常" + index);
}
// 数组满了，扩容
if (size == elementData.length) {
// 船舰一个新的数组，长度旧数组长度的2 倍
Object[] newArr = new Object[elementData.length * 2];
// 将就数组的数据拷贝到新数组
for (int i = 0; i < size; i++) {
newArr[i] = elementData[i];
}
// 让elementData指向新数组
elementData = Arrays.copyOf(elementData, elementData.length * 2);
}
// 后裔index及其后面的元素，从最后一个元素开始
for (int j = size; j > index; j--) {
elementData[j] = elementData[j - 1];
}
// 给数组第index位置赋值
elementData[index] = obj;
size++;
}
public Object remove(int index) {
if (index < 0 || index > size) {
throw new MyArrayIndexOutOfBoundsException("数组索引越界异常" + index);
}
return elementData[index];
}
}
测试类
import java.util.ArrayList;
import java.util.List;
public class TestLiner {
public static void main(String[] args) {
List list=new ArrayList();
list.add(111);
list.add(222);
list.add(333);
list.add(444);
list.add(555);
list.add(3,123);
list.remove(3);
System.out.println(list.size());
System.out.println(list.isEmpty());
System.out.println(list.get(3));
System.out.println(list.toString());
}
}
单链表
线性表中每个节点有唯一的前驱和后继节点。
设计链式储存结构是，每个逻辑节点储存单独存储，为了表示逻辑关系，增加指针域。
- 每个物理节点增加一个只想后继节点的指针域就是单链表
（其接口信息与自定义异常与单链表相同。）
单链表的结点 类
public class Node{
/*private Object data;
private Node next;*/
Object data;
Node next;
public Node() {
}
public Node(Object data) {
super();
this.data = data;
}
public Node(Object data, Node next) {
super();
this.data = data;
this.next = next;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public Node getNext() {
return getNext();
}
public void setNext(Node next) {
this.data = next;
}
}
实现类
import java.util.List;
public class SingleLinkedList implements Liner {
private Node head = new Node();// 头结点，不储存数据，
private int size;// 一共有几个结点
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public Object get(int i) {
Node p = head;
for (int j = 0; j <= i; j++) {
p = p.next;
}
return p.data;
}
public boolean contains(Object obj) {
if (isEmpty()) {
return false;
}
for (int i = 0; i < size; i++) {
Node p = head;
if (obj.equals(p.data)) {
return true;
}
}
return false;
}
public int indexOf(Object obj) {
for (int i = 0; i < size; i++) {
Node p = head;
if (obj.equals(p.data)) {
return i;
}
}
return -1;
}
public void add(Object index) {
this.add(size, index);
}
public void add(int index, Object obj) {
// 如果i位置错误异常
if (index < 0 || index > size) {
throw new MyArrayIndexOutOfBoundsException("数组指针越界异常" + index);
}
// 找到前 一个节点，从head节点开始
Node p = head;
for (int j = 0; j < index; j++) {
p = p.next;
}
// 暂时创建一个节点
Node newNode = new Node();
newNode.data = obj;
// 指明新结点的直接后继结点
newNode.next = p.next;
// 指明新结点的直接前驱节点
p.next = newNode;
size++;
}
//头结点删除
public Object removeFirst(){
Node temp = head;//移动指针
if(temp == null){
//头指针为空的情况
System.out.println("这是一个空链表");
}else{
Node removeNode = temp;//头指针不为空，指向的结点即为第一个结点，也就是删除结点。定义这个变量是为存储删除的值
temp = temp.next;//指针移动，指向删除结点的后一个结点
head = temp;//把头指针指向删除结点的后一个结点
size--;
return removeNode.data;//把删除结点的值返回
}
return null;
}
//尾结点删除
public Object removeLast(){
Node temp = head;//定义一个临时指针，先指向头指针
if(temp == null){
//头指针
System.out.println("这是一个空链表");
}else{
Node currentNode = temp.next;//定义一个当前指针，把它作为移动指针。
while(currentNode.next != null){
//循环遍历指针
temp = currentNode;//临时指针指向当前指针，即存储当前结点的值。
currentNode = currentNode.next;//当前指针的移动
}
temp.next = null;//到了这里，说明当前currentNode.next==null的，即currentNode是没有后继结点了，而他就是要被删除的结点。把它前一个结点的指针域赋值为空，不指向它，那它不就删除了。
size--;
return currentNode.data;//把删除结点的值返回
}
return null;
}
//删除指定的序号的结点
public Object remove(int index){
Node temp = head;//定义临时指针
if(temp == null){
//头指针为空
System.out.println("这是一个空链表");
}else{
Node currentNode = temp.next;//定义一个当前指针的变量
int i = 1;//定义一个记录位置的变量
if(index<1 || index>size+1){
System.out.println("删除位置不合理");
}
while(currentNode.next!=null){
if(index == i++){
temp = currentNode;//把当前结点的值即要删除的结点存储到temp临时指针中。目的是要把它存储的值返回回来。
currentNode = currentNode.next;
size--;
return temp.data;
}
currentNode = currentNode.next;
}
}
return null;
}
/*public Object remove(int index) {
if(index<1||index>size+1){
throw new MyArrayIndexOutOfBoundsException("位置不合法");
}
return index;
}
*/
@Override
public String toString() {
if (size == 0) {
return "[]";
}
StringBuilder builder = new StringBuilder("[");
Node p = head;
for (int i = 0; i < size; i++) {
if (i != size - 1) {
builder.append(p.data + ",");
} else {
builder.append(p.data);
}
}
builder.append("]");
return builder.toString();
}
}
测试类
import java.util.List;
public class TestSingleLinkedList {
public static void main(String[] args) {
SingleLinkedList list= new SingleLinkedList();
list.add(111);
list.add(222);
list.add(333);
list.add(454);
list.add(555);
list.add(5,123);
list.remove(3);
System.out.println(list.size());
System.out.println(list.isEmpty());
System.out.println(list.get(2));
System.out.println(list.toString());
}
}