顺序表总结-用ArrayList和LinkList实现线性表去重及反转

线性表包括顺序表和链表。
一、顺序表（顺序存储结构）
1、数组
数组是一种标准的线性表结构，其数据的存储顺序与存储的物理地址直接相关，具有随机存取速度快的特点。
int[] arr = new int[10]; //定义长度为10的数组
int length = arr.length; //数组长度通过访问数组对象的length属性获取
arr[0] = 1; //数组元素赋值
int a = arr[0]; //数组元素访问

2、列表（ArrayList）
数组的创建需要指定长度，若在不清楚数组所需使用的长度时，除了使用链表外，还可以使用ArrayList，区别在于后者是一个用数组实现的可自动扩展的顺序表，而前者是链表。
ArrayList list = new ArrayList(); //列表对象创建，指定数据元素类型为Integer;
list.add(3); //list:[3]，列表添加元素1
list.add(0,2); //list:[2,3]，第0个位置插入元素2
list.remove(0); //list:[3]，删除第0个位置的元素
list.set(0,2); //list:[2]，设置第0个元素为2
int num = list.get(0); // num为2，获取第0个元素
int size = list.size(); //size为1，获取列表的大小
int index = list.indexOf(2); //index为0，为元素2在列表中的位置

二、链表（链式存储结构）
链表（LinkedList）
LinkedList是用双向链表实现的线性表集合，双向链表指的是链表中每一个节点都包含了该节点的前驱及后继节点的引用。该集合类对外暴露的接口与ArrayList类似，也有增（add）、删（remove）、改（set）、查（get）方法，不同的是，这些方法都是以链表的形式实现。
LinkedList list = new LinkedList(); //链表对象创建，指定数据元素类型为Integer;
list.add(3); //list:[3]，链表添加元素1
list.add(0,2); //list:[2,3]，第0个位置插入元素2
list.remove(0); //list:[3]，删除第0个位置的元素
list.set(0,2); //list:[2]，链表第0个元素为2
int num = list.get(0); // num为2，获取第0个元素
int size = list.size(); //size为1，获取链表的大小
int index = list.indexOf(2); //index为0，为元素2在链表中的位置

由于LinkedList是用双向链表实现的集合类，因此还有一些方法是链表独有的，如addFirst/addLast（链表头部/尾部插入元素）、removeFirst/removeLast（链表头部/尾部删除元素）、getFirst/getLast（获取链表头部/尾部元素）等。

三、线性表反转
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public abstract class Test {

public static void main(String[] args) {
	ArrayList<Integer> arr = new ArrayList<>();
    LinkedList<Integer> link = new LinkedList<>();
    for(int i=0;i<100000;i++){
        arr.add(i);
        link.add(i);
    }
    TimerUtil.start();
    List a = reverseArr(arr);
    TimerUtil.pause("ArrayList");
    List b = reverseArr(link);
    TimerUtil.pause("LinkedList");
    TimerUtil.stop();
}


//LinkedList数据反转
public static List<Integer> reverseArr(ArrayList<Integer> arr) {
	if(arr==null){
		return null;
	}
	//二分
	for(int i = 0; i <= arr.size()/2;i++){
		int j=arr.size()-1-i;
		arr.set(i,arr.get(j));
		arr.set(j,arr.get(i));
	}
	return arr;
}
//ArrayList数据反转
public static List<Integer> reverseArr(LinkedList<Integer> arr){
	if(arr==null){
		return null;
	}
	//二分
	for(int i = 0; i <= arr.size()/2;i++){
		int j=arr.size()-1-i;
		arr.set(i,arr.get(j));
		arr.set(j,arr.get(i));
	}
	return arr;
}

}
//自定义工具类
public class TimerUtil {
private static long start;
private static long lastTime;
private static long end;
public static void start(){
start = System.currentTimeMillis();
lastTime = start;
System.out.println("----开始计时----");
}
public static void pause(){
long p = System.currentTimeMillis();
System.out.println("----耗时：" + (p - lastTime) + “ms----”);
lastTime = p;
}
public static void pause(String s){
long p = System.currentTimeMillis();
System.out.println("----" + s + “|耗时：” + (p - lastTime) + “ms----”);
lastTime = p;
}
public static void stop(){
end = System.currentTimeMillis();
System.out.println("----结束计时----");
}
}
四、线性表去重
实现思路：
1.使用两个for循环遍历集合所有元素，重复用remove去掉
2.新建集合，用contains保存不重复元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public abstract class Test {

public static void main(String[] args) {
    ArrayList<Integer> arr = new ArrayList<>();
    LinkedList<Integer> link = new LinkedList<>();
    for(int i=0;i<100000;i++){
        arr.add(i);
        arr.add(i);
        link.add(i);
        link.add(i);
    }
    TimerUtil.start();
    List c = distinctArr(arr);
    TimerUtil.pause("distinct ArrayList");
    List d = distinctArr(link);
    TimerUtil.pause("distinct LinkedList");
    TimerUtil.stop();
}

//方法一：1.使用两个for循环遍历集合所有元素
public static List distinctArr(List arr){
for(int i = 0; i <=arr.size();i++){
for(int j = i+1;j<=arr.size();j++){
if(arr.get(i).equals(arr.get(j))){
arr.remove(j);
}
}
}
return arr;
}

//方法二：新建集合，用contains保存不重复元素
public static List distinctArr(List arr){
//新建新的List集合，用于存放去重后的元素
List newList = new ArrayList();
//循环遍历旧集合元素
for(int i = 0; i <arr.size();i++){
boolean isContains = newList.contains(arr.get(i));
if(!isContains){
newList.add(arr.get(i));
}
}
//把旧集合所有元素清空
arr.clear();
arr.addAll(newList);
return arr;
}

}
//新建自定义工具类TimerUtil测试耗时
public class TimerUtil {
private static long start;
private static long lastTime;
private static long end;
public static void start(){
start = System.currentTimeMillis();
lastTime = start;
System.out.println("----开始计时----");
}
public static void pause(){
long p = System.currentTimeMillis();
System.out.println("----耗时：" + (p - lastTime) + “ms----”);
lastTime = p;
}
public static void pause(String s){
long p = System.currentTimeMillis();
System.out.println("----" + s + “|耗时：” + (p - lastTime) + “ms----”);
lastTime = p;
}
public static void stop(){
end = System.currentTimeMillis();
System.out.println("----结束计时----");
}
}