leetcode常规算法题复盘（基础篇）——线性表java实现

根据清华大学出版社的《数据结构及应用算法教程》第二章内容，线性表包括顺序存储模式及链式存储模式，以下为根据书中内容通过java语言实现的顺序表及链表。

其中元素类型通过泛型化进行约束。

此处特别鸣谢CSDN爪 哇大佬的博客，地址：https://blog.csdn.net/qq_40794973/article/details/101555091?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_baidulandingword-3&spm=1001.2101.3001.4242

顺序表：

import java.util.Arrays;
/**
 * 顺序线性表的实现
 */
public class LineList<E>{
　　private int size;   //长度
　　private Object[] array;  //底层数组
　　private final int default_length=16; //默认长度
 /**
  * 无参构造方法
  */
　　public LineList(){
　　　　size = 0;
  //使用默认长度构造数组
　　　　array = new Object[default_length];
 16　　 }
 /**
  * 指定长度进行构造
  * @param length 指定初始长度
  */
 public LineList(int length){
  if(length<0){
   throw new IllegalArgumentException("初始长度不合法:"+length);
  }
  //使用指定长度构造数组
  array = new Object[length];
 }

 /**
  * 指定初始化元素和长度进行构造
  * @param element 初始化元素
  * @param length 初始化长度
  */
 public LineList(E element,int length){
  if(length<1){
   throw new IllegalArgumentException("初始长度不合法:"+length);
  }
  //使用指定长度构造数组
  array = new Object[length];
  //初始化第一个元素
  array[0] = element;
  size++;
 }
 /**
  * 指定初始化元素进行构造
  * @param element 初始化元素
  */
 public LineList(E element){
  //使用默认长度初始化数组
  array = new Object[default_length];
  //初始化第一个元素
  array[0] = element;
 }

 /**
  * 获取元素个数
  */
 public int size() {
  return size;
 }

 /**
  * 判断是否为空
  */
 public boolean isEmpty() {
  return size==0;
 }

 /**
  * 判断是否包含此元素
  */
 public boolean contains(E e) {
  if(indexOf(e) == -1){
   return false;
  }
  return true;
 }

 /**
  * 格式化为数组
  */
 public Object[] toArray() {
  return Arrays.copyOf(array, size);
 }

 /**
  * 向线性表尾部添加一个元素
  * @param e
  * @return
  */
 public void add(E e) {
  extendCapacity(size+1);
  array[size]=e;
  size++;
 }

 /**
  * 扩容
  * @param length 需要的长度
  */
 private void extendCapacity(int length){
  //当前数组长度和需要的长度取最大
  int minCapacity = Math.max(array.length, length);
  //判断是否需要扩容
  if(minCapacity - array.length>0){
   //数组长度增加一半
   int newLength = array.length + array.length/2;
   //如果新的长度还比需求要小,将需求的长度作为数组长度
   if(newLength < minCapacity){
    newLength=minCapacity;
   }
   //数组长度不能超过Integer.Max_Value
   if(newLength > Integer.MAX_VALUE - 8){
    newLength = Integer.MAX_VALUE;
   }
   //数组扩容
   array = Arrays.copyOf(array, newLength);
  }
 }
 /**
  * 从线性表中移除所有此元素
  * @param e 需要移除的元素
  * @return
  */
 public void removeAll(E e) {
  if(e==null){
   for(int i=0;i<size;i++){
    if(array[i]==null){
     fastRemove(i);
    }
   }
  }else{
   for(int i=0;i<size;i++){
    if(e.equals(array[i])){
     fastRemove(i);
    }
   }
  }
 }

 /**
  * 删除索引处元素,后面的元素依次前移
  * @param index 需要删除的索引
  */
 private void fastRemove(int index){
  if(size-index-1>0){  
   //数组从index+1开始全部前移
   System.arraycopy(array, index+1, array, index, size-1);
  }
  //最后一个元素请空
  array[--size]=null;
 }

 /**
  * 清空线性表
  */
 public void clear() {
  //将数组全部填充为null
  Arrays.fill(array, null);
  //将元素个数改为0
  size=0;
 }
 /**
  * 获得索引处的元素
  * @param index
  * @return 索引处的元素
  */
 @SuppressWarnings("unchecked")
 public E get(int index) {
  checkIndex(index);
  return (E)array[index];
 }

 /**
  * 验证是否为索引越界
  * @param index
  */
 private void checkIndex(int index){
  if(index>=size || index<0){
   throw new IndexOutOfBoundsException("索引越界");
  }
 }

 /**
  * 将索引处的元素修改为新的元素
  * @param index 索引位置
  * @param element 元素
  * @return 原索引处的元素
  */
 @SuppressWarnings("unchecked")
 public E set(int index, E element) {
  checkIndex(index);
  E e = (E)array[index];
  array[index]=element;
  return e;
 }

