Java算法常用数据结构

1、Stack栈

栈最大的一个特点就是先进后出，我们也可以使用栈来解决一些问题，例如反向输出链表，通过遍历链表，把遍历到的数据存储再栈里面，等遍历完成之后，再把栈里面的数据一一取出来。

（1）构造栈 new Stack < T >();

public stack();

例子：

import java.util.Stack;

Stack<Integer> stack = new Stack<>();

（2）判空 empty();

public boolean empty()//测试此堆栈是否为空。 
//结果 
//true当且仅当此堆栈不包含项目时; false否则。

例子：

import java.util.Stack;

Stack<Integer> stack = new Stack<>();
System.out.println(stack.empty());

其实我一直用的都是isEmpty，但是不知道他们有什么区别

（3）压栈 push()

public E push(E item)

例子：

import java.util.Stack;

Stack<Integer> stack = new Stack<>();
//压栈
stack.push(1);
System.out.println(stack.empty());

（4）查看栈顶的元素 peek()

public E peek()//查看此堆栈顶部的对象，而不从堆栈中删除它。 

例子：

import java.util.Stack;

Stack<Integer> stack = new Stack<>();
//压栈
stack.push(1);
System.out.println(stack.peek());
System.out.println(stack.empty());

（5）出栈pop()

public E pop()//删除此堆栈顶部的对象，并将该对象作为此函数的值返回。

例子：

import java.util.Stack;

Stack<Integer> stack = new Stack<>();
//压栈
stack.push(1);
System.out.println(stack.empty());
stack.peek();
System.out.println(stack.empty());
stack.pop();
System.out.println(stack.empty());

（6）查找元素再栈中的位置search()

public int search(Object o)
//返回一个对象在此堆栈上的基于1的位置。 
//如果对象o作为该堆栈中的项目发生，则该方法返回距堆栈顶部最靠近堆栈顶部的距离; 
//堆栈中最上面的项目被认为是距离1 。 equals方法用于比较o与此堆栈中的项目。 

//参数 
//o - 所需对象。 

//结果 
//从该对象所在的堆栈顶部的基于1的位置; 返回值-1表示对象不在堆栈上。 

例子：

import java.util.Stack;

Stack<Integer> stack = new Stack<>();
//压栈
stack.push(1);
System.out.println(stack.empty());
System.out.println(stack.search(1));

（7）常见应用

1、输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode==null || listNode.next==null){
            return new ArrayList<Integer>();
        }
        Stack<Integer> stack=new Stack<Integer>();
        while(listNode.next!=null) {
			stack.push(listNode.val);
            listNode=listNode.next;
		}
        stack.push(listNode.val);
        ArrayList<Integer> list=new ArrayList<Integer>();
        while(!stack.isEmpty()) {
        	list.add(stack.pop());
        }
        return list;
    }
}

2、用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
    	//首先要判断stack2里面是否为空栈，如果不是的话，先把stack里面的栈先空出来
    	if(!stack2.isEmpty()) {
    		return stack2.pop();
    	}else {
    		while(!stack1.isEmpty()) {
    			stack2.push(stack1.pop());
    		}
    		return stack2.pop();
    	}
    	
    }
}

2、Queue队列

返回类型	方法	说明
boolean	add(E e)	将指定的元素插入到此队列中，如果可以立即执行此操作，而不会违反容量限制， true在成功后返回 IllegalStateException如果当前没有可用空间，则抛出IllegalStateException。
E	element()	检索，但不删除，这个队列的头。
boolean	offer(E e)	如果在不违反容量限制的情况下立即执行，则将指定的元素插入到此队列中。
E	peek()	检索但不删除此队列的头，如果此队列为空，则返回 null 。
E	poll()	检索并删除此队列的头，如果此队列为空，则返回 null 。
E	remove()	检索并删除此队列的头。

其中offer和add相对，peek和element相对

这里的Queue是一个接口，已知常用的实现类LinkedList、ArrayQueue

2（1）LinkedList

（1）构造队列 new LinkedList< T >()

（2）添加元素add

（2）删除元素remove

（3）入队出队

（4）迭代器iterator

由于拓展的太多了，这里不一一写了，拓展的LinkedList可以实现单向队列，双向队列，还可以实现栈，功能十分强大

（5）常见应用

import java.util.LinkedList;
import java.util.Queue;
 
public class Main {
    public static void main(String[] args) {
        //add()和remove()方法在失败的时候会抛出异常(不推荐)
        Queue<String> queue = new LinkedList<String>();
        //添加元素
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("element="+queue.element()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("peek="+queue.peek()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
    }
}

a
b
c
d
e
===
poll=a
b
c
d
e
===
element=b
b
c
d
e
===
peek=b
b
c
d
e

2（2）ArrayDeque

与LinkedList不同的地方在于，LinkedList是一个链表，二ArrayDeque是一个数组，初始容量容纳16个元素

（1）构造函数

（2）常见API

3、List列表

同样的也有多个拓展，常见的为ArrayList，LinkedList

3（1）ArrayList

构造一个初始值为10的空列表

（1）构造函数

（2）添加元素

（3）删除元素

（4）常见应用

3（2）LinkedList（见上面，不再赘述）

4、StringBuilder StringBuffer

StringBuffer 和StringBuilder其实是一样的东西，区别在于StringBuilder是线程不安全的，而StringBuffer是线程安全的

（1）构造函数

（2）追加

（3）插入

（4）删除指定

（5）定位某个字符

（6）常见应用

5、Map

Map的实现类一般有HashMap、、HashTable、ConcurrentHashMap

5（1）HashMap

（1）构造函数

（2）常用API

//清空所有
clear();
//克隆一份，注意浅拷贝和深拷贝
clone();
//放入
put(K key,V val);
//取出
get(K key);
//判空
isEmpty();
//数量
size();

6、Set

同样是KV形式的，和Map的区别在于，Set的值不能重复

（1）构造函数

（2）常用API