参考视频: 【黑马程序员】2020最新数据结构与算法教程(求职面试必备)
参考leetcode学习资料: 图解算法数据结构
注意 目录结构呦!!!按本文目录
在src文件夹下
创建项目和文件,直接粘代码即可运行
算法和数据结构简述+排序的笔记
【Java数据结构笔记一】-- 数据结构与算法概述–【时间复杂度+空间复杂度】
【Java数据结构笔记二】-- 排序 --冒泡+选择+插入+希尔+归并+快速
Mywrite
sort
Bubble(冒泡)
这是冒泡排序
package Mywrite.sort;
import java.util.Arrays;
public class Bubble {
// 测试代码
public static void main(String[] args) {
Integer[] arr = {4,5,7,2345,6,83};
sort(arr);
System.out.println(Arrays.toString(arr));
}
// 排序
public static void sort(Comparable[] a){
for(int i = a.length -1; i>0; i--){
for(int j = 0; j < i; j++){
// 比较索引i和索引j+1处的值
if(greater(a[j],a[j+1])){
exch(a,j,j+1);
}
}
}
}
// 比大小
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) > 0;
}
// 交换
private static void exch(Comparable[] a, int i ,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
Selection(选择)
选择排序
package Mywrite.sort;
import java.util.Arrays;
public class Selection {
// 测试
public static void main(String[] args) {
//原始数据
Integer[] a = {34,5325,567,2546,252465,563};
sort(a);
System.out.println(Arrays.toString(a));
}
// 排序
public static void sort(Comparable[] a){
for(int i = 0; i < a.length-1 ; i++){
int minIndex = i;
for(int j = i+1; j <a.length ;j++){
if(greater(a[minIndex],a[j])){
minIndex = j;
}
}
// 交换最小元素所在索引minIndex处的值和索引i处的值
exch(a,minIndex, i);
}
}
//比较
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w)>0;
}
//交换
private static void exch(Comparable[] a, int i, int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
Insertion(插入)
package Mywrite.sort;
import java.util.Arrays;
public class Insertion {
public static void main(String[] args) {
Integer[] a = {2,35,63,76,265,7474,24,345,456};
sort(a);
System.out.println(Arrays.toString(a));
}
// 排序
public static void sort(Comparable[] a){
for(int i=1;i< a.length; i++){
for(int j = i; j>=0; j--){
// 比较索引j处的值和索引j-1处的值;如果索引j-1处的值大于j处的值,需要交换j及j-1
// 处的值
if(greater(a[j-1], a[j])){
exch(a,j,j-1);
}else{
break;
}
}
}
}
// 比大小
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) > 0;
}
// 交换
private static void exch(Comparable[] a, int i ,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
Shell(希尔)
package Mywrite.sort;
import java.util.Arrays;
public class Shell {
public static void main(String[] args) {
Integer[] a = {3,4,5,8,9,0,76,6,5,4,2};
sort(a);
System.out.println(Arrays.toString(a));
}
// 排序
public static void sort(Comparable[] a) {
// 1. 根据数组a的长度,确定增长量h的初始值
int h = 1;
while (h < a.length / 2) {
h = 2 * h + 1;
}
// 2.希尔排序
while (h >= 1) {
// 排序
//2. 1 找到待插入的元素
for (int i = h; i < a.length; i++) {
System.out.println(i);
//2.2 把待插入的元素插入到有序数列中
for (int j = i; j >= h; j -= h) {
// 待插入的元素时a[j],比较a[j]和a[j-h]
if (greater(a[j - h], a[j])) {
// 交换元素
exch(a, j - h, j);
} else {
// 待插入元素已经找到了合适得到位置。结束循环
break;
}
}
}
// 减小h的值
h = h / 2;
}
}
// 比大小
private static boolean greater(Comparable v, Comparable w){
return v.compareTo(w) > 0;
}
// 交换
private static void exch(Comparable[] a, int i ,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
Merge(归并)
package Mywrite.sort;
import java.util.Arrays;
public class Merge {
public static void main(String[] args) {
Integer[] a = {8,4,5,7,1,3,6,2};
sort(a);
System.out.println(Arrays.toString(a));
}
// 定义一个辅助数组
private static Comparable[] assist;
// 比大小
private static boolean less(Comparable v, Comparable w){
return v.compareTo(w) < 0;
}
// 交换
private static void exch(Comparable[] a, int i ,int j){
Comparable temp = a[i];
a[i] = a[j];
a[j] = temp;
}
/*对数组a中的元素进行排序*/
public static void sort(Comparable[] a){
//1. 初始化数组assist
assist = new Comparable[a.length];
//2.定义一个lo变量,和hi变量,分别记录数组中最小的索引和最大的索引
int lo = 0;
int hi = a.length - 1;
//3. 调用sort重载方法完成数组a中 从索引lo到索引hi、的元素的排序
sort(a,lo,hi);
}
/*对数组a中从lo到hi的元素进行排序*/
private static void sort(Comparable[] a, int lo, int hi){
// 做安全性校验
if(hi<=lo){
return;
}
// 对lo到hi之间的数据分为两个组‘
int mid = lo+(hi - lo)/2; // 5,9 mid=7
// 分别对每一组数据进行排序
sort(a,lo,mid);
sort(a,mid+1,hi);
// 再把两个组中的数据进行记录
merge(a,lo,mid,hi);
}
// 对数组中,从lo到mid为一组,从mid+1到hi为一组,对这两组数据进行归并
private static void merge(Comparable[] a, int lo, int mid, int hi){
// 定义三个指针,分别指向开始数组的索引处和左右子组的开始索引处
int i = lo;
int p1 = lo;
int p2 = mid + 1;
// 遍历,移动p1指针和p2指针,比较对应索引处的值,找出小的那个,放到辅助数组的对应索引处
while(p1<=mid && p2<=hi){
// 比较对应索引出的值
if(less(a[p1],a[p2])){
assist[i++] = a[p1++];
}else{
assist[i++] = a[p2++];
}
}
// 遍历,如果p1的指针没有走完,那么程序移动p1指针,把对饮的元素放到辅助数组的对应索引处
while(p1 <= mid){
assist[i++] = a[p1++];
}
//遍历,如果p2的指针没有走完,那么程序移动p2指针,把对应的元素放到辅助数组的对应索引处
while(p2<=hi){
assist[i++] = a[p2++];
}
// 把辅助数组中的元素拷贝到原数组中
for(int index=lo;index <= hi; index++){
a[index] = assist[index];
}
}
}
Quick(快速)
快速排序
package Mywrite.sort;
//##### 快速排序API设计
// 1. | 类名 | Quick |
// | 构造方法 | Quick{}:创建Quick对象 |
// | 成员方法 | 1. public static void sort(Comparable[] a) : 对数组内的元素进行排序<br />
// 2. private static void sort(Comparable[] a,int lo,int hi) : 对数组a中从索引lo到索引hi之间的元素进行排序<br />
// 3. public static boolean less(Comparable v,Comparable w): 判断v是否小于w<br />
// 4. private static int partition(Comparable []a,int lo,int hi): 对数组a中,从索引lo到索引hi之间的元素进行分组,并返回分组界限对应的索引<br />
// 5. private static void exch(Comparable[] a,int i,int j): 交换a数组中,索引i和索引j处的值 |
import java.util.Arrays;
public class Quick {
public static void main(String[] args) {
Integer[] a = {6,3,5,2,1,5,7,8,3,5};
sort(a);
System.out.println(Arrays.toString(a));
}
/*
* 比较v元素是否小于w元素
* */
private static boolean less(Comparable v, Comparable w){
return v.compareTo(w) < 0;
}
/*
数组元素i和j交换位置
*/
private static void exch(Comparable[] a, int i, int j){
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
// 对数组内的元素进行排序
public static void sort(Comparable[] a) {
int lo = 0;
int hi = a.length - 1;
sort(a,lo,hi);
}
// 对数组a中从索引lo到索引hi之间的元素进行排序
private static void sort(Comparable[] a, int lo, int hi){
// 安全性校验
if(hi<=lo){
return;
}
// 需要对数组中lo索引到hi索引处的元素进行分组(左子树和右子树):
int partition = partition(a, lo, hi); // 返回的是分组的分界值所在的索引,分界值位置变换后的索引
// 让左子组有序
sort(a, lo, partition-1);
// 让右子组有序
sort(a, partition+1, hi);
}
// 切分
//对数组a中,从索引lo到索引hi之间的元素进行分组,并返回分组界限对应的索引
public static int partition(Comparable[] a, int lo, int hi){
// 确定分界值
Comparable key = a[lo];
// 定义两个指针,分别指向带切分元素的最小索引处和最大索引处的下一个位置
int left = lo;
int right = hi+1;
// 切分
while(true){
// 先从右往左扫描,移动right指针,找到一个比分界值大的元素,停止
while(less(key,a[--right])){
if(right==lo){
break;
}
}
// 再从左往右扫描。移动left指针,找到一个比分界值大的元素,停止
while(less(a[++left],key)){
if(left == hi){
break;
}
}
// 判断left>=right,如果是,则证明元素扫描完毕,结束循环,如果不是,则交换元素
if(left>=right){
break;
}else{
exch(a,left,right);
}
}
//交换分界值
exch(a,lo,right);
return right;
}
}
记录:刚开始n个月的数据结构与算法学习(java语言)
- 从不断看视频,不停地跟着视频敲代码,反反复复地理解,到现在:看着之前的练习代码疯狂试探盲敲
思路+不断练习
才是学好东西的王道- 看视频学习仅是复刻,回归书本是王道!!!刷题更是王道!!!!!
前端就业?话说我为什么不学JS的数据结构呢?
- 没有好的教学资源(我没有思路的时候,刚开始看不懂书,理解能力太差)
- 而且开学刷过一段时间JS的数据结构,纯背代码是有的,学不到思路也是真的,关键学JS的算法和数据结构人少啊!
- 算法和数据结构是一种思路,语言也不只会学一门,对吧,哈哈哈哈。
- 也欢迎准备前端就业的小哥哥和小姐姐私信交流一起学习,欢迎分享更好的学习方式呀!
要点赞+关注+收藏呦👉
笔记在博主本人的博客上也有奥!全套!!!
- 翼遥bingo【持续完善中,biu~~】