数据结构之List

数据结构学习之List的实现
先将数据结构的ADT简单抽出来，不是jdk中定义的List，只是一个类似的接口，只作为学习使用：

package com.dzlijian.utils.comments;
/**
 * 
 * @ClassName:  List   
 * @Description:数据结构列表的抽象数据结构ADT
 * @author: 长子科技 
 * @date:   2021年7月7日 下午10:36:11   
 *   
 * @param <E>  
 * @Copyright: 2021 www.tydic.com Inc. All rights reserved. 
 */
public interface List<E> {
	/*
	 * 获取元素个数
	 */
	public int getSize();
	/*
	 * 判断是否为空
	 */
	public boolean isEmpty();
	/*
	 * 判断是否包含
	 */
	boolean contains(E e);
	/*
	 * 获取某个元素的索引，
	 */
	
	public int indexof(E e);
	/*
	 * 获取指定位置的元素
	 */
	
	public E get(int index);
	/*
	 * 设置指定位置的元素
	 */
	
	public void set(int index,E e);
	/*
	 * 指定位置插入数据
	 */
	public void add(int index,E e);
	/*
	 * 删除指定位置的元素
	 */
	public E remove(int index);
}

1，使用数组实现List接口：
上代码：

package com.dzlijian.utils.comments;

import java.util.Arrays;
/**
 * 
 * @ClassName:  ArrayList   
 * @Description:动态数值。
 * @author: 长子科技 
 * @date:   2021年5月29日 下午5:31:01   
 *   
 * @param <E>  
 * @Copyright: 2021 www.tydic.com Inc. All rights reserved. 
 */


public class ArrayList<E> implements List<E> {
	
	private int size;
	
	private E[] data;
	
	private static final int DEFAULT_CAPACITY=10;

	@Override
	public int getSize() {
		return size;
	}

	@Override
	public boolean isEmpty() {
		return size==0;
	}

	@Override
	public boolean contains(E e) {
		for(int i=0;i<size;i++){
			if(data[i].equals(e)){
				return true;
			}
		}
		return false;
	}

	@Override
	public int indexof(E e) {
		for(int i=0;i<size;i++){
			if(data[i].equals(e)){
				return i;
			}
		}
		return -1;
	}

	@Override
	public E get(int index) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("下标越界。。。");
		}
		return data[index];
	}

	@Override
	public void set(int index, E e) {
		if(index<0||index>size){
			throw new IllegalArgumentException("下标越界。。。");
		}
		data[index]=e;
	}

	private void grow(int newCapacity){
		if(newCapacity<=DEFAULT_CAPACITY){
			return;
		}
		data=Arrays.copyOf(data, newCapacity);
	}
	@Override
	public void add(int index, E e) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("下标越界。。。");
		}
		if(size==data.length){
			grow(2*size);
		}
		
		for(int i=size-1;i<index;i--){
			data[i+1]=data[i];
		}
		data[index]=e;
		size++;
		
	}

	@Override
	public E remove(int index) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("下标越界。。。");
		}
		E val=data[index];
		for(int i=index-1;i<size;i++){
			data[i-1]=data[i];
		}
		data[size]=null;
		size--;
		if(size>(data.length>>1)){
			grow((data.length>>1));
		}
		return val;
	}

}

2，使用链表实现List：
代码：`package com.dzlijian.utils.comments;

/**
*

• @ClassName: LinkedList

• @Description:链表实现List接口

• @author: 长子科技

• @date: 2021年7月7日 下午10:35:23

• @param

• @Copyright: 2021 www.tydic.com Inc. All rights reserved.
  */
  public class LinkedList implements List {

  private static class Node{
  private E data;

   private Node<E> next;
   
   public Node(E e,Node<E> next){
   	data=e;
   	this.next=next;
   }
   public Node(E e){
   	this(e,null);
   }
  

  }

  private int size;

  private Node head;

  public LinkedList(){
  size=0;
  head=new Node(null, null);
  }

  @Override
  public int getSize() {
  return size;
  }

  @Override
  public boolean isEmpty() {
  return size==0;
  }

  @Override
  public boolean contains(E e) {
  if(e==null){
  throw new IllegalArgumentException(“非法参数。。。”);
  }
  Node pre=head;
  for(int i=0;i<size;i++){
  if(pre.data.equals(e)){
  return true;
  }
  }
  return false;
  }

  @Override
  public int indexof(E e) {
  if(e==null){
  throw new IllegalArgumentException(“非法参数。。。”);
  }
  Node pre=head;
  for(int i=0;i<size;i++){
  if(pre.data.equals(e)){
  return i;
  }
  }
  return -1;
  }

  @Override
  public E get(int index) {
  if(index<0||index>size){
  throw new IllegalArgumentException(“下标越界。。。”);
  }
  Node pre=head;
  for(int i=0;i<index;i++){
  pre=pre.next;
  }
  return pre.data;
  }

  @Override
  public void set(int index, E e) {
  if(index<0||index>size){
  throw new IllegalArgumentException(“下标越界。。。”);
  }
  Node pre=head;
  for(int i=0;i<index-1;i++){
  pre=pre.next;
  }
  pre.next=new Node(e,pre.next);

  }

  @Override
  public void add(int index, E e) {
  if(index<0||index>size){
  throw new IllegalArgumentException(“下标越界。。。”);
  }
  if(index0){
  addFirst(e);
  }else
  if(indexsize){
  addLast(e);
  }else{
  Node pre=head;
  for(int i=0;i<index;i++){
  pre=pre.next;
  }
  pre=new Node(e,pre.next);
  size++;
  }

  }

  @Override
  public E remove(int index) {
  if(index<0||index>size){
  throw new IllegalArgumentException(“下标越界。。。”);
  }
  if(index0){
  return removeFirst();
  }else if(indexsize){
  return removeLast();
  }else{
  Node pre=head;
  for(int i=0;i<index-1;i++){
  pre=pre.next;
  }
  Node temp=pre.next;
  pre.next=temp.next;
  size–;
  return temp.data;
  }
  }

  private void addFirst(E e){
  Node node=new Node(e,head);
  head=node;
  size++;
  }
  private void addLast(E e){
  Node newNode=new Node(e,null);
  if(head==null){
  head=newNode;
  }else{
  Node pre=head;
  while(pre.next!=null){
  pre=pre.next;
  }
  pre.next=newNode;
  }
  size++;
  }

  private E removeFirst(){
  if(size==0){
  return null;
  }
  Node node=head;
  head=head.next;
  size–;
  return node.data;
  }

  private E removeLast(){
  if(size0){
  return null;
  }
  if(size1){
  return removeFirst();
  }
  Node< E> pre=head;
  while(pre.next.next!=null){
  pre=pre.next;
  }
  Node result=pre.next;
  pre.next=null;
  size–;
  return result.data;
  }
  }
  `

代码比较简单，仅作为学习记录使用。