Java常见的数据结构

集合

MsArrayList

定义一个全局数组Object[] elementData;，是为了保存数据，但是不初始化。当我们new一个对象的时候才初始化。
定义集合的大小Integer size = 0 ,这个大小不是数组的大小。
add(T element)
add(Integer index,T element)
remove(Integer index)
T get(Integer index)

package com.shengun.list;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

/**
 * 模拟ArrayList
 * @param <T>
 */
public class MsArrayList<T> implements Iterable<T> {

    //定义一个空数组
    private Object[] elementData;
    //链表元素大小
    private Integer size = 0;

    /**
     * 有参数构造
     * @param capacity
     */
    public MsArrayList(int capacity){
        //初始化容量
        elementData = new Object[capacity];
    }

    /**
     * 无参数构造
     */
    public MsArrayList() {
        elementData = new Object[10];
    }

    /**
     * 添加元素方法
     */
    public void add(T element){
        checkCapacity();
        elementData[size] = element;
        size++;
    }

    /**
     * 指定位置添加元素
     */
    public void add(Integer index, T element) {
        checkIndex(index);
        checkCapacity();
        //判断元素是否是最后一个
        if(index == size - 1){
            elementData[size] = element;
        }else{
            System.arraycopy(elementData, index, elementData, index + 1, size - index);
            elementData[index] = element;
        }
        size++;
    }

    /**
     * 指定元素删除元素
     */
    public void remove(Integer index) {
        checkIndex(index);
        System.arraycopy(elementData, index + 1, elementData, index, size - index);
        elementData[--size] = null;
    }


    /**
     * 判断是否需要扩容
     */
    public void checkCapacity(){
        //判断是否需要扩容
        if(size <= elementData.length){
            //需要扩容
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }


    /**
     * 获取元素
     */
    public T get(Integer index) {
        checkIndex(index);
        return (T) elementData[index];
    }

    /**
     * 判断元素是否超限
     * @param index
     */
    public void checkIndex(Integer index) {
        if(index < 0 || index > size){
            throw new RuntimeException("元素超限");
        }
    }

    /**
     * 返回size
     */
    public Integer getSize(){
        return size;
    }


    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(1, 2);
        list.remove(1);

        MsArrayList<String> ms = new MsArrayList<String>();
        ms.add("12");
        ms.add("123");
        ms.add("123456");
        ms.add(1,"10");
        ms.add(4,"10");
//        ms.add(0,"10000");
        ms.remove(0);
        ms.remove(3);
        ms.remove(1);
//        System.out.println(ms.get(0));
//        System.out.println(ms.get(3));
//        System.out.println(ms.get(5));
        Iterator<String> iterator = ms.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }


    }


    @Override
    public Iterator<T> iterator() {
        return new MsIterator();
    }

    class MsIterator implements Iterator<T> {
        int index = 0;

        @Override
        public boolean hasNext() {
            return index != size;
        }

        @Override
        public T next() {
            return (T) elementData[index++];
        }

    }
}

TMsLinkedList

package com.shengun.list;

import java.util.Iterator;

public class MsLinkedList<T> implements Iterable<T> {

    /**
     * 节点
     */
    class Node<E>{
       E item;
       Node<E> prev;
       Node<E> next;

       Node(Node<E> prev,E item,Node<E> next){
            this.item = item;
            this.prev = prev;
            this.next = next;
       }
    }

    //链表大小
    private int size = 0;
    //头节点
    private Node<T> first;
    //为节点
    private Node<T> last;

    //添加节点
    public void add(T element) {
        Node<T> l = last;
        //直接添加在节点尾部
        //新的节点
        Node<T> newNode = new Node<>(l,element,null);
        last = newNode;
        if(l == null){
            //第一个元素
            first = newNode;
        }else{
            //否则不是第一个，他的下一个节点的元素指向新的节点
            l.next = newNode;
        }
        size++;
    }

    /**
     * 添加节点
     */
    public void add(int index,T element) {
        if(index <0|| index > size){
            throw new RuntimeException("索引超限");
        }
        if(index == size){
            add(element);
        }else{
            Node<T> oldValue = node(index);
            Node<T> pre = oldValue.prev;
            Node<T> newNode = new Node<>(pre, element, oldValue);
            oldValue.prev = newNode;
            if(pre == null){
                //代表是第一个元素
                first = newNode;
            }else{
                pre.next = newNode;
            }
            size++;
        }
    }

    /**
     * 指定位置元素替换
     */
    public T set(int index, T element) {
        checkIndex(index);
        //原来元素的位置
        Node<T> x = node(index);
        T oldVale = x.item;
        x.item = element;
        return oldVale;
    }

    /**
     * 根据元素下标找到指定的元素
     */
    public T get(int index){
        checkIndex(index);
       return node(index).item;
    }

