- 首先我自己封装了一些常用的工具方法、工具类，在排序算法中都有应用，当然以后会不断扩充的
/**
* Copyright (c) 2013-Now http://AIminminAI.com All rights reserved.
*/
package UtilsByHu;
/**
*
* @author HHB
* @version 2022年4月11日
*/
public class ArrayUtils {
/**
* 专门用于打印数组的方法(函数)
* @param arr
* @author HHB
*/
public void printArr(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print("第" + i + "个数组元素是" + arr[i] + " ");
}
}
public void printArr(char[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print("第" + i + "个数组元素是" + arr[i] + " ");
}
}
/**
* 用于交换数组arr中两个元素a和b的工具方法
* @param arr
* @param a
* @param b
* @return
* @author HHB
*/
public void swapArray(int[] arr, int a, int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
/**
* Copyright (c) 2013-Now http://AIminminAI.com All rights reserved.
*/
package UtilsByHu;
import java.util.Iterator;
import java.util.List;
/**
*
* @author HuHongBo
* @version 2022年4月15日
*/
public class CollectionUtils {
/**
* 专门迭代遍历并打印出字符串的
* @param list
* @author HHB
*/
public void printCollectionOfString(List<String> list){
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String string2 = (String) iterator.next();
System.out.print(string2 + " ");
}
}
public void printCollectionOfListString(List<List<String>> list){
Iterator<List<String>> iterator = list.iterator();
while (iterator.hasNext()) {
List<String> string2 = iterator.next();
printCollectionOfString(string2);
}
}
/**
* 专门迭代打印List>
* @param list
* @author HHB
*/
public void printCollectionOfIntegerDouble(List<List<Integer>> list){
Iterator<List<Integer>> iterator = list.iterator();
while (iterator.hasNext()) {
List<Integer> num = iterator.next();
System.out.print(num + " ");
}
}
/**
* 专门用于迭代打印List
* @param list
* @author HHB
*/
public void printCollectionOfInteger(List<Integer> list){
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
int num = iterator.next();
System.out.print(num + " ");
}
}
}
- 选择排序
/**
* Copyright (c) 2013-Now http://AIminminAI.com All rights reserved.
*/
package SortingAlgorithm;
import UtilsByHu.ArrayUtils;
/**
*
* 快速排序：就是搭建一个舞台，也就是将第一个元素带上舞台，然后让第一个元素和第二个一直到最后一个分别比较一下，然后找出最小值及其索引，然后将这个最小值和第一个元素相互交换。
* 然后针对除第一个元素外剩余的元素们，将舞台搭在第二个元素处，在用第二个与后面每一个轮流比较找出这些元素中最小的，找出最小的与第二个元素交换，
* 然后针对除第二个元素外剩余的元素们......
* 再到第三个....一直到最后一个
*
* @author HHB
* @version 2022年4月9日
*/
public class SelectionSort {
/**
* 第一個版本，算是先找出整個數組中的最小元素所在位置，并將這個索引值賦值給minValue
* 然後將最小值與數組的第一個元素交換
*
* @param args
* @author HHB
*/
// public static void main(String[] args) {
// int[] arr = new int[] { 2, 5, 4, 3, 7, 6, 1, 9, 8 };
// for (int i = 0; i < arr.length; i++) {
// System.out.print("第" + i + "个数组元素是" + arr[i] + " ");
// }
//
// //搭建一个舞台，放每轮最小的值,最開始假設0這個位置是最小值所在位置
// int minValue = 0;
// int i = 0;
// for (i = 1; i < arr.length - 1; i++) {
// if (arr[i] < arr[minValue]) {
// minValue = i;
// System.out.println(minValue);
// }
// }
// int temp = arr[minValue];
// arr[minValue] = arr[0];
// arr[0] = temp;
// System.out.println("===============");
// for (int j = 0; j < arr.length; j++) {
// System.out.print("第" + j + "个数组元素是" + arr[j] + " ");
// }
// }
/**
* 第二个版本，大体实现选择排序功能，然后在第三阶段中对某些可复用的功能进行封装
* @param args
* @author HHB
*/
// public static void main(String[] args) {
// int[] arr = new int[] { 2, 5, 4, 3, 7, 6, 1, 9, 8, 23, 85, 56, 22, 11, 30 };
// for (int i = 0; i < arr.length; i++) {
// System.out.print("第" + i + "个数组元素是" + arr[i] + " ");
// }
//
//
// for (int k = 0; k < arr.length; k++) {
// //搭建一个舞台，放每轮最小的值,最開始假設0這個位置是最小值所在位置
// int minValue = k;
// for (int i = k + 1; i < arr.length; i++) {
// if (arr[i] < arr[minValue]) {
// minValue = i;
System.out.println(minValue);
// }
// }
// int temp = arr[minValue];
// arr[minValue] = arr[k];
// arr[k] = temp;
// }
//
// System.out.println("===============");
// for (int j = 0; j < arr.length; j++) {
// System.out.print("第" + j + "个数组元素是" + arr[j] + " ");
// }
// }
/**
* 第三个阶段，对某些可复用的功能进行封装，成为方法
* @param args
* @author HHB
*/
public static void main(String[] args) {
int[] arr = new int[] { 2, 5, 4, 3, 7, 6, 1, 9, 8, 23, 85, 56, 22, 11, 30 };
new ArrayUtils().printArr(arr);
selectionSort(arr);
System.out.println("===============");
new ArrayUtils().printArr(arr);
}
public static void selectionSort(int[] arr){
for (int k = 0; k < arr.length; k++) {
//搭建一个舞台，放每轮最小的值,最開始假設0這個位置是最小值所在位置
int minValue = k;
for (int i = k + 1; i < arr.length; i++) {
if (arr[i] < arr[minValue]) {
minValue = i;
// System.out.println(minValue);
}
}
new ArrayUtils().swapArray(arr, minValue, k);
}
}
}
- 冒泡排序
/**
* Copyright (c) 2013-Now http://AIminminAI.com All rights reserved.
*/
package SortingAlgorithm;
import UtilsByHu.ArrayUtils;
/**
*
* 冒泡排序:从数组第一个元素开始，让第一个元素和第二个元素比较大的移到后面，然后第二个和第三个比较....倒数第二个和倒数第一个比较，最后就把最大的元素移到了最后一格
* 接着，从从数组第一个元素开始，让第一个元素和第二个元素比较大的移到后面，然后第二个和第三个比较....倒数第三个和倒数第二个比较,最后就把第二大元素移到了倒数第二格
* ...
* 最后就把倒数第一大元素放在了第一格
* 为啥要叫冒泡，可以把要排序的数组竖起来，两个一比较两个一比较，那是不是把大的元素嘟嘟嘟滴冒到了数组最后面的格子，倒过来不就是嘟嘟嘟向上冒嘛
*
* @author HHB
* @version 2022年4月13日
*/
public class BubbleSorting {
public static void main(String[] args) {
int[] arr = new int[]{9, 6, 2, 23, 3, 46, 18, 7, 4, 8, 1, 5};
new ArrayUtils().printArr(arr);
bubbleSort(arr);
System.out.println("=====");
new ArrayUtils().printArr(arr);
}
public static void bubbleSort(int[] arr){
/**
* 这两层for循环的终止条件的书写形式都可以
*/
// for (int k = arr.length; k > 0; k--) {
// System.out.println("=====");
// System.out.println(k);
// for (int i = 0; i < k - 1; i++) {
// if(arr[i] > arr[i + 1]){
// new ArrayUtils().swapArray(arr, i, i + 1);
// }
// }
// }
for (int k = arr.length - 1; k > 0; k--) {
for (int i = 0; i < k; i++) {
if(arr[i] > arr[i + 1]){
new ArrayUtils().swapArray(arr, i, i + 1);
}
}
}
}
}
- 插入排序：
/**
* Copyright (c) 2013-Now http://AIminminAI.com All rights reserved.
*/
package SortingAlgorithm;
import UtilsByHu.ArrayUtils;
/**
* 插入排序：将后面的大小不合适的一个元素通过从最后一个一个比较把他换到前面的合适大小的位置
* 就跟打扑克牌一样，如果咱们拿到一张牌要插到前面两张牌中，相当于把比这张牌大的所有后面元素都要向后移动
* @author HHB
* @version 2022年4月22日
*/
public class InsertionSorting {
public static void insertionSort(int[] arr){
/**
* 从第一个位置（上的元素）开始先向后遍历，如果碰到前大后小的元素，就把这个小的插到大的前面（为什么要叫插呢，因为并不是移动一步），比如1532，那这个2是不是要插到35的前面，相当于要交换两次，所以交换两次了那就不能叫普通的交换了，要交插入
*/
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
new UtilsByHu.ArrayUtils().swapArray(arr, j, j - 1);
}
}
}
}
public static void main(String[] args) {
int[] arr = new int[]{9, 6, 2, 23, 3, 46, 18, 7, 4, 8, 1, 5};
new ArrayUtils().printArr(arr);
insertionSort(arr);
System.out.println("=====");
new ArrayUtils().printArr(arr);
}
}
未完待续
巨人的肩膀：
bilibili好多讲算法的老师
labuladong老师，推荐一下他的公众号，干货多多
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）