常用的数据结构 JAVA

目录

• 1、线性表
• 2、栈：
• 3、队列：
• 4、HashMap:

1、线性表

List<Object> narnat = new ArrayList<>();

ArrayList：动态数组

1、可以嵌套使用

2、add(x)添加元素x，remove(index)删除某个位置的元素

3、注意list是指向性的，在不确定被指向元素是否会发生变动，最好复制一下被指向元素

List<Integer> none  = new ArrayList<>();
List<List<Integer>>end  = new ArrayList<>();
end.add(new ArrayList<Integer>(none));
//为了防止none后续会变动，这里直接复制none

1、Java中List类应该主要是一些方法， 方法的实现应该是在ArrayList类中实现

类似下方的A类B类代码：

import java.util.*;    
public class Main {         
    public static void main(String args[]) {        
    int array[] = {1, 2, 3};
    A<int []> xxf = new B<>();
    xxf.swapp(array);
    //xxf只能调用A类方法无法调用B类
    }
}


class A <T> {
	 public void swapp(T a) {
		 B<T> d = new B<T>();
		 d.address(a);
	 }
}
 
class B <T>  extends A <T> {
	 public void address(T a) {
	     System.out.println(a);
	 }
}

2、List类是一个接口类，所以不能面向对象自己，里面只存储与线性表相关的相关方法所以比较方便

3、而ArrayList类中存在与线性表无关的方法，为了防止用户调用到错误的方法，所以创建的对象是以List开头

代码：

import java.util.*;    
public class Main {         
    public static void main(String args[]) {        
   	 
    A c = new B();
    A d = c;
    
    //d只能调用A类方法 
    
    
    B f = new B();
   //f，A, B方法都可以调用
    A g = f;
    //g也只能调用A类方法
     
    }
}


class A <T> {
	 public void swapp(T a) {
		 B<T> d = new B<T>(); 
		 d.address(a);
	 }
	 public void sxx() {
		 
	 }
}
 
class B <T>  extends A <T> {
	 public void address(T a) {
	     System.out.println(a);
	 }
}

遇到:
public void map(List<Integer> qu){
}

List<Integer> xx = ArrayList<>()；

map(xx);
我的理解是：
List<Integer> qu = xx = ArrayList<>();       

代码：

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.InputEvent;
import java.util.*;
//需要将读书页面大小调至67%
public class Main {
 public static void main(String[] args) throws AWTException {
       ArrayList<Integer> qu = new ArrayList<>();
       swap(qu);
	   System.out.println(qu);
	  }
 public static void swap (List<Integer> aa) {
	 aa.add(1);
 } 
}
 
 

4、个人理解：qu是ArrayList类创建的，但传参 变成List aa = qu = ArrayList<>(); 朴素来理解即aa虽然是ArrayList生的，是List养的，所以受List限制

这里也证实qu和aa调用的函数范围是不同的：

2、栈：

java推荐使用：

Deque stack = new ArrayDeque<Integer>();

Deque：双向队列

1、add(x)将x放在栈顶（最后），push(x)将x放在栈首（末尾）offer(x),将x放在栈首

2、peek()、poll()、peekFirst()、pollFirst()都是对首元素进行操作这是易错点

3、peekLast(), pollLast()才是对栈顶元素操作，这么设计因为可以当队列使用尽管一般队列不用它

3、队列：

Queue qu = new LinkedList<Integer> ();

LinkedList : 链表

1、先进先出

2、peek(x) : 显示首部元素，poll()：删掉并返还首部元素

4、HashMap:

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

1、今天才发现HashMap是dfs剪枝的一款神器！！！

2、即利用map存储dfs已算过的值，防止重复的计算，以空间换时间

偷学网上大佬的代码：

太过优雅，一点没改：整数替换

1、map<key, value>

2、containKey(n)：判断key内是否存有n

3、containValue(n)：判断value内是否存有n

4、get(n)：通过key值n找到value值m

5、put<key, value>：存入新值