数据结构基础--线性表

文章来源：http://www.cnblogs.com/V1haoge/p/8276472.html

手动实现的顺序线性表结构，实现了基本的方法，本地简单测试通过，主要用于理解顺序线性表的结构，还实现了简单的数组扩容，有兴趣的朋友可以看看。

package dataStructure;

import java.io.Serializable;

/**
 * 顺序线性表
 *
 * @author qe259
 */
public class MyArrayList implements Serializable {

    private static final long serialVersionUID = 5162710183439028792L;
    private Object[] list;//底层用数组实现
    private static final Integer INITLEBGTH = 10;//默认的初始化数组长度
    private static final Double INITFACTOR = 0.75;//默认的初始化增长因子
    private final Double dilatationFactor = 1.5;//默认的初始化扩容因子
    private Double factor;//增长因子
    private Integer length;//数组的长度
    private Integer nowLength;//当前数组包含元素的长度

    public MyArrayList(){
        this(INITLEBGTH);
    }

    public MyArrayList(Integer length){
        this(length,INITFACTOR);
    }

    public MyArrayList(Integer length,Double factor){
        this.length = length == null || length == 0 ? INITLEBGTH : length;
        this.factor = factor == null || factor > 1 || factor <= 0 ? INITFACTOR : factor;
        list = new Object[length];
        nowLength = 0;
    }

    //数组扩容
    private void dilatation(){
        Object[] objs = new Object[(int)(length * dilatationFactor)];
        for(int i =0,j = 0;i<nowLength;i++,j++){
            objs[j] = list[i];
        }
        list = objs;
        length = objs.length;
    }

    //添加元素
    public void add(Object obj){
        if((double)nowLength/length >= factor){
            this.dilatation();
        }
        list[nowLength]=obj;
        nowLength++;
    }

    //查看元素
    public Object get(Integer index){
        if(index<0||index>list.length){
            throw new NullPointerException();
        }
        return list[index];
    }

    //插入元素
    public void insert(Integer index,Object obj){
        if((double)nowLength/length >= factor){
            this.dilatation();
        }
        for(int i = nowLength;i>index;i--){
            list[i]=list[i-1];
        }
        list[index]=obj;
        nowLength++;
    }

    //移除元素
    public void remove(Integer index){
        if(index<0||index>nowLength-1){
            throw new NullPointerException();
        }
        for(int i = index;i < nowLength-1;){
            list[i]=list[++i];
        }
        list[nowLength-1]=null;
        nowLength--;
    }

    //移除指定元素
    public void remove(Object t){
        for(int i= 0;i<nowLength;i++){
            if(get(i)==t) {
                remove(i);
            }
        }
    }

    //清空元素
    public void clear(){
        for(int i = 0;i<nowLength;i++){
            list[i] = null;
        }
        nowLength=0;
    }

    //包含元素
    public Boolean contains(Object t){
        for(int i = 0;i<nowLength;i++){
           if(list[i] == t){
               return true;
           }
        }
        return false;
    }

    @Override
    public String toString() {
        StringBuffer s = new StringBuffer("MyArrayList[");
        for(int i = 0;i<nowLength;i++){
            s.append(list[i].toString()).append(i==nowLength-1?"":",");
        }
        return s.append("]").toString();
    }

    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        System.out.println(list.toString());
        System.out.println(list.contains("3"));
        list.add("6");
        list.add("2");
        list.add("5");
        System.out.println(list.toString());
        try{
            list.remove(10);
        }catch(NullPointerException e){
            e.printStackTrace();
        }
        System.out.println(list.toString());
        list.remove(2);
        System.out.println(list.toString());
        list.remove("2");
        System.out.println(list.toString());
        list.insert(3,"100");
        System.out.println(list.toString());
        list.clear();
        System.out.println(list.toString());
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        System.out.println(list.toString());
        list.add("100");
        list.add("100");
        list.insert(0,"10000");
        System.out.println(list.toString());
    }
}

　　顺序线性表，底层以数组来实现，是内存上连续排列的一系列数据，其特点是查询和添加元素比较迅速，但是插入元素和移除元素比较慢，需要遍历数组。

　　手动实现链表形式线性表：

package dataStructure;

import java.io.Serializable;
import java.util.Objects;

/**
 * 链式线性表
 *
 * @author qe259
 */
public class MyLinkedList implements Serializable {

    //节点
    private static class Node{
        Object data;
        Node next;
        Node(Object data,Node next){
            this.data = data;
            this.next = next;
        } 
    }

