二叉树、链表、集合学习笔记
知识点1：二叉树
一.二叉树的常用性质
1.常用性质
1.在二叉树的第i层最多有2^（i-1）个节点（i>=1）
2.二叉树中如果深度为k(有k层),那么最多有2^k - 1个节点（k>=1）
3.若二叉树按照从上到下从左到右依次编号，则若某节点编号为k,则其左右子树根节点编号分别为2k和2k+1;
4.二叉树分类：满二叉树、完全二叉树
满二叉树：高度为h,由2^h - 1个节点构成的二叉树称为满二叉树
完全二叉树：若设二叉树的高度为h,除第h层外，其它各层（1~h-1）的节点数都达到最大个数，第h层上的节点都集中在该层最左边的若干位置上。
关系：满二叉树一定是完全二叉树，而完全二叉树不一定是满二叉树。
5.在完全二叉树中，具有n个节点的二叉树的深度为[log2n] + 1，其中[log2n] + 1是向下取整。满二叉树的深度为k=log2(n + 1)。
2.二叉树实现方式
1.第一类数组实现
用数组root[]存储结点值，在这种实现当中，对于编号为k的节点，其左子节点的编号为2*k，右子节点的编号为2*k + 1，另外确定根节点的编号为1.毫无疑问，这种实现极易产生巨大的空间浪费，比如对于一个只有一条链的树，假设该树含有31个节点，存储这31个节点却需要开一个2^30的数组，因此此方法较少使用。（此处的2^30是指数值，由2k计算出来的数值过大）
2.结构体+指针实现
用结构体指针u来表示一个节点，其中u->v表示该节点的权值，u->left和u->right分别指向该节点的左右子节点，初始化全部为NULL，若需用到该节点，则申请空间，否则视为无子节点！就这样互相联系成一颗结构体指针二叉树！节省空间，但是容易出现指针悬挂或者未知的指针内存错误。
3.第二类数组实现
对于一棵有n个节点树，只需要开一个大小为n的数组，节点按照出现顺序依次编号，这么一来，每个节点的左右节点的编号就无法通过2*k，2*k+1的形式来直接确定了，这时就需要数组lch[maxn] , rch[maxn]；其中lch[u]表示u节点的左子节点的编号，因此通过u = lch[u]就可以访问到u节点的左子节点，rch[u]的含义同理。另外，用value[u]表示编号为u节点的权值，如此一来，申请新节点的newnode函数与初始化的newtree函数写法就变得不同了，具体见代码。（此处只需结点个数个数组即可，并不计算数值！）
举例
package com.atguigu.javase.tree;
class Tree {
private class TreeNode {
int value;
TreeNode left;
TreeNode right;
}
private TreeNode root; // 根引用
public void add(int n) {
TreeNode newNode = new TreeNode();
newNode.value = n;
if (root == null) { // 树为空
root = newNode;
} else {
insert(root, newNode);
}
}
public void insert(TreeNode target, TreeNode newNode) {
if (newNode.value < target.value) { // 新结点比目标小, 向左走
if (target.left == null) {
target.left = newNode;
} else {
insert(target.left, newNode);
}
} else { // 向右走
if (target.right == null) {
target.right = newNode;
} else {
insert(target.right, newNode);
}
}
}
public void view(TreeNode node) {
if (node == null) {
return;
}
view(node.left);
System.out.println(node.value);
view(node.right);
}
public void travel() {
view(root);
}
}
public class TreeTest {
public static void main(String[] args) {
Tree tree = new Tree();
tree.add(20);
tree.add(10);
tree.add(50);
tree.add(80);
tree.add(5);
tree.add(2);
tree.add(9);
tree.travel();
}
}
知识点2：链表
一.链表几大特性
1、解决数组无法存储多种数据类型的问题。
2、解决数组中，元素个数无法改变的限制(C99的变长数组，C++也有变长数组可以实现)。
3、数组移动元素的过程中，要对元素进行大范围的移动，很耗时间，效率也不高。
这个简单链表的构成：
头指针(Header)，若干个节点(节点包括了数据域和指针域)，最后一个节点要指向空。
实现原理：头指针指向链表的第一个节点，然后第一个节点中的指针指向下一个节点，然后依次指到最后一个节点，这样就构成了一条链表。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dM8vEgEV-1596805878801)(C:\Users\汤胖胖\AppData\Roaming\Typora\typora-user-images\1594868185094.png)]
举例
package com.atguigu.javase.link;
class Link {
private class Node {
Object value; // 数据域
Node next; // 指针域
public Node(Object value) {
this.value = value;
}
}
private Node head;
private Node tail;
private int size;
public void add(Object obj) {
Node newNode = new Node(obj);
if (head == null) {
head = newNode;
tail = newNode;
} else {
tail.next = newNode;
tail = newNode;
}
size++;
}
public void travel() {
Node tmp = head;
while (tmp != null) {
System.out.println(tmp.value);
tmp = tmp.next;
}
}
public int size() {
/*
int size = 0;
Node tmp = head;
while (tmp != null) {
size++;
tmp = tmp.next;
}*/
return size;
}
public boolean remove(Object obj) {
if (head.value.equals(obj)) { // 先判断是否删除的是头
head = head.next;
size--;
return true;
}
Node prev = head;
while (prev.next != null) { // 用于检索要删除的目标结点的前一个
if (prev.next.value.equals(obj)) { // 判断的是prev.下一个节点的值
// 真正删除它
if (prev.next == tail) { // 如果删除的是尾结点, 必须让尾变化
tail = prev;
}
prev.next = prev.next.next; // 把要删除目标结点的后面的结点的地址写入前一个结点中.
size--;
return true;
}
prev = prev.next; // 如果判断失败, 继续右移指针.
}
return false;
}
}
public class LinkTest {
public static void main(String[] args) {
Link link = new Link();
link.add("yy");
link.add("abc");
link.add("aa");
link.add("aa");
link.add("cc");
link.add("qq");
link.add("zz");
link.add("pp");
link.add("aa");
link.add("xx");
link.travel();
System.out.println("********************");
link.remove("qq");
link.travel();
}
}
知识点3：集合
一、集合分类
学习Java集合类我们从以下几个主要的内容进行学习，大致可以分为List列表，set集合，map映射和工具类，这个工具类包括Iterrator迭代器，Enumeration枚举类，Arrays和Collection。
Collection
Collection : 保存一个一个的对象
* 无序可重复. 无序 : 不按添加顺序保存元素, 可重复 : 重复的对象可以多次添加.
* boolean add(Object obj) 添加元素, 返回值表示添加成功或失败
* boolean contains(Object obj) 判断当前集合中是否包含参数中的对象
* boolean remove(Object obj) 删除指定的元素
* int size() 返回元素个数
*
* Set : 保存一个一个的对象, 无序不可重复
* HashSet : 使用哈希算法实现的Set集合.
* 去重规则 : 两个对象的equals为true, 两个对象的hashCode也必须相等.
*
* TreeSet : 基于二叉搜索树实现的Set集合. 内部要实现自然排序, 如果提供了比较器,它就会定制排序.
* 去重规则 : 两个对象的compare为0.
List
* List : 保存一个一个的对象, 有序可重复
* void add(int index, Object ele). 在指定下标位置处插入新元素
* Object get(int index) 返回指定下标处的元素
* Object remove(int index) 删除指定下标处的元素
* Object set(int index, Object ele) 替换指定下标处的元素为参数ele. 旧元素作为返回值.
*
* ArrayList : 基于数组实现的List集合
* Vector : 和ArrayList等价.
* LinkedList : 基于链表实现的List集合.
Map
* Map : 保存一对一对的对象
举例
class Student implements Comparable {
private int id;
private String name;
private int grade;
private double score;
public Student() {}
public Student(int id, String name, int grade, double score) {
this.id = id;
this.name = name;
this.grade = grade;
this.score = score;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", grade=" + grade +
", score=" + score +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return id == student.id &&
grade == student.grade &&
Double.compare(student.score, score) == 0 &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name, grade, score);
}
@Override
public int compareTo(Object o) throws RuntimeException {
if (!(o instanceof Student)) {
throw new RuntimeException("对象不可比");
}
int n = (int)(this.score - ((Student)o).score);
if (n == 0) {
n = 1;
}
return n;
}
}
// 写一个比较器, 用于完成两个学生对象的比较
class MyComparator implements Comparator {
@Override
public int compare(Object o1, Object o2) {
if (!(o1 instanceof Student) || !(o2 instanceof Student)) {
throw new RuntimeException("对象不可比");
}
return -(((Student)o1).getGrade() - ((Student)o2).getGrade());
}
}
public class CollectionTest {
@Test
public void test7() {
MyComparator myComparator = new MyComparator();
Set set = new TreeSet(myComparator); // 通过构造器传递对象, 99.9%的情况是对象关联.
Student s1 = new Student(1,"小明", 5, 80);
Student s2 = new Student(2,"小花", 4, 90);
Student s3 = new Student(3,"小伟", 2, 100);
Student s4 = new Student(4,"小芳", 1, 90);
Student s5 = new Student(5,"小丽", 6, 50);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
for (Object tmp : set) {
System.out.println(tmp);
}
System.out.println("*************************************");
// 1) 遍历谁, 就向谁要迭代器.
Iterator iterator = set.iterator();
// 使用注意事项1 : 迭代器要趁热使用
// set.remove(s1); 不要随意再修改集合的内容, 否则迭代器会出问题.
// 2) 循环依次询问当前游标后面有无元素, 如果有, 返回true
while (iterator.hasNext()) {
// 真的获取到后面的元素, 并且会引发内部游标的下移
Object obj = iterator.next();
// next()在循环中必须只调用一次.
System.out.println(obj);
}
// 使用注意事项 : 迭代器是一次性使用, 用完作废.
}
@Test
public void test6() {
Set set = new TreeSet();
Student s1 = new Student(1,"小明", 5, 80);
Student s2 = new Student(2,"小花", 4, 90);
Student s3 = new Student(3,"小伟", 2, 100);
Student s4 = new Student(4,"小芳", 1, 90);
Student s5 = new Student(5,"小丽", 6, 50);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
for (Object tmp : set) {
System.out.println(tmp);
}
}
@Test
public void test5() {
Set set = new TreeSet();
//set.add(20);
//set.add(5);
//set.add(2);
//set.add(10);
set.add("cc");
set.add("bb");
set.add("aa");
//set.add(30);
for (Object tmp : set) {
System.out.println(tmp);
}
}
@Test
public void test4() {
Set set = new TreeSet();
set.add(20);
set.add(5);
set.add(2);
set.add(10);
set.add(80);
set.add(60);
set.add(5);
for (Object tmp : set) {
System.out.println(tmp);
}
}
@Test
public void test3() {
Set set = new HashSet(); // 无序不可重复
Student s1 = new Student(1, "小明", 3, 80);
Student s2 = new Student(2, "小丽", 2, 90);
Student s3 = new Student(1, "小明", 3, 80);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s1);
for (Object obj : set) {
System.out.println(obj);
}
}
// 创建一个List集合, 保存10个20以内的随机整数.
@Test
public void exer3() {
List list = new ArrayList();
for (int i = 0; i < 10; i++) {
int n = (int)(Math.random() * 20);
list.add(n);
}
// 遍历
for (int i = 0; i < list.size(); i++) {
Object o = list.get(i);
System.out.println(o);
}
}
// 创建一个List集合, 保存10个20以内的随机整数, 不要重复的.
@Test
public void exer4() {
List list = new ArrayList();
for (int i = 0; i < 10; i++) {
int n = (int)(Math.random() * 20);
if (list.contains(n)) {
i--;
continue;
}
list.add(n);
}
for (Object tmp : list) {
System.out.println(tmp);
}
}
@Test
public void exer42() {
List list = new ArrayList();
while (list.size() != 10) {
int n = (int)(Math.random() * 20);
if (!list.contains(n)) {
list.add(n);
}
}
for (Object tmp : list) {
System.out.println(tmp);
}
}
@Test
public void exer43() {
List list = new ArrayList();
for (int i = 0; i < 10;) {
int n = (int)(Math.random() * 20);
if (!list.contains(n)) {
list.add(n);
i++;
}
}
for (Object tmp : list) {
System.out.println(tmp);
}
}
@Test
public void test2() {
List list = new ArrayList();
list.add("abc");
list.add("yyy");
list.add(new Integer(200));
list.add("abc");
list.add(200);
list.add(new Student(2, "小丽", 1, 50));
System.out.println(list);
list.add(2, "我是汉字"); // 插入
list.add(1, 3);
System.out.println(list);
Object o = list.get(7);
System.out.println(o);
list.remove(3); // 整数会优先作为下标来使用
list.remove(Integer.valueOf(3)); // 删除对象
System.out.println(list); //[abc, yyy, 200, abc, 200, Student{id=2, name='小丽', grade=1, score=50.0}]
list.set(3, 3.14); // 替换操作
System.out.println(list);
System.out.println("*************************************");
for (int i = 0; i < list.size(); i++) {
Object o1 = list.get(i);
System.out.println(o1);
}
}
// 创建一个Set集合, 保存10个20以内的随机整数.
@Test
public void exer1() {
Set set = new HashSet();
for (int i = 0; i < 10; i++) {
set.add((int)(Math.random() * 20));
}
// 遍历集合
for (Object tmp : set) {
System.out.println(tmp);
}
}
// 创建一个Set集合, 保存10个20以内的随机整数. 保证10个.
@Test
public void exer12() {
Set set = new HashSet();
while (set.size() != 10) {
set.add((int)(Math.random() * 20));
}
// 遍历集合
for (Object tmp : set) {
System.out.println(tmp);
}
}
@Test
public void exer13() {
Set set = new HashSet();
for (int i = 0; i < 10; i++) {
int n = (int)(Math.random() * 20);
if (!set.add(n)) {
i--;
}
}
}
@Test
public void exer14() {
Set set = new HashSet();
for (int i = 0; i < 10; ) {
int n = (int)(Math.random() * 20);
if (set.add(n)) {
i++;
}
}
}
public static void main(String[] args) {
Set set = new HashSet(); // Set : 无序不可重复
set.add("abc");
set.add("yyy");
set.add(new Integer(200));
set.add(100); // set.add(Integer.valueOf(100));
set.add(new Student(1, "小明", 2, 80));
boolean b1 = set.add("yyy");
boolean b2 = set.add(200);
System.out.println(b1);
System.out.println(b2);
System.out.println(set.size());
System.out.println(set);
System.out.println("***************************************");
// 遍历集合.
for (Object tmp : set) {
System.out.println(tmp);
}
boolean contains = set.contains(200); // 判断是否包含
System.out.println("contains = " + contains);
set.remove(100); // 删除
System.out.println(set);
}
}
(Integer.valueOf(100));
set.add(new Student(1, “小明”, 2, 80));
boolean b1 = set.add(“yyy”);
boolean b2 = set.add(200);
System.out.println(b1);
System.out.println(b2);
System.out.println(set.size());
System.out.println(set);
System.out.println("***************************************");
// 遍历集合.
for (Object tmp : set) {
System.out.println(tmp);
}
boolean contains = set.contains(200); // 判断是否包含
System.out.println("contains = " + contains);
set.remove(100); // 删除
System.out.println(set);
}
}
1618
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