 /**
  * 在指定的索引处插入指定的元素
  * @param index 索引位置
  * @param element 元素
  */
 public void add(int index, E element) {
  //验证索引
  checkIndex(index);
  //是否需要扩容
  extendCapacity(size+1);
  //复制数组
  System.arraycopy(array, index, array, index+1, size-index);
  array[index]=element;
 }

 /**
  * 移除索引处的元素
  * @param index 索引
  * @return 删除了的元素
  */
 @SuppressWarnings("unchecked")
 public E remove(int index) {
  checkIndex(index);
  //取得索引位置的元素
  E e = (E)array[index];
  fastRemove(index);
  return e;
 }

 /**
  * 取得元素第一次出现的位置的索引
  * @param e 要查找的元素
  * @return 如果为-1说明线性表没有这个元素
  */
 public int indexOf(E e) {
  if(e==null){//注意此处e==null的含义是传入了一个值为空的e值，但e并不是没有，还是应该在Object array里寻找同样为空的位置。
   for(int i=0;i<size;i++){
    if(e==array[i]){
     return i;
    }
   }
  }
  for(int i=0;i<size;i++){
   if(e.equals(array[i])){
    return i;
   }
  }
  return -1;
 }

 /**
  * 取得元素最后一次出现的位置的索引
  * @param e 要查找的元素
  * @return 如果为-1说明线性表没有这个元素
  */
 public int lastIndexOf(E e) {
  //判断元素是否为null
  if(e==null){    
   for(int i=size-1;i>=0;i--){
    if(e==array[i]){
     return i;
    }
   }
  }
  for(int i=size-1;i>=0;i--){
   //如果为null这里会跑出NullPoint异常
   //所以前面要加上验证是否为Null
   if(e.equals(array[i])){
    return i;
   }
  }
  return -1;
 }

 /**
  * 截取线性表
  * @param fromIndex 开始索引
  * @param toIndex 结束索引
  * @return 截取的线性表
  */
 @SuppressWarnings("unchecked")
 public LineList<E> subList(int fromIndex, int toIndex) {
  //判断开始索引是否越界
  if(fromIndex<0 || fromIndex >=size){
   throw new IndexOutOfBoundsException("开始索引越界:"+fromIndex);
  }
  //判断结束索引是否越界
  if(toIndex >=size || fromIndex <0){
   throw new IndexOutOfBoundsException("结束索引越界:"+toIndex);
  }
  //判断开始索引和结束索引是否正确
  if(fromIndex > toIndex){
   throw new IllegalArgumentException("参数不正确,开始索引应大于等于结束索引");
  }
  LineList<E> list = new LineList<E>();
  for(int i=fromIndex,j=toIndex;i<=j;i++){
   list.add((E)array[i]);
  }
  return list;
 }
}

 链表：

①用常规方式实现有虚拟头结点的链表

public class LinkedList<E> {
    private class Node {
        public E e;
        public Node next;
        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }
        public Node(E e) {
            this(e, null);
        }
        public Node() {
            this(null, null);
        }
        @Override
        public String toString() {
            return e.toString();
        }
    }
    private Node dummyHead;
    private int size;
    public LinkedList() {
        dummyHead = new Node();
        size = 0;
    }
    // 获取链表中的元素个数
    public int getSize() {
        return size;
    }
    // 返回链表是否为空
    public boolean isEmpty() {
        return size == 0;
    }
    // 在链表的index(0-based)位置添加新的元素e
// 在链表中不是一个常用的操作，练习用
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }
        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        prev.next = new Node(e, prev.next);
        size++;
    }
    // 在链表头添加新的元素e
    public void addFirst(E e) {
        add(0, e);
    }
    // 在链表末尾添加新的元素e
    public void addLast(E e) {
        add(size, e);
    }
    // 获得链表的第index(0-based)个位置的元素
// 在链表中不是一个常用的操作，练习用：
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Get failed. Illegal index.");
        }
        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.e;
    }
    // 获得链表的第一个元素
    public E getFirst() {
        return get(0);
    }
    // 获得链表的最后一个元素
    public E getLast() {
        return get(size - 1);
    }
    // 修改链表的第index(0-based)个位置的元素为e
    // 在链表中不是一个常用的操作，练习用：
    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Set failed. Illegal index.");
        }
        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        cur.e = e;
    }
    // 查找链表中是否有元素e
    public boolean contains(E e) {
        Node cur = dummyHead.next;
        while (cur != null) {
            if (cur.e.equals(e)) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    // 从链表中删除index(0-based)位置的元素, 返回删除的元素
    // 在链表中不是一个常用的操作，练习用
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Remove failed. Index is illegal.");
        }
        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        Node retNode = prev.next;
        prev.next = retNode.next;
        retNode.next = null;
        //疑问：这里为什么不释放结点retNode？
        size--;
        return retNode.e;
    }
    // 从链表中删除第一个元素, 返回删除的元素
    public E removeFirst() {
        return remove(0);
    }
    // 从链表中删除最后一个元素, 返回删除的元素
    public E removeLast() {
        return remove(size - 1);
    }
    // 从链表中删除元素e
    public void removeElement(E e) {
        Node prev = dummyHead;
        while (prev.next != null) {
            if (prev.next.e.equals(e)) {
                break;
            }
            prev = prev.next;
        }
        if (prev.next != null) {
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size--;
        }
    }
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        //Node cur = dummyHead.next;
        //while(cur != null){
        //    res.append(cur + "->");
        //    cur = cur.next;
        //}
        for(Node cur = dummyHead.next ; cur != null ; cur = cur.next) {
            res.append(cur + "->");
        }
        res.append("NULL");
        return res.toString();
    }
　　}

 ②用递归的方式实现链表

