Java中顺序表和链表实现

一、顺序表的实现
顺序表需实现的接口

public class SeqList {
// 打印顺序表
public void display() { }
// 在 pos 位置新增元素
public void add(int pos, int data) { }
// 判定是否包含某个元素
public boolean contains(int toFind) { return true; }
// 查找某个元素对应的位置
public int search(int toFind) { return -1; }
// 获取 pos 位置的元素
public int getPos(int pos) { return -1; }
// 给 pos 位置的元素设为 value
public void setPos(int pos, int value) { }
//删除第一次出现的关键字key
public void remove(int toRemove) { }
// 获取顺序表长度
public int size() { return 0; }
// 清空顺序表
public void clear() { }
}

public class Seqlist {
    private int[] datas = new int[100];
    private int size = 0;
    public int getSize() {
        return size;
    }
    public void display() {
        String result = "[";
        for (int i = 0; i < size; i++) {
            result += datas[i];
            if (i < size - 1) {
                result += ",";
            }
        }
        result += "]";
        System.out.println(result);
    }
    public void add(int pos, int data) {
        if(pos < 0 || pos > size){
            return;
        }
        if (size >= datas.length) {
            int[] newDatas = new int[2 * datas.length];
            for (int i = 0; i < datas.length; i++) {
                newDatas[i] = datas[i];
            }
            datas = newDatas;
        }
        if (pos == size) {
            datas[pos] = data;
            size++;
            return;
        }
        for (int i = size - 1; i >= pos; i--) {
            datas[i + 1] = datas[i];
        }
        datas[pos] = data;
        size++;
    }
    public boolean contains(int toFind) {
        for (int i = 0; i < size; i++) {
            if (datas[i] == toFind) {
                return true;
            }
        }
        return false;
    }
    public int search(int toFind) {
        for (int i = 0; i < size; i++) {
            if (datas[i] == toFind) {
                return i;
            }
        }
        return -1;
    }
    public int getPos(int pos) {
        return datas[pos];
    }
    public void setPos(int pos, int data) {
        datas[pos] = data;
    }

    public void remove(int toRemove) {
        int pos = search(toRemove);
        if (pos == -1) {
            return;
        }
        if (pos == size - 1) {
            size--;
            return;
        }
        for (int i = pos; i < size - 1; i++) {
            datas[i] = datas[i + 1];
        }
        size--;
    }
    public void clear() {
        size = 0;
    }
}

二·、链表的实现

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

public class SingleLinkedList {

class Node {
   public int data;
   public Node next = null;
   public Node(int data) {
       this.data = data;
   }
}

   private Node head = null;
   public void addFirst(int data) {
       Node node = new Node(data);
       if (head == null) {
           head = node;
           return;
       }
       node.next = head;
       head = node;
   }

   public void addLast(int data) {
       Node node = new Node(data);
       if (head == null) {
           head = node;
           return;
       }
       Node tail = head;
       while (tail.next != null) {
           tail = tail.next;
       }
       tail.next = node;
   }

   public void display() {
       for (Node cur = head; cur != null; cur = cur.next) {
           System.out.print(cur.data + " ");
       }
       System.out.println();
   }

   public int getSize() {
       int size = 0;
       for (Node cur = head; cur != null; cur = cur.next) {
           size++;
       }
       return size;
   }

   public boolean addIndex(int index, int data) {
       int size = getSize();
       if (index < 0 || index > size) {
           return false;
       }
       if (index == 0) {
           addFirst(data);
           return true;
       }
       if (index == size) {
           addLast(data);
           return true;
       }
       Node node = new Node(data);
       Node prev = getPos(index - 1);
       node.next = prev.next;
       prev.next = node;
       return true;
   }

   private Node getPos(int index) {
       Node cur = head;
       for (int i = 0; i < index; i++) {
           cur = cur.next;
       }
       return cur;
   }

