JAVA数据结构及刷题算法_java算法刷题

一 创建数组 常用四种方式

1 int[] a = {1,2,3};

2 int[] b = new int[]{1,2,3};

3 int[] c = new int[3];(默认情况都是0）

4 ArrayList<integer> arr = new ArrayList<>();(不需要指定长度和元素）

二 添加元素

ArrayList<integer> arr = new ArrayList<>();//创建ArrayList对象

arr.add(99);//默认插在尾端，当末尾有内存地址可添加时，时间复杂度o（1）；当内存末尾没有内存地址时，需要重新申请内存，此时时间复杂度为o（n）。

arr.add(3,88) //第一个参数是索引，第二个参数是要插入的值。

三 访问元素 通过下标或者索引访问。时间复杂度o(1)

int c1 = c[1];

int arr1 = arr.get(1);

四 更新元素

c[1] = 11;

arr.set(1,11); //第一个参数为索引，第二个为数值

五 删除元素

arr.remove(3);//参数为要删除的元素

六 数组长度 时间复杂度为O(1);因为数组创建时会维持一个变量，调用方法时直接返回变量，而不是一个一个遍历

int cSize = c.length;

int arrSize = arr.size();

七 遍历数组 for循环

八 查找元素  时间复杂度o（n)

c1遍历查找

boolean is99 = arr.contains(99); //是否包含元素99

九 排序 时间复杂度O（N logN）

Array.sort（c);//默认从小到大排序

Collections.sort(arr);默认从小到大排序

从大到小排序

abc三种创建数组方式：

1 先sort排序，然后 从后往前读

2 将int[] c转化成Integer[] c，然后Collections.sort(arr,Collections.reverseOrder());//反向排序

链表list

创建 LinkedList<Integer> list = new LinkedList<>();

添加 list.add(0);//尾部添加

list.add(2,99)//第一个参数为插入的位置，第二个参数为插入元素的数值。

访问元素

list.get(2);//返回第二个元素的值

搜索元素

list.indexOf（99）;

更新元素

list.set(2,88);和add参数类似

删除元素

list.remove(2);删除第二个索引位置的元素

长度，时间复杂度o(1)

int length = list.size();长度

队列常用操作

创建队列

Queue<Integer> queue = new LinkedList<>();推荐用链表实现Queue，方便操作

添加元素

queue.add(元素)；

获取即将出队的元素(队列的头元素）

int templ = queue.peek();

删除即将出队的元素

int temp2 = queue.poll();//还有其他方法例如remove()等

判断队列是否为空（本质判断队列长度是否为0）

boolean a = queue.isEmpty();

队列长度

int len = queue.size();

遍历队列（一般边遍历边删除）

while（！queue.isEmpty()){

    int temp = queque.poll();

    System.out.println(temp);

}

栈常用操作

  1 创建栈，包含在stack中

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

2 添加元素

stack.push(1);
stack.push(2);
System.out.println(stack.toString());

3 获取栈顶元素

stack.peek();

4 删除栈顶元素

删除并返回栈顶元素

int temp = stack.pop();
System.out.println(temp);

5 栈的大小

stack.size();

6 栈是否为空

stack。isEmpty();

7 栈的遍历

//边删除边遍历
while(!stack.isEmpty()){
    int num = stack.pop();
    System.out.println(num);
}

哈希hash表常用操作 key-value

 访问access：不能

 搜索search ： o（1） 通过搜索key，碰撞时时间复杂度为o（k），k为碰撞元素的个数。

 插入 insert ：o（1）

 删除delete ：o（1）

哈希表常用操作：

1 创建哈希表

1数组自主创建，数组的索引为key，值为value

2 用系统的hashmap创建,第一个为key，第二个为value

HashMap<Integer,String> map = new HashMap<>();

2 添加元素  o（1）

map.put(1,"hanmei");
map.put(2,"lihua"):

3 更新元素  o（1）

map.put(1,"bishi");

 删除元素

map.remove(1); //参数为key

5 获取key的值 value,传递参数为key，返回值为value

map.get(1);

6 检查key是否存在

map.containsKey(3);

 长度

//Length
//time complexity：o（1）
//hashtable check the length
map。size();

是否还有元素

//Is Empty
// time complexity：o（1）
map.isEmpty();

集合 set

特点：无序，不重复

 作用：检查某一元素是否存在；检查重复元素

分类 HashSet；LinkListSet；TreeSet......

HashSet(哈希集合实质上背后是一张哈希表），所以有可能会产生Hash冲突。

集合Hashset的常用操作

创建集合

HashSet<Integer> set = new HashSet<>();

添加元素

set.add(10);
set.add(1);
set.add(2);

搜索元素

set.contains(2);

删除元素

set.remove(10);

查看长度

set.size();

堆（完全二叉树的最大堆，最小堆）

访问

搜索：堆顶元素o（1）；堆任意元素o（n）

添加：o（logN）

删除：o（logN）原因：

java中堆的常用操作

1 创建堆，堆化， o（N）。原因：先将数进行堆化O（n），然后将堆化的数据排序，以最小堆为例 o（n） 

函数：

import java.util.PriorityQueue

创建最小堆（默认）

PriorityQueue<Integer> minheap = new PriorityQueue<>();

创建最大堆

PriorityQueue<Integer> maxheap = new PriorityQueue<>(Collections.reverseOrder());

2 添加元素 

minheap.add(10);
maxheap.add(10);

3 获取堆顶元素

minheap.peak();
maxheap.peek();

4 删除并返回堆顶元素

minheap.poll();
maxheap.poll();

5 堆的长度（大小）

minheap.size();
maxheap.size();

6 堆的遍历

while( !minheap.isEmpty() ){
    minheap.poll();
    }

leetcode p215 p692

常用算法

1 双指针

快慢双指针：一般两个指针，每次快指针移动两次，慢指针移动一次。例如环形列表中移动几次后这两个指针会在同一位置。p141，p881

对撞双指针：两个指针，一个在前，一个在后。一般数组有序的时候可以考虑

2 二分法  分，就硬分，注意要low 和 high对撞跳出while（low < high）循环

3 滑动窗口(sliding window)

 目的 减少while循环 一般数组中的定长问题

lc 209 1456