    /**
     * 校验索引
     *
     * @param index
     */
    private void checkIndex(int index) {
        if(index < 0 || index >= size){
            throw new RuntimeException("索引超限");
        }
    }

    /**
     * 遍历节点
     * @param index
     * @return
     */
    private Node<T> node(int index){
        //二分遍历
        if(index < (index << 1)){
            Node<T> x = first;
            //从头部开始遍历
            for (int i = 0; i < index; i++) {
                x = x.next;
            }
            return x;
        }else{
            Node<T> x = last;
            for (int i = size - 1; i > index; i--) {
                x =  x.prev;
            }
            return x;
        }
    }


    public static void main(String[] args) {
//        LinkedList last = new LinkedList();
//        last.get(1);
//        last.set(1, "2");
//        last.add(1, "2");
        MsLinkedList<String> list = new MsLinkedList<>();
        list.add("0");
        list.add("1");
        list.add("2");
//        list.set(3, "2");
        list.add(0, "000000");
        list.add(2, "222222222222");
        list.add(5,"666666666666");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    @Override
    public Iterator<T> iterator() {
        return new MsIterator();
    }

    class MsIterator implements Iterator<T> {
        int index = 0;

        @Override
        public boolean hasNext() {
            return index != size;
        }

        @Override
        public T next() {
            return get(index++);
        }
    }


}

队列

ArrayQueue

package com.shengun.queue;

import java.util.Arrays;

/**
 * 先进先出
 */
public class ArrayQueue<T> {

    //第一个元素下标
    private int head = 0;
    //最后一个元素下标
    private int tail = 0;

    private Object[] elementData;

    public ArrayQueue(){
        elementData = new Object[10];
    }

    /**
     * 入队列
     * 队列是从尾部开始入
     */
    public boolean enQueue(T element){
        if(tail <= elementData.length){
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity << 1;
            //需要扩容
            elementData = Arrays.copyOf(elementData, newCapacity);
            if(head != 0){
                //进行数据迁移
                if(tail - head > 0){
                    System.arraycopy(elementData, head, elementData, 0, tail - head);
                }
                tail = tail - head;
                head = 0;
            }
        }
        elementData[tail++] = element;
        return true;
    }

    /**
     * 出队列
     */
    public T deQueue() {
        if(head == tail){
            throw new RuntimeException("队列为空");
        }

        return (T) elementData[head++];
    }

    public static void main(String[] args) {
        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        arrayQueue.enQueue(1);
        arrayQueue.enQueue(2);
        arrayQueue.enQueue(3);
        arrayQueue.enQueue(4);

        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());

    }

}

LinkedQueue

package com.shengun.queue;

public class LinkedQueue<T> {

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

    //头节点
    private Node<T> head;
    //尾节点
    private Node<T> tail;
    private int size = 0;

    public LinkedQueue(){}


    /**
     * 入栈
     */
    public Boolean enQueue(T element) {
        //尾部插入
        Node<T> newNode = new Node<>(element, null);
        //如果尾节点为空
        if (tail == null) {
            //把新的值赋予为节点
            tail = newNode;
            //原来的尾节点就是新的头节点
            head = tail;
            size++;
            return true;
        }
        tail.next = newNode;
        tail = newNode;
        size++;
        return true;
    }

    /**
     * 出栈
     */
    public T dnQueue(){
        if(size == 0){
            throw new RuntimeException("栈为空");
        }
        Node<T> l = head;
        head = head.next;
        size --;
        return l.item;
    }

    public static void main(String[] args) {
        LinkedQueue<Integer> linkedQueue = new LinkedQueue<>();
        linkedQueue.enQueue(1);
        linkedQueue.enQueue(2);
        linkedQueue.enQueue(3);
        linkedQueue.enQueue(4);

        System.out.println(linkedQueue.dnQueue());
        System.out.println(linkedQueue.dnQueue());
        System.out.println(linkedQueue.dnQueue());
        System.out.println(linkedQueue.dnQueue());
        System.out.println(linkedQueue.dnQueue());


    }

}

栈

ArrayStack

package com.shengun.stack;

import java.util.Arrays;

public class ArrayStack<T> {

    /**
     * 数组啊实现的栈
     */
    private Object[] elementData;

    private int topIndex = 0;

    public ArrayStack(){
        elementData = new Object[10];
    }

