本篇我们介绍下数据结构中的顺序表、链表的基础概念,以及它们各自的java代码实现。
一、顺序表
1.1 什么是顺序表
顺序表和链表都是属于线性表。顺序表,顾名思义所有元素物理上都是顺序存储,类似于数组。
1.2 顺序表的api设计 (基于数组)
类名:SequenceList
构造方法:SequenceList(int capacity)//指定容量
成员方法:
public void clear(); 置空顺序表
public boolean isEmpty(); 判断表是否为空
public int size(); 获取顺序表长度
public T get(int i); 根据索引获取元素
public void add(T t); 添加元素
public void add(int i ,T t); 向指定索引处插入元素
public T remove(); 删除元素
public T remove(int i); 删除指定索引处的元素
public int indexOf(T t); 检索元素第一次出现的位置
public boolean contains(T t); 是否包含元素
成员变量:
private T[] eles ; 存储数据的数组
private int N ; 当前线性表的长度
1.3 java代码实现
package com.tingcream.alg.linear;
import java.util.Iterator;
/**
* 顺序表 api设计 (基于数组)
* 类名: SequenceList
* 构造方法: SequenceList(int capacity)//指定容量
* 成员方法:
* public void clear() 置空顺序表
* public boolean isEmpty()
* public int size() 获取线性表长度
* public T get(int i); O(1)
* public void add(T t); O(1)
* public void add(int i ,T t); O(n)
* public T remove(); O(1)
* public T remove(int i); O(n)
* public int indexOf(T t); O(n)
* public boolean contains(T t);
*
* 成员变量 :
* private T[] eles; 存储数据的数组
* private int N;当前线性表的长度
*
*/
public class SequenceList implements Iterable{
private T[] eles;//存储数据的数组 ()
private int N ;//线性表长度 ,相当于一个指针初始是指向索引0
public SequenceList(int capacity){
this.eles=(T[])new Object[capacity];
this.N=0;
}
//置空顺序表
public void clear(){
this.N=0;
}
//判断顺序表是否为空
public boolean isEmpty(){
return this.N==0;
}
//获取顺序表的长度
public int size(){
return this.N;
}
//获取指定索引的值
public T get(int i){
return eles[i];
}
//向顺序表尾部插入元素
public void add(T t){
if(N==eles.length){
resize(2*eles.length);
}
this.eles[N++]=t;
//调用重载的insert方法
// add(N,t);
}
//插入元素
public void add(int i,T t){
if(N==eles.length){
resize(2*eles.length);
}
for(int index=N;index>i;index--){
eles[index]=eles[index--];
}
eles[i]=t;
this.N++;
}
//移除最后一个元素
public T remove(){
//调用重载的remove方法
return remove(N-1);
}
//移除一个元素
public T remove(int i){
T value= this.eles[i];
for(int index=i;index=0;
}
//扩容或缩容
public void resize(int newSize){
T[] original=eles;
eles=(T[])new Object[newSize];
for(int i=0;i iterator() {
return new Itr();
}
//迭代器类
private class Itr implements Iterator{
private int cursor;
public Itr(){
this.cursor=0;
}
@Override
public boolean hasNext() {
return cursor
}
}
}
1.4 java测试代码
package com.tingcream.alg.test;
import com.tingcream.alg.linear.SequenceList;
public class SequenceListTest {
public static void main(String[] args) {
SequenceList list=new SequenceList(4);
list.add("aa");
list.add("bb");
list.add("cc");
list.add("dd");
list.add("ee");
list.remove(1);
//遍历
for(String s: list){
System.out.println(s);
}
}
}
二、链表
2.1 什么是链表
链表也是线性表中的一种,逻辑上是线性的,但是物理存储上不是连续的内存空间。链表通过next指针执行下一个节点,从而实现了数据的链式存储。
2.2 链表的api设计
类名: LinkList
构造方法: LinkList()
成员方法:
public void clear()
public boolean isEmpty()
public int size()
public T get(int i)
public void add(T t)
public void add(int i ,T t)
public T remove()
public T remove(int i)
public int indexOf(T t)
public boolean contains(T t);
成员内部类:
private class Node 节点类
成员变量:
private Node head;//头结点元素
private int N ; //链表长度
2.3 java代码实现
package com.tingcream.alg.linear;
import java.util.Iterator;
/**
* 链表 api设计
* 类名: LinkList
* 构造方法: LinkList()
* 成员方法:
* public void clear()
* public boolean isEmpty()
* public int size()
* public T get(int i)
* public void add(T t)
* public void add(int i ,T t)
* public T remove()
* public T remove(int i)
* public int indexOf(T t)
* public boolean contains(T t);
*
* 成员内部类:
* private class Node 节点类
* 成员变量:
* private Node head;//头结点元素
* private int N ; //链表长度
*/
public class LinkList implements Iterable{
private Node head;//表示头结点
private int N;// 链表长度
//构造方法
public LinkList(){
this.head=new Node(null,null);
this.N=0;
}
//清空链表
public void clear(){
this.head.next=null;
this.N=0;
}
//获取链表长度
public int size(){
return N;
}
//判断链表是否为空
public boolean isEmpty(){
return N==0;
}
//根据位置i获取元素
public T get(int i){
Node n=head.next;
for(int index=0;index=0;
}
//反转链表
public void reverse(){
if(isEmpty()){
return ;
}
reverse(head.next);
}
//把当前反转后的结点对象返回
private Node reverse(Node current){
if(current.next==null){
head.next=current;
current.next=null;
return current;
}
Node n= reverse(current.next);
n.next=current;
current.next=null;
return current;
}
@Override
public Iterator iterator() {
return new Itr();
}
//内部类 迭代器
private class Itr implements Iterator{
private Node n;
public Itr(){
this.n=head;
}
@Override
public boolean hasNext() {
return n.next!=null;
}
@Override
public T next() {
n=n.next;//n指针向后移动一步
return n.item;
}
}
//内部类 ,表示结点
private class Node {
private T item;
private Node next;
public Node(T item,Node next){
this.item=item;
this.next=next;
}
}
}
2.4 java测试代码
package com.tingcream.alg.test;
import com.tingcream.alg.linear.LinkList;
public class LinkListTest {
public static void main(String[] args) {
LinkList list =new LinkList();
list.add("aa");
list.add("bb");
list.add("cc");
list.add("dd");
for(String s: list){
System.out.println(s);
}
System.out.println("bb位置:"+list.indexOf("bb"));
System.out.println("是否包含aa:"+list.contains("aa"));
}
}