Day13_数据结构与集合(上)
Day13_数据结构与集合(上)
线性表
- 相同数据类型
- 序列（顺序性）
- 有限
数组
优点：按照索引查询的效率高，O(1)
不按照索引，数组无序：O(n)
不按照索引，数组有序：二分法查找 O(log2n)
链表
-
单向链表：每个结点只有一个指针域，指向下一个结点
-
双向链表：每个结点有两个指针域，一个指向上一个结点，一个指向下一个结点。其中第一个结点指向上一结点的指针域为空，最后一个结点指向下一结点的指针域为空
-
循环链表： 首尾相连
栈和队列
栈和队列，是操作受限制的线性表。
栈
特点：先进后出，后进先出。
简单应用
- 网络浏览器将用户最近访问过的网址组织为一个栈。用户每按一次“后退”按钮，即可沿相反次序访问刚访问过的页面。
- 文本编辑器中的撤销和恢复功能，用户编辑操作被依次记录在一个栈中，用户每按一次“后退”按钮，即可取消最近一次操作。
队列
特点：先进先出。
双端队列：两端都可以进行进队，出队的队列。
树
结点的度(Degree)：节点拥有的子树数目。
树的度：树内各结点的度的最大值。
二叉树
每个结点的度均不超过2的有序树。以左孩子为根的子树称为左子树，以右孩子为根的子树称为右子树。
满二叉树
- 高度为k且有(2^k+1)-1个结点的二叉树。
- 在满二叉树中，每层结点都达到最大数，即每层结点都是满的，因此成为满二叉树。
完全二叉树
若在一棵满二叉树中，在最下层从最右侧起去掉相邻的若干叶子结点，得到的二叉树即为完全二叉树。
满二叉树必为完全二叉树，完全二叉树不一定是满二叉树。
二叉树的存储结构
- 顺序存储结构
- 链式存储结构
二叉树的遍历
- 先序遍历：根->左子树->右子树
- 中序遍历：左子树->根->右子树
- 后序遍历：左子树->右子树->根
平衡二叉树
左右两个子树的高度差(平衡因子)的绝对值不超过1。
红黑树：一种特殊的平衡二叉树。
集合
上层接口(collection)
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo01 {
public static void main(String[] args) {
/*
接口中常用的方法：
增加：add(E e) addAll(Collection<? extends E> c)
删除：clear() remove(Object o)
修改：
查看：iterator() size()
判断：contains(Object o) equals(Object o) isEmpty()
*/
Collection col=new ArrayList();
col.add("java");
//集合内只能放引用数据类型，此时自动装箱Integer i=12;
col.add(12);
col.add(9.8);
System.out.println(col);
System.out.println(col.size());
System.out.println(col.isEmpty());
//清空集合
//col.clear();
//遍历集合
//方式一：无法使用普通for循环，因为无法获取集合索引
//方式二：增强for循环
for(Object o:col){
System.out.print(o+"\t");
}
//方式三：
Iterator it = col.iterator();
while(it.hasNext()){
System.out.print(it.next()+"\t");
}
}
}
输出：
[java, 12, 9.8]
3
false
java 12 9.8 java 12 9.8
List
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo02 {
public static void main(String[] args) {
List list=new ArrayList();
list.add("java");
list.add("html");
list.add("css");
list.add("js");
System.out.println(list);
//在索引1处添加元素
list.add(1,"oracle");
System.out.println(list);
//修改指定索引处的元素
list.set(1,"servlet");
System.out.println(list);
//查询指定索引的元素
System.out.println(list.get(0));
//遍历
//方式一：普通for循环
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i)+"\t");
}
System.out.println();
//方式二：增强for循环
for(Object o:list){
System.out.print(o+"\t");
}
System.out.println();
//方式三：
Iterator it = list.iterator();
while(it.hasNext()){
System.out.print(it.next()+"\t");
}
}
}
输出：
[java, html, css, js]
[java, oracle, html, css, js]
[java, servlet, html, css, js]
java
java servlet html css js java servlet html css js
java servlet html css js
ArrayList类
底层结构：数组
原理：数组的扩容
Vector类（现在已淘汰）
底层结构：数组
原理：数组的扩容
ArrayList类：效率高，线程不安全
Vector：效率低，线程安全
泛型
import java.util.ArrayList;
import java.util.List;
public class Demo03 {
public static void main(String[] args) {
//多态，扩展性好
List list=new ArrayList();
//不需要扩展性好，想用ArrayList中特有的方法的时候，用这个方式
ArrayList al=new ArrayList();
al.add("java");
al.add(12);
al.add(9.8);
System.out.println(al);
/*泛型：加入<>表示的泛型之后，说明集合内只能放这种数据类型
在没有加入泛型时，会报黄色的警告
*/
ArrayList<String> al1=new ArrayList();
al1.add("java");
al1.add("html");
al1.add("css");
al1.add("js");
//al1.add(12);报错，因为12的类型不是String
for(String a:al1){
System.out.print(a+"\t");
}
}
}
输出：
[java, 12, 9.8]
java html css js
泛型类
import java.util.ArrayList;
public class Demo04<AA> {
//普通的类Demo04后面加上一个泛型，泛型的类不确定，就变成了一个泛型类
//并且AA的类型不确定，什么时候才确定？创建对象的时候确定的
}
class Demo05 {
public static void main(String[] args) {
//在创建对象时，不使用泛型，可以，但是有黄色警告
Demo04 demo01=new Demo04();
//在创建对象时，使用泛型
Demo04<String> demo02=new Demo04<String>();
Demo04<Integer> demo03=new Demo04<Integer>();
Demo04<Double> demo04=new Demo04<Double>();
//泛型类的应用
ArrayList al=new ArrayList();
ArrayList<String> al1=new ArrayList<String>();
ArrayList<Integer> al2=new ArrayList<Integer>();
}
}
泛型的高级应用
泛型的上限、下限
创建一个Person类
public class Person {
private String name;
private int age;
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Person (String name,int age){
super();
this.name=name;
this.age=age;
}
public Person (){
super();
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
创建一个Person的子类Student类
public class Student extends Person{
private String name;
private double height;
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public Student(String name,double height){
super();
this.name=name;
this.height=height;
}
public Student(){
super();
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", height=" + height +
'}';
}
}
示例：
import java.util.ArrayList;
public class Demo06 {
public static void main(String[] args) {
ArrayList<Person> al=new ArrayList<Person>();
al.add(new Person("lili",19));
al.add(new Person("nana",23));
al.add(new Person("lulu",20));
bianLi(al);
ArrayList<Student> al2=new ArrayList<Student>();
al2.add(new Student("lili",170.5));
al2.add(new Student("nana",168.9));
al2.add(new Student("lulu",172.4));
bianLi(al2);
}
//泛型的上限，ArrayList<? extends Person> al表示只要是Person的子类，就可以使用
//泛型的下限，ArrayList<? super Person> al表示只要是Person的父类，就可以使用
public static void bianLi(ArrayList<? extends Person> al){
for (Object p:al) {
System.out.println(p);
}
}
}
输出：
Person{name='lili', age=19}
Person{name='nana', age=23}
Person{name='lulu', age=20}
Student{name='lili', height=170.5}
Student{name='nana', height=168.9}
Student{name='lulu', height=172.4}
