Java实现顺序表和链表的基本操作

java实现顺序表和单链表的基本操作

顺序表：
简单理解：一个有顺序的表[数组]。我们使用一个整数N来定义他的长度，一个数组来负责描述他的结构也就是

class SequenceList<T>{
	private T[] array;
	private Integer N;
	public SequenceList(Integer capacity){
		this.array = (T[])new Object[capacity];
		this.N = 0;
	}
}

关于顺序表的一些基本处理：

package wh1006.datastructure.train;

import java.util.Iterator;

public class SequenceList<T> implements Iterable{
    private T[] eles;
    private int N;
    public SequenceList(int capacity){
        this.eles = (T[]) new Object[capacity];
        this.N = 0;
    }
    //初始化顺序表
    public void clear(){
        this.N =0;
    }
    //判断线性表是否为空
    public boolean isEmpty(){
        return N==0;
    }
    //返回线性表的长度
    public int length(){
        return N;
    }
    //返回第i个位置的元素
    public T get(int i){
        return eles[i];
    }
    //数组扩容
    public void resize(int newSize){
        T[] temp = eles;
        eles = (T[]) new Object[newSize];
        for (int i = 0; i < eles.length; i++) {
            eles[i] = temp[i];
        }
    }
    //插入元素
    public void insert(T t){
        //判断线性表满不满
        if(N==eles.length){
            resize(N*2);
        }
        eles[N] = t;
        N++;
    }
    //插入元素到指定位置
    public void insert(int i,T t){
        if(N==eles.length){
            resize(N*2);
        }
        N++;
        for (int j = N-1; j >= i ; j--) {
            eles[j+1] = eles[j];
        }
    }
    //删除元素(根据下标删除）
    public T remove(int i){
        T t = eles[i];
        for (int j = i; j <eles.length-1; j++) {
            eles[j] = eles[j+1];
        }
        N--;
        return t;
    }

    //删除第一次出现元素(根据元素删除）
    public void remove(T t){
        int j = 0;
        for (int i = 0; i < eles.length; i++) {
            if(eles[i] == t){
                 j = i;
            }
        }
        for (int z = j;z<eles.length-1;z++){
            eles[z] = eles[z+1];
        }
        N--;
    }
    //遍历
    @Override
    public Iterator iterator() {
        return new SItrator();
    }
    private class SItrator implements Iterator{
        private int cursor = 0;
        @Override
        public boolean hasNext() {
            return N==cursor;
        }

        @Override
        public Object next() {
            return eles[cursor++];
        }
    }
}

顺序表的主要不足：占用空间较大（尤其是扩容时空间复杂度为2N）

链表：
基本理解:类似于有人给你指路的过程，只会告诉你路在哪里【告诉你下一个节点的位置】，而不会告诉你路的终点有什么。并且只有知道上一个节点在哪才能知道下一个节点在哪儿

链表的基本结构为节点，抽象为类：

class Node<T>{
	private T item;
	private Node next;
	public Node(T item,Node next){
		this.item = item;
		this.next = next;
	}
}

链表的基本结构：

class LinkList{
	private Node head; //头结点
	private Integer N; //链表的长度
	public LinkList(){
		this.head = new Node(null,null);
		this.N = 0;
	}
}

链表的基本操作

package wh1006.datastructure.train;

public class LinkList<T> {
    private Node head;
    private int N;
    private class Node{
        T item;
        Node next;
        public Node(T item,Node next){
            this.item = item;
            this.next = next;
        }
    }

    //初始化链表
    public LinkList(){
        this.head = new Node(null,null);
        this.N =0;
    }
    //判断链表是否为空
    public Boolean isEmpty(){
        return N==0;
    }
    //返回链表的长度
    public int length(){
        return N;
    }
    //清空链表
    public void clear(){
        head.next=null;
        this.N=0;
    }
    //获取指定位置的元素
    public T get(int i){
        Node node = head.next;
        for(int index=0;index<i;index++){
            node = node.next;
        }
        return node.item;
    }
    //插入元素
    public void insert(T t){
        Node node = head;
        while (node.next!=null){
            node = node.next;
        }
        Node newNode = new Node(t,null);
        node.next = newNode;
        N++;
    }

    //插入元素到指定位置
    public void insert(T t,int i){
        Node node = head;
        for(int index = 0;index<i-1;index++){
            node = node.next;
        }
        Node NextNode = node.next;
        Node NewNode = new Node(t,NextNode);
        node.next = NewNode;
        N++;
    }
    //删除元素
    public T remove(int i){
        Node node = head;
        for(int index = 0;index<i-1;index++){
            node = node.next;
        }
        T item = node.next.item;
        node.next = node.next.next;
        N--;
        return item;
    }
    //返回第一个元素
    public int indexof(T t){
        Node node = head;
        for (int index=0;index<N;index++){
            if (node.item!=t){
                node = node.next;
            }else{
                return index;
            }
        }
        return -1;
    }
}

链表的缺点：不便于查找，查找消耗的时间太多，起码为查找的位置i；
测试顺序表:

package wh1006.datastructure.test;

import wh1006.datastructure.SequenceList;

public class SequenceListTest {
    public static void main(String[] args) {
        SequenceList<String> sl = new SequenceList<>(10);
        //测试插入
        sl.insert("姚明");
        sl.insert("科比");
        sl.insert("库里");
        sl.insert(1,"詹姆斯");
        sl.insert("姚明");
        sl.insert("科比");
        sl.insert("库里");
        sl.insert("詹姆斯");
        sl.insert("姚明");
        sl.insert("科比");
        sl.insert("字母歌");
        //测试获取
        for (String s:sl
             ) {
            System.out.println(s);
        }
//        sl.printSe();
//        String s = sl.get(1);
//        System.out.println(s);
//        String remove = sl.remove(0);
//        System.out.println("被删除的元素是："+remove);
//        sl.clear();
//        System.out.println("清空后线性表中的元素个数为："+sl.length());
    }
}

链表的测试：

package wh1006.datastructure.test;

import wh1006.datastructure.SequenceList;
import wh1006.datastructure.train.LinkList;

public class LinkListTest {
    public static void main(String[] args) {
        LinkList<String> sl = new LinkList<>();
        //测试插入
        sl.insert("姚明");
        sl.insert("科比");
        sl.insert("库里");
        sl.insert("詹姆斯",2);
        sl.remove(4);
        for (int i = 0; i < sl.length(); i++) {
            System.out.print(sl.get(i)+" ");
        }
    }

}