   public boolean contains(int toFind) {
       for (Node cur = head; cur != null; cur = cur.next) {
           if (cur.data == toFind) {
               return true;
           }
       }
       return false;
   }

   public void remove(int toRemove) {
       if (head.data == toRemove) {
           head = head.next;
           return;
       }
       Node prev = searchPrev(toRemove);
       Node toDelete = prev.next;
       prev.next = toDelete.next;
   }

   private Node searchPrev(int toRemove) {
       for (Node cur = head; cur != null
               && cur.next != null; cur = cur.next) {
           if (cur.next.data == toRemove) {
               return cur;
           }
       }
       return null;
   }
}

// 2、无头双向链表实现
public class DoubleLinkedList {
//头插法
public void addFirst(int data);
//尾插法
public void addLast(int data);
//任意位置插入,第一个数据节点为0号下标
public boolean addIndex(int index,int data);
//查找是否包含关键字key是否在单链表当中
public boolean contains(int key);
//删除第一次出现关键字为key的节点
public void remove(int key);
//删除所有值为key的节点
public void removeAllKey(int key);
//得到单链表的长度
public int size();
public void display();
public void clear();
}

public class DoubleLinkedList {

class Node{
    private int data;
    private Node next;
    private Node prev;

    public Node(int data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
}

    private Node head = null;
    private Node last = null;

    public void addFirst(int data) {
        Node node = new Node(data);
        if (head == null) {
            head = node;
            last = head;
            return;
        }
        node.next = head;
        head.prev = node;
        head = node;
    }

    public void addLast(int data){
        Node node = new Node(data);
        if(this.last == null){
            this.last = node;
            this.head = node;
        }else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }

    public int getLength(){
        Node cur = this.head;
        int len = 0;
        while(cur != null){
            len++;
            cur = cur.next;
        }
        return len;
    }

    public boolean addIndex(int index, int data){
        if(index < 0 || index > this.getLength()){
            System.out.println("插入位置非法！");
            return false;
        }
        if(index == 0){
            addFirst(data);
            return true;
        }
        if(index == this.getLength()) {
            addLast(data);
            return true;
        }
        Node node = new Node(data);
        Node cur = this.head;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.prev.next = node;
        node.next = cur;
        node.prev = cur.prev;
        cur.prev = node;
        return true;
    }

    public boolean contains(int key){
        Node cur = this.head;
        while(cur != null){
            if(cur.data == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    public boolean remove(int key) {
        if (this.head == null) {
            return false;
        }
        Node cur = this.head;
        while (cur != null) {
            if (cur.data == key) {
                if (cur == this.head) {
                    if (cur.next == null) {
                        this.head = this.last = null;
                    } else {
                        cur.next.prev = null;
                        this.head = cur.next;
                    }
                    return true;
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next == null) {
                        this.last = cur.prev;
                    } else {
                        cur.next.prev = cur.prev;
                        return true;
                    }
                }
                return true;
            }
            cur = cur.next;

        }
        return false;
    }
    public void removeAllKey(int key){
        if(this.head == null){
            return ;
        }
        Node cur = this.head;
        while (cur != null){
            if(cur.data == key){
                if(cur == this.head){
                    if(cur.next == null){
                        this.head = this.last = null;
                        return ;
                    }else {
                        cur.next.prev = null;
                        this.head = cur.next;
                    }
                }else {
                    cur.prev.next = cur.next;
                    if(cur.next == null){
                        this.last = cur.prev;
                    }else {
                        cur.next.prev = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

    public void clear(){
        while(this.head != null){
            Node cur = this.head.next;
            this.head.next = null;
            this.head.prev = null;
            this.head = cur;
        }
        this.last = null;
    }

    public void display(){
        if(this.head == null){
            System.out.println("链表为空！");
        }else {
            Node cur = this.head;
            while(cur != null){
                System.out.print(cur.data);
                System.out.print("->");
                cur = cur.next;
            }
            System.out.println();
        }
    }
}