数据结构之线性表

一.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是种在实际广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列......

线性表在逻辑上是线性结构，也就是说连续的一条直线，但是在物理结构上不一定是连续的，线性表在物理上存储是，通常以数组和链式结构的形式存储。

二.顺序表

顺序表是一段用物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下采用数组存储。在数组上完成数据的增删查改。

2.1 接口的实现

public class SeqList {
private int[] array;
private int size;
// 默认构造方法
SeqList(){ }
// 将顺序表的底层容量设置为initcapacity
SeqList(int initcapacity){ }
// 新增元素,默认在数组最后新增
public void add(int data) { }
// 在 pos 位置新增元素
public void add(int pos, int data) { }
// 判定是否包含某个元素
public boolean contains(int toFind) { return true; }
// 查找某个元素对应的位置
public int indexOf(int toFind) { return -1; }
// 获取 pos 位置的元素
public int get(int pos) { return -1; }
// 给 pos 位置的元素设为 value
public void set(int pos, int value) { }
//删除第一次出现的关键字key
public void remove(int toRemove) { }
// 获取顺序表长度
public int size() { return 0; }
// 清空顺序表
public void clear() { }
// 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
public void display() { }
}

三.ArrayList简介

在集合框架中，ArrayList是一个普通的类，实现了List接口。

3.1 ArrayList的构造

public static void main(String[] args){
//构造一个空的列表
List<Integer>list1 = new ArrayList<>();

//构造一个具有10个容量的列表
List<Integer>list2 = new ArrayList<>(10);
list2.add(1);
list2.add(2);
list2.add(3);
//list3构造好之后，与list中的元素一致
ArratList<Integer>list3 = new ArrayList<>(list2);

}

3.2 常见操作

boolean add(E e) 尾插 e

void add(int index, E element) 将 e 插入到 index 位置

boolean addAll(Collection<? extends E> c) 尾插 c 中的元素

E remove(int index) 删除 index 位置元素

boolean remove(Object o) 删除遇到的第一个 o

E get(int index) 获取下标 index 位置元素

E set(int index, E element) 将下标 index 位置元素设置为 element

void clear() 清空

boolean contains(Object o) 判断 o 是否在线性表中

int indexOf(Object o) 返回第一个 o 所在下标

int lastIndexOf(Object o) 返回最后一个 o 的下标

List<E> subList(int fromIndex, int toIndex) 截取部分 list

public static void main(String[] args){
List<String>list = new ArrayList<>();
list.add("JavaSE");
list.add("JavaWeb");
list.add("JavaEE");
list.add("JVM");
list.add("测试课程");
System.out.println(list);

//获取list中有效元素的个数
System.out.println(list.size());
//获取和设置 index位置上的元素，注意index必须介于【0,size】之间
System.out.println(list.get(1));
list.set(1,"JavaWEB");
System.out.println(list.get(1));
// 在list的index位置插入指定元素，index及后续的元素统一往后搬移一个位置
list.add(1, "Java数据结构");
System.out.println(list);
// 删除指定元素，找到了就删除，该元素之后的元素统一往前搬移一个位置
list.remove("JVM");
System.out.println(list);
// 删除list中index位置上的元素，注意index不要超过list中有效元素个数,否则会抛出下标越界异常
list.remove(list.size()-1);
System.out.println(list);
// 检测list中是否包含指定元素，包含返回true，否则返回false
if(list.contains("测试课程")){
list.add("测试课程");
}
// 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找
list.add("JavaSE");
System.out.println(list.indexOf("JavaSE"));
System.out.println(list.lastIndexOf("JavaSE"));
// 使用list中[0, 4)之间的元素构成一个新的SubList返回,但是和ArrayList共用一个elementData数组
List<String> ret = list.subList(0, 4);
System.out.println(ret);
list.clear();
System.out.println(list.size());
}

3.3ArrayList的遍历

三种方式遍历：for循环+下标，foreach，使用迭代器

public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
// 使用下标+for遍历
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
System.out.println();
// 借助foreach遍历
for (Integer integer : list) {
System.out.print(integer + " ");
}
System.out.println();
Iterator<Integer> it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next() + " ");
}
System.out.println();
}

四.链表

4.1链表的概念及结构：

1. 链表是一种物理存储结构上非连续的存储结构，数据元素的罗顺序是通过链表中的引用链接次序实现的。

2. 链表的结构

• 单向或者双向

• 带头或者不带头

• 循环或者非循环

4.2链表的实现

//无头单向非循环链表实现
public class SingleLinkList{
//头插法
public void addFirst(int data){
}
//尾插法
public void addLast(int data){
}
//任意位置插入，第一个数据节点为0号下标
public void addindex(int index,int data){
}
//查找是否包含关键字key是否在单链表中
public boolean cotains(int key){
   return false;
}
//删除第一次关键字为key的节点
public void remove(int key){
}
//删除所有值为key的节点
public void removeAllkey(int key){
}
//得到单链表的长度
public int size(){
return -1;
}
public void clea(){
}
public void display(){
}

• 车厢类/节点类的定义：class Node{

E val;//保存的值

Node next;//下一个车厢的地址

}

• 火车类/链表类的定义 class SingleLinkList {

Node head;//头结点的地址；

int size；节点个数/具体的元素个数

}

public clas SingleLinkedList<E> implements SeqList<E>{
    private Node head;
    private int size;
//车厢类的定义，车厢作为火车的私有内部类，对外部完全隐藏
private class Node {
    E val;
    Node next;          
   }
}

• 链表的头插：

Node node =new Node(1);

node.next =head;

head = node;

size++;

• 链表的遍历：

public String toString(){
    StringBuilder sb = new StringBuilder();
//从当前链表的第一个节点开始向后遍历，直到走到尾结点为止
//第一个节点head
//尾结点的next值 == null
Node temp =head;
while(temp!=null){
sb.append(temp.val);
sb.append("->");
temp = temp.next;
 }
return sb.toString();
}

• LinkedList遍历

public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1); // add(elem): 表示尾插
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
System.out.println(list.size());
// foreach遍历
for (int e:list) {
System.out.print(e + " ");
}
System.out.println();
// 使用迭代器遍历---正向遍历
ListIterator<Integer> it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next()+ " ");
}
System.out.println();
// 使用反向迭代器---反向遍历
ListIterator<Integer> rit = list.listIterator(list.size());
while (rit.hasPrevious()){
System.out.print(rit.previous() +" ");
}
System.out.println();
}