学习地址：【数据结构与算法基础-java版】 🚀数据结构--Java专栏🚀
- 笔记01【01-09】【概述、数组基本使用】【源码、课件】
- 笔记02【10-18】【栈、队列、单链表(增删节点)、循环链表、双向循环链表、递归(斐波那契、汉诺塔)】
- 笔记03【19-27】【（时间、空间复杂度）；八大排序（冒泡、快速、插入、希尔、选择、归并、基数、队列基数）】
- 笔记04【28-33】【树结构(二叉树)概述、创建、遍历、查找节点、删除节点】
- 笔记05【34-39】【顺序存储二叉树概述、二叉树遍历、堆排序、线索二叉树实现及遍历】
- 笔记06【40-48】【赫夫曼树、概述、原理分析、代码实现(数据压缩、创建编码表、解码、压缩文件、解压文件)】
- 笔记07【49-54】【二叉排序树（添加、查找、删除节点）】
- 笔记08【55-57】【二叉平衡树(AVL)-概述、单旋转、双旋转】
- 笔记09【58-60】【计算机中数据的存储原理、2-3树的插入原理、B树和B+树】
- 笔记10【61-63】【哈希表概述、散列函数的设计、散列冲突解决方案】
- 笔记11【64-67】【图结构概述、图遍历原理(BFS\DFS)、图遍历代码实现】
课件（源码、XMind文件）：【链接：https://pan.baidu.com/s/1JYLnvxdvTCbRybxi2RE6Ew 提取码：mi7f】
目 录
P1-1.1数据结构概述
整个思维导图【实在是太大了！！！请自己下载xmind文件，自行查看吧！】
1、数据结构概述
第一集的思维导图
什么是数据结构：数据与数据之间的关系！
数据的存储结构：数据在计算机中如何存储！
数据的逻辑结构：数据与数据之间的关系！
图结构：多对多！！！
P2-1.2算法概述
算法是规则的有限集合，会为解决特定问题而规定的一系列操作。
数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。
1、思维导图
2、导入老师的eclipse工程，中文乱码---解决方案
1、右键出现中文乱码的java项目名，在右键菜单中选择最后一项Properties！
2、点击【Properties】，在弹出窗口选择Resource选项，然后在右侧操作窗口中的第一项选择other选项，在选项右边下拉选择中点选合适的编码格式！如果你不知道导入项目的使用了什么编码，你可以尝试选择utf-8，这是编程中最常用的编码格式。然后确定Apple and close就可以了！
3、格式化代码
package demo1;
public class AddOneToHundred {
public static void main(String[] args) {
int total = 0;
int end = 100;
// 使用for循环计算
for (int i = 1; i <= end; i++) {
total += i;
}
System.out.println(total);
// 直接计算
total = (1 + end) * end / 2;
// 算法没有最好的，只有最适合的！
// 打印结果
System.out.println(total);
}
}P3-2.1数组的基本使用
package demo1;
public class TestArray {
public static void main(String[] args) {
// 创建一个数组
int[] arr1 = new int[3];
// 获取数组长度
int length1 = arr1.length;
System.out.println("arr1's length: " + length1);
// 访问数组中的元素:数组名[下标] 注意：下标从0开始,最大可以取到长度-1
int element0 = arr1[0];
System.out.println("element0: " + element0);
for(int x: arr1) {
System.out.println(x);
}
// 为数组中的元素赋值
arr1[0] = 99;
System.out.println("element0: " + arr1[0]);
arr1[1] = 98;
arr1[2] = 97;
// 遍历数组
for (int i = 0; i < length1; i++) {
System.out.println("arr1 element" + i + ": " + arr1[i]);
}
// 创建数组的同时为数组中的元素赋值
int[] arr2 = new int[] { 90, 80, 70, 60, 50 };
// 获取数组的长度
System.out.println("arr2 length: " + arr2.length);
}
}
P4-2.2数组元素的添加
1、替换数组
package demo1;
import java.util.Arrays;
public class TestOpArray {
public static void main(String[] args) {
// 解决数组的长度不可变的问题
int[] arr = new int[] { 9, 8, 7 };
// 快速查看数组中的元素
System.out.println(Arrays.toString(arr));
// 要加入数组的目标元素
int dst = 6; // destination 目的地 缩写
// 创建一个新的数组，长度是原数组长度+1
int[] newArr = new int[arr.length + 1];
// 把原数组中的数据全部复制到新数组中
for (int i = 0; i < arr.length; i++) {
newArr[i] = arr[i];
}
// 把目标元素放入新数组的最后
newArr[arr.length] = dst;
// 新数组替换原数组
arr = newArr;
System.out.println(Arrays.toString(arr));
}
}
P5-2.3数组元素的删除
或者 数组元素前移操作！！！
package demo1;
import java.util.Arrays;
public class TestOpArray2 {
// 如何删除数组中的元素
public static void main(String[] args) {
// 目标数组
int[] arr = new int[] { 9, 8, 7, 6, 5, 4 }; // 数组长度为6
System.out.println(arr.length);
// 要删除的元素的下标
int dst = 3; // 0、1、2、3、4、5
System.out.println(Arrays.toString(arr));
// 创建一个新的数组，长度是原数组的长度-1
int[] newArr = new int[arr.length - 1]; // 数组长度为5
// 复制原数组中除了要删除的那个元素以外其它的元素
for (int i = 0; i < newArr.length; i++) { // i: 0\1\2\3\4
// 要删除的元素之前的元素
/**-----------------------------------*/
// if (i < dst) {
// System.out.println("---: " + i);
// newArr[i] = arr[i];
// // 要删除的元素之后的元素
// } else {
// System.out.println("***: " + i);
// newArr[i] = arr[i + 1];
// }
/**-----------------------------------*/
if (i == dst) {
continue;
}
System.out.println("***: " + i);
newArr[i] = arr[i];
}
// 新数组替换旧数组
arr = newArr;
System.out.println(Arrays.toString(arr));
}
}
P6-2.4面向对象的数组
1、数组的底层实现原理
1.1、MyArray.java
// 判断下标是否越界
if (index < 0 || index > elements.length - 1) {
throw new RuntimeException("下标越界");
}
package demo1.util;
import java.util.Arrays;
public class MyArray {
// 用于存储数据的数组
private int[] elements; // 只能存 int, 存其他类型的数据：object
public MyArray() {
elements = new int[0];
}
// 获取数组长度的方法
public int size() {
return elements.length;
}
// 往数组的末尾添加一个元素
public void add(int element) {
// 创建一个新的数组
int[] newArr = new int[elements.length + 1];
// 把原数组中的元素复制到新数组中
for (int i = 0; i < elements.length; i++) {
newArr[i] = elements[i];
}
// 把添加的元素放入新数组中
newArr[elements.length] = element;
// 使用新数组替换旧数组
elements = newArr;
}
// 打印所有元素到控制台
public void show() {
System.out.println(Arrays.toString(elements));
}
// 删除数组中的元素
public void delete(int index) {
// 判断下标是否越界
if (index < 0 || index > elements.length - 1) {
throw new RuntimeException("下标越界");
}
// 创建一个新的数组，长度为原数组的长度-1
int[] newArr = new int[elements.length - 1];
// 复制原有数据到新数组
for (int i = 0; i < newArr.length; i++) {
// 想要删除的元素前面的元素
if (i < index) {
newArr[i] = elements[i];
// 想要删除的元素后面的元素
} else {
newArr[i] = elements[i + 1];
}
}
// 新数组替换旧数组
elements = newArr;
}
// 取出指定位置的元素
public int get(int index) {
// 判断下标是否越界
if (index < 0 || index > elements.length - 1) {
throw new RuntimeException("下标越界");
}
return elements[index];
}
// 插入一个元素到指定位置
public void insert(int index, int element) {
// 创建一个新的数组
int[] newArr = new int[elements.length + 1];
// 将原数组中的元素放入新数组中。
for (int i = 0; i < elements.length; i++) {
// 目标位置之前的元素
if (i < index) {
newArr[i] = elements[i];
// 目标位置之后的元素
} else {
newArr[i + 1] = elements[i];
}
}
// 插入新的元素
newArr[index] = element;
// 新数组替换旧数组
elements = newArr;
}
// 替换指定位置的元素
public void set(int index, int element) {
// 判断下标是否越界
if (index < 0 || index > elements.length - 1) {
throw new RuntimeException("下标越界");
}
elements[index] = element;
}
// 线性查找
public int search(int target) {
// 遍历数组
for (int i = 0; i < elements.length; i++) {
if (elements[i] == target) {
return i;
}
}
// 没有找到对应的元素
return -1;
}
// 二分法查找
public int binarySearch(int target) {
// 记录开始位置
int begin = 0;
// 记录结束位置
int end = elements.length - 1;
// 记录中间的位置
int mid = (begin + end) / 2;
// 循环查找
while (true) {
// 什么情况下没有这个元素？
// 开始在结束位置之后或重合,没有这个元素
if (begin >= end) {
return -1;
}
// 判断中间的这个元素是不是要查找的元素
if (elements[mid] == target) {
return mid;
// 中间这个元素不是要查的元素
} else {
// 判断中间这个元素是不是比目标元素大
if (elements[mid] > target) {
// 把结束位置调整到中间位置前一个位置
end = mid - 1;
// 中间这个元素比目标元素小
} else {
// 把开始位置调整到中间位置的后一个位置
begin = mid + 1;
}
// 取出新的中间位置
mid = (begin + end) / 2;
}
}
}
}1.2、TestMyArray.java
package demo1;
import demo1.util.MyArray;
public class TestMyArray {
public static void main(String[] args) {
// 创建一个可变的数组
MyArray ma = new MyArray();
// 获取长度
int size = ma.size();
ma.show();
// 往可变数组中添加一个元素
ma.add(99);
ma.add(98);
ma.add(97);
// 显示可变数组中的所有元素到控制台
ma.show();
// 删除某个元素
ma.delete(1);
ma.show();
// 取出指定位置的元素
int element = ma.get(1);
System.out.println(element);
System.out.println("=====================");
ma.add(96);
ma.add(95);
ma.add(94);
ma.show();
// 插入元素到指定位置
ma.insert(3, 33);
ma.show();
System.out.println("=====================");
// 替换指定位置的元素
ma.set(0, 100);
ma.show();
System.out.println(ma.size());
}
}
P7-2.5查找算法之线性查找
package demo1;
public class TestSearch {
public static void main(String[] args) {
// 目标数组
int[] arr = new int[] { 2, 3, 5, 6, 8, 4, 9, 0 };
// 目标元素
int target = 8;
// 目标元素所在的下标
int index = -1;
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (arr[i] == target) {
index = i;
break;
}
}
// 打印目标元素的下标
System.out.println("index:" + index);
}
}
P8-2.6查找算法之二分法查找
二分法：要求 数组 必须 有序！！！
结束条件：while (begin < end) {}
package demo1;
public class TestBinarySearch {
public static void main(String[] args) {
// 目标数组
int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
// 目标元素
int target = 30;
// 记录开始位置
int begin = 0;
// 记录结束位置
int end = arr.length - 1;
// 记录中间的位置
int mid = (begin + end) / 2;
// 记录目标位置
int index = -1;
// 循环查找
while (begin < end) {
// 判断中间的这个元素是不是要查找的元素
if (arr[mid] == target) {
index = mid;
break;
// 中间这个元素不是要查的元素
} else {
// 判断中间这个元素是不是比目标元素大
if (arr[mid] > target) {
// 把结束位置调整到中间位置的前一个位置
end = mid - 1;
// 中间这个元素比目标元素小
} else {
// 把开始位置调整到中间位置的后一个位置
begin = mid + 1;
}
// 取出新的中间位置
mid = (begin + end) / 2;
}
}
System.out.println("index: " + index);
}
}
P9-2.7查找算法整合
1、MyArray.java
package demo1.util;
import java.util.Arrays;
public class MyArray {
// 用于存储数据的数组
private int[] elements; // 只能存 int, 存其他类型的数据：object
public MyArray() {
elements = new int[0];
}
// 获取数组长度的方法
public int size() {
return elements.length;
}
// 往数组的末尾添加一个元素
public void add(int element) {
// 创建一个新的数组
int[] newArr = new int[elements.length + 1];
// 把原数组中的元素复制到新数组中
for (int i = 0; i < elements.length; i++) {
newArr[i] = elements[i];
}
// 把添加的元素放入新数组中
newArr[elements.length] = element;
// 使用新数组替换旧数组
elements = newArr;
}
// 打印所有元素到控制台
public void show() {
System.out.println(Arrays.toString(elements));
}
// 删除数组中的元素
public void delete(int index) {
// 判断下标是否越界
if (index < 0 || index > elements.length - 1) {
throw new RuntimeException("下标越界");
}
// 创建一个新的数组，长度为原数组的长度-1
int[] newArr = new int[elements.length - 1];
// 复制原有数据到新数组
for (int i = 0; i < newArr.length; i++) {
// 想要删除的元素前面的元素
if (i < index) {
newArr[i] = elements[i];
// 想要删除的元素后面的元素
} else {
newArr[i] = elements[i + 1];
}
}
// 新数组替换旧数组
elements = newArr;
}
// 取出指定位置的元素
public int get(int index) {
// 判断下标是否越界
if (index < 0 || index > elements.length - 1) {
throw new RuntimeException("下标越界");
}
return elements[index];
}
// 插入一个元素到指定位置
public void insert(int index, int element) {
// 创建一个新的数组
int[] newArr = new int[elements.length + 1];
// 将原数组中的元素放入新数组中。
for (int i = 0; i < elements.length; i++) {
// 目标位置之前的元素
if (i < index) {
newArr[i] = elements[i];
// 目标位置之后的元素
} else {
newArr[i + 1] = elements[i];
}
}
// 插入新的元素
newArr[index] = element;
// 新数组替换旧数组
elements = newArr;
}
// 替换指定位置的元素
public void set(int index, int element) {
// 判断下标是否越界
if (index < 0 || index > elements.length - 1) {
throw new RuntimeException("下标越界");
}
elements[index] = element;
}
// 线性查找
public int search(int target) {
// 遍历数组
for (int i = 0; i < elements.length; i++) {
if (elements[i] == target) {
return i;
}
}
// 没有找到对应的元素
return -1;
}
// 二分法查找
public int binarySearch(int target) {
// 记录开始位置
int begin = 0;
// 记录结束位置
int end = elements.length - 1;
// 记录中间的位置
int mid = (begin + end) / 2;
// 循环查找
while (true) {
// 什么情况下没有这个元素？
// 开始在结束位置之后或重合,没有这个元素
if (begin >= end) {
return -1;
}
// 判断中间的这个元素是不是要查找的元素
if (elements[mid] == target) {
return mid;
// 中间这个元素不是要查的元素
} else {
// 判断中间这个元素是不是比目标元素大
if (elements[mid] > target) {
// 把结束位置调整到中间位置前一个位置
end = mid - 1;
// 中间这个元素比目标元素小
} else {
// 把开始位置调整到中间位置的后一个位置
begin = mid + 1;
}
// 取出新的中间位置
mid = (begin + end) / 2;
}
}
}
}2、TestMyArraySearch.java
package demo1;
import demo1.util.MyArray;
public class TestMyArraySearch {
public static void main(String[] args) {
MyArray ma = new MyArray();
ma.add(1);
ma.add(2);
ma.add(3);
ma.add(4);
ma.add(5);
// 调用线性查找方法
int index = ma.search(0);
System.out.println("index: " + index);
// 调用二分法查找
int index2 = ma.binarySearch(6);
System.out.println("index2: " + index2);
}
}
2665
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
