线性表的定义与特点之顺序表笔记及其java语言实现 数据结构与算法笔记

1. 顺序表占用一片连续的存储空间（如数组），均采用顺序结构存储数据。其特点有地址连续、一次存放、随机存取、类型相同。
2. 假设顺序表第一个元素的地址值为基地址a1，假设每个元素占用存储单元数(即字节数)为L，则其中第n个元素的地址值为LOC=a1 + (n-1)L,可以方便的计算出任意元素的地址（随机存取）。
3. 顺序表的优点：
                     ·可以任意读写线性表的元素，其随机读写的时间复杂度为O(1).

                            ·存储密度大(数据都紧挨着存储)

4.线性表的缺点

        ·插入与删除元素时，常常需要移动大量元素，因此插入删除操作效率较低，其时间复杂度为O(n)

        ·静态存储形式，其空间大小不能随意更改。

5.基于以上优缺点，在需要大量检索操作且很少插入、删除元素时，可以选用顺序表

顺序表的java实现：

import java.util.Comparator;
//这里为测试代码
public class SequentialTable {
    public static void main(String[] args) {
        List<Integer> list = new List<>();
        list.add(1);
        list.add(2);
        list.add(3);
       // list.delete(3);
        System.out.println(list);
        list.insert(2,4);
        System.out.println(list);
        list.delete(2);
        System.out.println(list);
        System.out.println(list.delete((Integer) 3));
       // System.out.println(list.get((Integer) 3));

        System.out.println(list);
        System.out.println(list.get(4));


    }
}
class List<T>{
    private int size = 100;
    private int lenth = 0;
//由于java的泛型只是编译期技术，其在编译之后会全部擦除，变成Object，因此不允许直接创建泛型数组
//这里通过强制类型转换的方式偷懒，当然最好还是直接创建Object[],然后在使用时进行强制类型转换
    private T[] list = (T[])(new Object[size]);
//判断传入的i是否合法
    private boolean isNotLeGal(int i){

        if (i<1 || i > lenth){
            return true;
        }
        return false;
    }
    public int getSize(){
        return size;
    }
    public int getLenth(){
        return lenth;
    }
    public boolean add(T obj){
        if (lenth == size){
            return false;
        }
        list[lenth++] = obj;
        return true;
    }
    public T get(int i){
        if (isNotLeGal(i)){
            return null;
        }
        i--;
        return (T)list[i];
    }
    public T delete(int i){
        if (isNotLeGal(i)){
            return null;
        }
        i--;
        T result = list[i];
        for (int j = i; j < lenth-1 ; j++) {
            list[j] = list[j+1];
        }
        lenth--;
        return result;
    }
    public int get(T obj){
        for (int i = 0; i < lenth; i++) {
            if (obj.equals(list[i])){
                return i+1;
            }
        }
        return 0;
    }
    public T replace(int i, T obj){
        if (isNotLeGal(i)){
            return null;
        }
        T result = (T)list[--i];
        list[i] =  obj;
        return result;
    }
    public boolean insert(int i, T obj){
        if (lenth >= size){
            return false;
        }
        if (isNotLeGal(i)){
            return false;
        }
        i--;
        for (int j = lenth-1; j >= i; j--) {
            list[j+1] = list[j];
        }
        list[i] = obj;
        lenth++;
        return true;
    }
    public T delete(T obj){
        int i = get(obj);
        if (i > 0){
            return delete(i);
        }
        return null;
    }
//采用comparator接口可以根据实际问题自定义判断规则
    public int get(T obj, Comparator<T> cmp){
        for (int i = 0; i < lenth; i++) {
            if (cmp.compare(obj,(T)list[i]) == 0){
                return i+1;
            }
        }
        return 0;
    }
    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; i < lenth-1; i++) {
            stringBuilder.append(list[i]+",");
        }
        stringBuilder.append(list[lenth-1]+"]");
        return stringBuilder.toString();

    }
}