/**
 * Recursion
 */
public class LinkedListR<E> {
    private class Node {
        public E e;
        public Node next;
        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }
        public Node(E e) {
            this(e, null);
        }
        public Node() {
            this(null, null);
        }
        @Override
        public String toString() {
            return e.toString();
        }
    }
 
    // 在链表的递归实现中，我们不使用虚拟头结点，也能无差异的处理位置0的问题：
    private Node head;
    private int size;
    public LinkedListR() {
        head = null;
        size = 0;
    }
    // 获取链表中的元素个数
    public int getSize() {
        return size;
    }
    // 返回链表是否为空
    public boolean isEmpty() {
        return size == 0;
    }
    // 在链表的index(0-based)位置添加新的元素e
    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }
        head = add(head, index, e);
        size++;
    }
    // 在以node为头结点的链表的index位置插入元素e，递归算法
    private Node add(Node node, int index, E e) {
        if (index == 0) {
            return new Node(e, node);
        }
        node.next = add(node.next, index - 1, e);
        return node;
    }
    // 在链表头添加新的元素e
    public void addFirst(E e) {
        add(0, e);
    }
    // 在链表末尾添加新的元素e
    public void addLast(E e) {
        add(size, e);
    }
    // 获得链表的第index(0-based)个位置的元素
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Get failed. Illegal index.");
        }
        return get(head, index);
    }
    // 在以node为头结点的链表中，找到第index个元素，递归算法
    private E get(Node node, int index) {
        if (index == 0) {
            return node.e;
        }
        return get(node.next, index - 1);
    }
    // 获得链表的第一个元素
    public E getFirst() {
        return get(0);
    }
    // 获得链表的最后一个元素
    public E getLast() {
        return get(size - 1);
    }
    // 修改链表的第index(0-based)个位置的元素为e
    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Update failed. Illegal index.");
        }
        set(head, index, e);
    }
    // 修改以node为头结点的链表中，第index(0-based)个位置的元素为e，递归算法
    private void set(Node node, int index, E e) {
        if (index == 0) {
            node.e = e;
            return;
        }
        set(node.next, index - 1, e);
    }
    // 查找链表中是否有元素e
    public boolean contains(E e) {
        return contains(head, e);
    }
    // 在以node为头结点的链表中，查找是否存在元素e，递归算法
    private boolean contains(Node node, E e) {
        if (node == null) {
            return false;
        }
        if (node.e.equals(e)) {
            return true;
        }
        return contains(node.next, e);
    }
    // 从链表中删除index(0-based)位置的元素, 返回删除的元素
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Remove failed. Index is illegal.");
        }
        Pair<Node, E> res = remove(head, index);
        size--;
        head = res.getKey();
        return res.getValue();
    }
    // 从以node为头结点的链表中，删除第index位置的元素，递归算法
    // 返回值包含两个元素，删除后的链表头结点和删除的值：）
    private Pair<Node, E> remove(Node node, int index) {
        if (index == 0) {
            return new Pair<>(node.next, node.e);
        }
        Pair<Node, E> res = remove(node.next, index - 1);
        node.next = res.getKey();
        return new Pair<>(node, res.getValue());
    }
    // 从链表中删除第一个元素, 返回删除的元素
    public E removeFirst() {
        return remove(0);
    }
    // 从链表中删除最后一个元素, 返回删除的元素
    public E removeLast() {
        return remove(size - 1);
    }
    // 从链表中删除元素e
    public void removeElement(E e) {
        head = removeElement(head, e);
    }
    // 从以node为头结点的链表中，删除元素e，递归算法
    private Node removeElement(Node node, E e) {
        if (node == null) {
            return null;
        }
        if (node.e.equals(e)) {
            size--;
            return node.next;
        }
        node.next = removeElement(node.next, e);
        return node;
    }
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        Node cur = head;
        while (cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL");
        return res.toString();
    }
}