1、冒泡排序
package com.jdL.day21classwork;
public class BubbleSort {
public static void main(String[] args) {
//冒泡排序
int[] arrays={2,301,9,99,1,98,687,232,189,65,30,45,120,20,37,32,72,11,21};
BubbleSortMain(arrays);
for(int index=0;index<arrays.length;index++){
System.out.print(arrays[index]+",");
}
}
private static void BubbleSortMain(int[] arrays) {
int temp=0;
//第一层for是用来判断每一个值都需要走一遍冒泡（除了最后一个值：别人都冒完了，最后一个肯定是最小的）
for (int j = 0; j< arrays.length-1; j++) {
//第二层for在第一层的基础上，每次冒出一个最大值，下一个就减少一个冒泡判断的数字
for(int i = 0; i< arrays.length-1-j; i++){
//如果发现前一个值大于下一个值，就交换位置
if(arrays[i]> arrays[i+1]){
temp= arrays[i+1];
arrays[i+1]= arrays[i];
arrays[i]=temp;
}
}
}
}
}2、选择排序
package com.jdL.day21classwork;
public class SelectionSort {
public static void main(String[] args) {
//选择排序
int[] arrays={2,301,9,99,1,98,687,232,189,65,30,45,120,20,37,32,72,11,21};
selectionSort(arrays);
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+",");
}
}
public static void selectionSort(int[] arrays){
//1、第一轮：把索引0数据和后续索引的数值比较，小的往前挪
int temp=0;
//第一层for循环是依次拿出数组的每个元素（最后一个不用拿，因为前面的排完了，最后一个肯定是最大了）
for (int j=0;j<arrays.length-1;j++) {
//第二次for循环是把第一层for循环中拿到的数据依次和后面的数据比较，如果小就前移，第二层循环的时候
//之前排序好的就不用重复排序了
for(int i=1+j;i<arrays.length;i++){
if(arrays[j]>arrays[i]){
temp=arrays[i];
arrays[i]=arrays[j];
arrays[j]=temp;
}
}
}
}
}插入排序：
package com.jdL.day21classwork;
import java.util.Arrays;
public class InsertionSort {
public static void main(String[] args) {
//插入排序
int[] arrays={3,38,44,5,47,15,36,26,27,2,46,4,19,50,48};
InsertionSort(arrays);
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+",");
}
}
public static void InsertionSort(int[] arrays){
//1、找到无序的数据从那个索引开始的，从数组0索引开始找，找到一个数据比后面一个要大，返回索引值
int startIndex=0;
for(int i=0;i<arrays.length;i++){
if(arrays[i]>arrays[i+1]){
startIndex=i+1;
break;
}
}
//2、从startIndex遍历
for(int j=startIndex;j<arrays.length;j++){
//把遍历到的数据插入到前面有序的数据里面
//核心：其实是把无序里面的数据和前面有序里面的数据倒着依次比较，如果碰到大于无序数据的，就交换位置
for(int i=j;i>0;i--){
//这里其实可以认为是一个小的冒泡排序
if(arrays[i-1]>arrays[i]){
int temp=arrays[i];
arrays[i]=arrays[i-1];
arrays[i-1]=temp;
}
}
}
}
}递归算法：
心得：方法内部调用方法的时候，一定要更靠近出口
求和：1~100之间的和
package com.jdL.day21classwork;
public class Recursion {
public static void main(String[] args) {
System.out.println(getSum(100));
}
public static int getSum(int number){
if(number==1){
return 1;
}else{
return number+getSum(number-1);
}
}
}递归求5的阶乘
package com.jdL.day21classwork;
public class RecursionFactorial {
public static void main(String[] args) {
//递归求5的阶乘
System.out.println(getFactorial(5));
}
public static int getFactorial(int number){
if(number==1){
return 1;
}else{
return number*getFactorial(number-1);
}
}
}快速排序：
package com.jdL.day21classwork;
public class FastSort {
public static void main(String[] args) {
//快速排序
int[] arrays={6,1,2,7,9,3,4,5,10,8};
fastsort(arrays,0,arrays.length-1);
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+",");
}
}
//参数1：排序的数组
//参数2：排序的起始索引
//参数3：排序的末尾索引
public static void fastsort(int[] arr,int i,int j){
int start=i;
int end=j;
//记录基准数
if(start>end){
return;
}
int basenumber=arr[i];
while(start!=end){
//利用end从后往前比基准数小的数字
while(true){
if(end<=start||arr[end]<basenumber){
break;
}
end--;
}
//利用start从前往后找比基准数大的数字
while(true){
if(end<=start||arr[start]>basenumber){
break;
}
start++;
}
//把end和start所指的数字交换
int temp=arr[end];
arr[end]=arr[start];
arr[start]=temp;
}
//当start和end指向同一个元素的时候，上面的循环就会结束
int temp1=arr[i];
arr[i]=arr[start];
arr[start]=temp1;
//确定基准数左边的内容，递归调用
fastsort(arr,i,start-1);
fastsort(arr,start+1,j);
}
}需要注意：如果是从小到大排序，就需要先移动end