    private static final long serialVersionUID = 5162710183435428792L;
    private Node start;// = new Node(null,null);
    private Node end;// = new Node(null,null);
    private Integer length = 0;

    public MyLinkedList(){
        end = new Node(null,null);
        start = new Node(null,end);
    }
    
    //添加元素
    public void add(Object data){
        if(Objects.isNull(data))
            throw new NullPointerException();
        Node transitNode = end;
        end = new Node(data,null);
        transitNode.next = end;
        if(length==0){
            start.next=end;
        }
        length++;
    }
    
    //查找指定下标元素
    public Object get(Integer index){
        if(index<1||index>length)
            throw new NullPointerException();
        Integer count = 0;
        Node circleNode = start;
        while(circleNode.next != null){
            circleNode = circleNode.next;
            count++;
            if(count == index){
                return circleNode.data;
            }
        }
        return null;
    }
    
    //包含元素
    public boolean contains(Object data){
        boolean isExists = false;
        Node circleNode = start;
        while(circleNode.next != null){
            circleNode = circleNode.next;
            if(circleNode.data == data || circleNode.data.equals(data)){
                 isExists = true;
            }
        }
        return false;
    }
    
    //插入元素
    public void insert(Integer index,Object... objects){
        if(index <= 0 || index > length)
            throw new NullPointerException();
        Node circleNode = start;
        Integer count = 0;
        while(circleNode.next != null){
            if(count==index-1){
                Node transitNode = circleNode.next;
                Node oNode = new Node(objects[0],null);
                circleNode.next = oNode;
                if(objects.length==1){
                    oNode.next = transitNode;
                }
                length++;
                for(int i = 1;i<objects.length;i++){
                    if(i==objects.length-1){
                        oNode.next = new Node(objects[i],transitNode);
                    }else{
                        Node transitNode1 = new Node(objects[i],null);
                        oNode.next = transitNode1;
                        oNode = transitNode1;
                    }
                    length++;
                }
                break;
            }
            count++;
            circleNode = circleNode.next;
        }
    }
    
    //移除指定下标元素
    public void remove(Integer index){
        Node circleNode = start;
        Integer count = 0;
        if(index == length){
            while(circleNode.next !=null){
                count++;
                circleNode = circleNode.next;
                if(count==length-1)break;
            }
            circleNode.next=null;
            end = circleNode;
            length--;
            return;
        }
        while(circleNode.next != null){
            count++;
            circleNode = circleNode.next;
            if(count==index-1){
                circleNode.next = circleNode.next.next;
                length--;
                break;
            }
        }
    }

    //清空列表
    public void clear(){
        Node circleNode = start;
        while(circleNode.next != null){
            Node transitNode = circleNode.next;
            circleNode.next = null;
            circleNode = transitNode;
            circleNode.data = null;
        }
        length = 0;
        end = new Node(null,null);
        start = new Node(null,end);
    }

    @Override
    public String toString() {
        Node circleNode = start;
        StringBuffer str = new StringBuffer("MyLinkedList[");
        Integer count = 0;
        while(circleNode.next != null){
            count++;
            circleNode=circleNode.next;
            if(count == length){
                str.append(circleNode.data.toString()).append("]");
            }else{
                str.append(circleNode.data.toString()).append(",");
            }
        }
        return str.toString();
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyLinkedList list = new MyLinkedList();
        list.add("1");
        list.insert(1,"111");
        list.add("2");
        Object o = list.get(2);
        list.add("3");
        list.add("4");
        list.add("5");
        list.insert(3, "100","200","300");
        list.add("13321");
        list.remove(9);
        list.remove(4);
        list.add("asd");
        list.remove(9);
        System.out.println(list);
        list.clear();
    }

}

　　下面是静态链表，采用数组方式实现，适用于无指针和类似指针功能语言来实现：

package dataStructure;

import java.io.Serializable;

public class MyStaticLinkedList implements Serializable {

    private static final long serialVersionUID = 5143210183435428792L;

    //节点
    public static class Node{
        Object data;
        Integer next;
        Node(Object data,Integer next){
            this.data=data;
            this.next=next;
        }
    }

    private static Node[] staticList;
    private static final Integer ListLength = 1000;
    private Integer length = 0;//链表长度
    private Integer useMaxLength = 0;//這個值表示的是數組被占用過的最大下標值

    //无参构造器
    public MyStaticLinkedList(){
        this(ListLength);
    }

    //构造器
    public MyStaticLinkedList(Integer length){
        staticList = new Node[length];
        for(int i = 0;i<length;i++){
            staticList[i] = new Node(null,i+1);
        }
        staticList[length-1].next = 0;
    }