    /**
     * 入栈
     */
    public boolean push(T element) {
        //判断栈顶元素
        if(topIndex>=elementData.length){
            int newCapacity = elementData.length<<1;
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
        elementData[topIndex++] = element;
        return true;
    }

    /**
     * 出战并删除栈顶元素
     */
    public T pop(){
        if(topIndex<=0){
            throw new RuntimeException("栈为空");
        }
        return (T)elementData[--topIndex];
    }

    /**
     * 出栈
     * @return
     */
    public T peek(){
        if(topIndex<=0){
            throw new RuntimeException("栈为空");
        }
        return (T) elementData[topIndex-1];
    }

    public static void main(String[] args) {
        ArrayStack<Integer> stack = new ArrayStack<>();
        stack.push(0);
        stack.push(1);
        stack.push(2);
        stack.push(3);

//        System.out.println(stack.peek());
//        System.out.println(stack.peek());

        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());


    }
}

LinkedStack

package com.shengun.stack;

public class LinkedStack<T> {

    class Node<E>{
        E item;
        Node<E> next;

        public Node(E item,Node<E> next){
            this.item = item;
            this.next = next;
        }
    }

    private Node<T> header;
    //记录数
    private int elementCount = 0;

    public LinkedStack(){}

    //入栈
    public void add(T element) {
        header = new Node<>(element, header);
        elementCount++;
    }

    //出战，并删除元素
    public T pop(){
        if(header == null){
            throw new RuntimeException("栈为空");
        }
        T element = header.item;
        //删除栈顶元素
        header = header.next;
        elementCount--;
        return element;
    }

    //出战
    public T peek(){
        if(header == null){
            throw new RuntimeException("栈为空");
        }
        T element = header.item;
        return element;
    }

    public static void main(String[] args) {
        LinkedStack<Integer> stack = new LinkedStack<>();
        stack.add(1);
        stack.add(2);
        stack.add(3);
        stack.add(4);

        System.out.println(stack.peek());
        System.out.println(stack.peek());
        System.out.println(stack.peek());
        System.out.println(stack.peek());

        System.out.println("#######################");
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());

    }
}

hash表

MsHashTable

package com.shengun.hash;

import java.util.HashMap;

public class MsHashTable<K,V> {

    class Node<K,V>{
        //hash值
        int hash;
        K key;
        V value;
        Node<K,V> next;

        public Node(int hash,K key,V value,Node<K,V> next){
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }

    private Node<K,V>[] table;

    public MsHashTable(){
        table = new Node[16];
    }

    public void set(K key, V value) {
        //计算hashcode值
        int hash = hash(key);
        //计算数组下标
        int i = (table.length - 1) & hash;
        Node<K, V> node = new Node<>(hash, key, value, null);
        //看下i位置是否存在值
        Node<K, V> kvNode = table[i];
        if(kvNode == null){
            table[i] = node;
            return;
        }
        //位置有数据
        if(kvNode.equals(key)){
            kvNode.value = value;
        }else{
            kvNode.next = node;
        }
    }

    public V get(K key) {
        //计算hashcode值
        int hash = hash(key);
        //计算数组下标
        int i = (table.length - 1) & hash;
        Node<K, V> node = table[i];
        if(node == null){
            return null;
        }
        Node<K,V> newNode = node;
        while (newNode.next != null) {
            if(newNode.key.equals(key)){
                break;
            }
            newNode = newNode.next;
        }
        return newNode.value;

    }

    private int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }



    public static void main(String[] args) {
        MsHashTable<Integer, String> ms = new MsHashTable<>();
        ms.set(1, "1");
        ms.set(2, "2");
        ms.set(3, "3");
        ms.set(4, "4");
        ms.set(5, "5");


        for (int i = 0; i < 5; i++) {
            System.out.println(ms.get(i));
        }

    }
}

斐波那契数列

Fibonacci

package com.shengun.suanfa;

public class Fibonacci {

    /**
     * 斐波那契数列
     */
    public int fibonacci(int n){
        if(n == 0){
            return 0;
        }else if(n == 1){
            return 1;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String[] args) {
        Fibonacci fibonacci = new Fibonacci();
        System.out.println(fibonacci.fibonacci(0));
        System.out.println(fibonacci.fibonacci(1));
        System.out.println(fibonacci.fibonacci(2));
        System.out.println(fibonacci.fibonacci(3));
        System.out.println(fibonacci.fibonacci(4));
        System.out.println(fibonacci.fibonacci(5));
    }
}

汉诺塔

Hanoi

package com.shengun.suanfa;

public class Hanoi {

    //移动次数
    int moveCount = 0;

    public void  move(int id,char src,char dist){
        System.out.println("第"+(++moveCount)+"次移动，将" + id +" 从" + src + "移动到" + dist);
    }

    /**
     * 将A上的东西移动到C上
     */
    public void hanoi(int n, char A, char B, char C) {
        if(n == 1){
            move(0,A,C);
        }else{
            hanoi(n - 1, A, C, B);
            move(n - 1, A, C);
            hanoi(n - 1, B, A, C);
        }
    }

    public static void main(String[] args) {
        Hanoi hanoi = new Hanoi();
        hanoi.hanoi(4, 'A', 'B', 'C');
    }

}