栈的特点：后进先出，所以一个线性链表实现的栈也只能在一端操作才能满足这种特性；


/**
 * @Author: zzz
 * @CreateTime: 2017/3/27 14:51
 * @Description:
 */
public class MyStack<T> {

    private Node top;//永远指向栈顶元素
 //元素个数
 private int size;


    /**
     * 内部类，定义节点
 */
 private class Node {
        public T data;

        public Node next;

        public Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }

    }

    public void push(T data) {
        //next 指向当前元素top,如果是第一个元素next 指向null;
 Node node = new Node(data, top);
        //把当前元素指向top
 top = node;
        size++;
    }


    public T pop() {
        Node oldNode = top;
        top = top.next;
        oldNode.next = null;
        //释放引用
 return oldNode.data;
    }

    //返回栈顶的元素，但不出栈
 public T peek() {
        return top.data;

    }

    // 判断链栈是否为空栈
 public boolean empty() {
        return size == 0;
    }

    public String toString() {
        // 链栈为空链栈时
 if (empty())
            return "[]";
        else {
            StringBuilder sb = new StringBuilder("[");
            for (Node current = top; current != null; current = current.next) {
                sb.append(current.data.toString() + ", ");
            }
            int len = sb.length();
            return sb.delete(len - 2, len).append("]").toString();

        }
    }

    public static void main(String[] args) throws Exception {
        MyStack stack = new MyStack<String>();
        for (int i = 0; i <= 10; i++) {
            stack.push("111111-" + i);
        }
        System.out.println(stack);
        System.out.println("frist pop="+stack.pop());
        System.out.println("second pop="+stack.pop());
        System.out.println("thrid pop="+stack.pop());
        System.out.println("pop 之后的"+stack);
    }

/**
 * Created by zz.zhang on 2018/1/4.
 */
public class MyStack<T> {

    private int DEFAULT_SIZE = 8;//定义栈的初始默认长度
    private int capacity;//保存顺序栈的长度
    private int size;//保存顺序栈中元素的个数
    private Object[] elementData;//定义一个数组用于保存顺序栈中的元素

    public MyStack() {
        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];
    }

    public MyStack(int initSize) {
        capacity = 1;
        while (capacity < initSize) {
            capacity <<= 1;//将capacity设置成大于initSize的最小2次方
        }
        elementData = new Object[capacity];
    }

    public void push(T element) throws Exception {
        elementData[size++] = element;
    }

    public T pop() throws Exception {
        if (empty()) {
            throw new IndexOutOfBoundsException("栈空，不能出栈");
        }
        T oldValue = (T) elementData[size - 1];
        elementData[--size] = null; // 设置成null 让JVM垃圾回收
        return oldValue;
    }
public boolean empty() {
        return size == 0;
    }

    //返回当前顺序栈中元素的个数
    public int length() {
        return size;
    }

    //获取栈顶元素，不会将栈顶元素删除
    public T peek() throws Exception {
        if (size == 0)
            throw new ArrayIndexOutOfBoundsException("栈为空");
        return (T) elementData[size - 1];
    }

    public void clear() {
        for (int i = 0; i < size; i++) {
            elementData[i] = null;
        }
        size = 0;
    }

    public static void main(String[] args)throws Exception{
        MyStack<String> stack=new MyStack<String>(30);
        for(int i=0 ;i<30;i++){
            stack.push(String.valueOf(i));
        }
        System.out.println(stack.pop());
        System.out.println(stack.peek());
    }
}

hash算法 (hashmap 实现原理)

HASH 主要用于信息安全领域中加密算法，它把一些不同长度的信息转化成杂乱的128 位的编码, 这些编码值叫做HASH 值. 也可以说，hash 就是找到一种数据内容和数据存放地址之间的映射关系

例如字符串 hello 的哈希算法

char* value = "hello"; int key = (((((((27* (int)'h'+27)* (int)'e') + 27) 　* (int)'l') + 27) * (int)'l' +27) * 27 ) + (int)'o' ;。

 

  数组的特点是：寻址容易，插入和删除困难；而链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易 的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法—— 拉链法，我们可以理解为“ 链表 的数组” ，如图：

 

 

 

HashMap其实也是一个线性的数组实现的,所以可以理解为其存储数据的容器就是一个线性数组。这可能让我们很不解，一个线性的数组怎么实现按键值对来存取数据呢？这里HashMap有做一些处理。

    1.首先HashMap里面实现一个静态内部类Entry 其重要的属性有 key , value, next,从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean,我们上面说到HashMap的基 础就是一个线性数组,这个数组就是Entry[]，Map里面的内容都保存在Entry[]里面。

     2.既然是线性数组，为什么能随机存取？这里HashMap用了一个小算法，大致是这样实现：

 

Java代码  

1. 存储时:  
2.   
3. int hash = key.hashCode();--> 这个hashCode方法这里不详述,只要理解每个key的hash是一个固定的int值  
4.   
5. int index = hash % Entry[].length;  
6.   
7. Entry[index] = value;  
8.   
9. 取值时:  
10.   
11. int hash = key.hashCode();  
12.   
13. int index = hash % Entry[].length;  
14.   
15. return Entry[index]  

 

到这里我们轻松的理解了HashMap通过键值对实现存取的基本原理

    3.疑问：如果两个key通过hash % Entry[].length得到的index相同，会不会有覆盖的危险？

这里HashMap里面用到链式数据结构的一个概念.上面我们提到过Entry类里面有一个next属性,作用是指向下一个Entry。打个比方, 第一个键值对A进来,通过计算其key的hash得到的index=0，记做:Entry[0] = A.一会后又进来一个键值对B,通过计算其index也等于0,现在怎么办？HashMap会这样做:B.next = A,Entry[0] = B,如果又进来C,index也等于0,那么C.next = B,Entry[0] = C；这样我们发现index=0的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起。所以疑问不用担心。

到这里为止，HashMap的大致实现，我们应该已经清楚了。

当然HashMap里面也包含一些优化方面的实现，这里也啰嗦一下。

比如：Entry[]的长度一定后，随着map里面数据的越来越长，这样同一个index的链就会很长，会不会影响性能？

HashMap里面设置一个因素（也称为因子），随着map的size越来越大，Entry[]会以一定的规则加长长度。

 

 

解决hash冲突的办法

1）开放定址法（线性探测再散列，二次探测再散列，伪随机探测再散列）

2）再哈希法

3）链地址法

4）建立一 公共溢出区

 

java 中hashmap的解决办法就是采用的链地址法
转载文章