    //添加元素
    public void add(Object data){
        staticList[staticList[0].next].data = data;
        if(useMaxLength == length){
            staticList[0].next=++staticList[0].next;
            if(length == 0){
                staticList[staticList.length-1].next = 1;
            }
            if(staticList[0].next>useMaxLength)
                useMaxLength++;
        }else if(useMaxLength > length){//數組存在空位，即數組刪除過其中的元素
            for(int i = 1;i<=useMaxLength;i++){
                if(staticList[i].data==null){
                    staticList[staticList[0].next].next=i;
                    staticList[0].next=i;
                    break;
                }
            }
        }else
            throw new IllegalAccessError();
        length++;
    }

    //包含元素
    public Boolean contains(Object data){
        Boolean isExists = false;
        for(int i = 1;i<=useMaxLength;i++){//此處使用useMaxLength有取巧之嫌，本應循環鏈表，而非數組，所以此處查詢到的不一定是鏈表中保存的首個該數據
            if(staticList[i].data==data||staticList[i].data.equals(data)){
                isExists = true;
                break;
            }
        }
        return isExists;
    }

    /**
     * 插入元素
     */
    public void insert(Integer index,Object data){
        if(index<=0||index>length)
            throw new NullPointerException();
        staticList[staticList[0].next].data = data;
        Node circleNode = staticList[staticList.length-1];
        Integer oIndex = 0;//插入位置原节点
        for(int i = 0;i<=length;i++){//循環鏈錶
            if(i == index-1){//在首位插入数据，其前节点即为数组最后一位
                oIndex = circleNode.next;
                circleNode.next = staticList[0].next;
                staticList[staticList[0].next].next = oIndex;
            }
            circleNode = staticList[circleNode.next];
        }
        if(index == 1){
            staticList[staticList.length-1].next = staticList[0].next;
        }
        if(staticList[0].next>useMaxLength)
            useMaxLength++;
        //circleNode最后保存的是链表的尾节点这个节点和数组首位的下标一致，指向新的空位节点
        for(int i = 1;i < staticList.length;i++){
            if(staticList[i].data==null){
                staticList[0].next = i;
                circleNode.next = i;
                break;
            }
        }
        length++;
    }

    /**
     * 移除指定下标元素
     * @param index
     */
    public void remove(Integer index){
        if(index<=0||index>length)
            throw new NullPointerException();
        Node circleNode = staticList[staticList.length-1];
        Integer oIndex = 0;//删除节点的位置
        for(int i = 0;i <= length;i++){
            if(i==index-1){
                oIndex = circleNode.next;
                staticList[oIndex].data = null;
                circleNode.next = staticList[oIndex].next;
                Integer ooIndex = 0;
                if(staticList[0].next > oIndex){
                    ooIndex = staticList[0].next;
                    staticList[0].next = oIndex;
                    staticList[oIndex].next = ooIndex;
                }else{
                    ooIndex = staticList[staticList[0].next].next;
                    if(ooIndex > oIndex){
                        staticList[staticList[0].next].next = oIndex;
                        staticList[oIndex].next = ooIndex;
                    }
                }
            }
            if(i == length-1){
                circleNode.next = staticList[0].next;
            }
            circleNode = staticList[circleNode.next];
        }
        length--;
    }

    public void remove(Object data){

    }

    //清空鏈表
    public void clear(){
        for(int i = 0;i <= useMaxLength;i++){
            staticList[i].data = null;
            staticList[i].next = i + 1;
            staticList[staticList.length-1].next = 1;
        }
        useMaxLength = 0;
        length = 0;
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer("MyStaticLinkedList[");
        Node circleNode = staticList[staticList.length-1];
        for(int i = 0;i<length;i++){
            circleNode = staticList[circleNode.next];
            sb = i==length-1
                    ?sb.append(circleNode.data.toString())
                    :sb.append(circleNode.data.toString()).append(",");
        }
        return sb.append("]").toString();
    }

    //测试
    public static void main(String[] args){
        MyStaticLinkedList list = new MyStaticLinkedList(20);
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.remove(5);
        list.remove(1);
        list.remove(2);
        list.add("7");
        System.out.println(list);
        list.insert(1,"111");
        list.insert(2,"222");
        System.out.println(list.contains("333"));
        System.out.println(list.contains("3"));
        list.add("2");
        System.out.println(list);
        list.clear();
    }

}

 　　所有代码均为本人手工编写，功能经过本人简单测试，如有问题，还请指出，本代码旨在通过练习熟悉线性表的几种实现方式，和其中的复杂度。