Java学习笔记＜十八＞(冒泡排序和插入排序)

冒泡排序

import org.junit.Test;

import java.util.Arrays;
//冒泡排序
public class 冒泡排序 {
 @Test
 public void a1(){
     int[] arr=new int[]{5,4,2,6,1,8,9,0,3,7};
     System.out.println(Arrays.toString(arr));
     //冒泡排序0-9
     int tmp = 0;
     for (int j = 0; j <arr.length ; j++) {
         for (int i=0;i<arr.length-j-1;i++){
             if (arr[i+1]<arr[i]){
                 tmp=arr[i];
                 arr[i]=arr[i+1];
                 arr[i+1]=tmp;
             }
         }
     }
     System.out.println(Arrays.toString(arr));
 }

 @Test
 public void a2(){
     int[] arr = new int[]{5,6,3,2,1,4,7,0,8,9};
     System.out.println(Arrays.toString(arr));
     int tmp=0;
     for (int i = 0; i < arr.length; i++) {
         //flag为真表示有序
         Boolean flag=true;
         for (int j = 0; j < arr.length-i-1; j++) {
             if (arr[j]>arr[j+1]){
                 tmp=arr[j];
                 arr[j]=arr[j+1];
                 arr[j+1]=tmp;
                 //if条件成立说明数组不是有序的
                 flag=false;
             }
         }
         if (flag){
             break;
         }
     }
     System.out.println(Arrays.toString(arr));
 }

 @Test
 public void a3(){
     int[] arr=new int[]{4,2,3,1,0,7,9,5,6};
     //最后交换顺序的位置
     int lastindex=0;
     //有序范围,首先假设全部有序
     int sortborder=arr.length-1;
     int tmp=0;
     for (int i = 0; i < arr.length; i++) {
         //有序标签.假设全部有序
         boolean flag=true;
         for (int j = 0; j < sortborder; j++) {
             if (arr[j]>arr[j+1]){
                 tmp=arr[j];
                 arr[j]=arr[j+1];
                 arr[j+1]=tmp;
                 //交换顺序
                 flag=false;
                 //改变最后交换顺序的位置
                 lastindex=j;
             }
         }
         //逐次缩小比较的范围
         sortborder=lastindex;
         if (flag){
             //没进入过交换顺序的话,说明已经有序,跳出循环
             break;
         }
     }
     System.out.println(Arrays.toString(arr));
 }

}

冒泡排序的原理：就是两个数进行前后对比，有两个循环，循环一次，把最小的值放到外层循环开始的最前面

插入排序

import java.util.Arrays;

//快速排序
public class 快速排序 {

 public static void main(String[] args) {
     int[] arr=new int[]{52, 49, 80, 36, 14, 58, 61, 97, 23, 75};
     quicksort qk=new quicksort();
     qk.arr=arr;
     int[] res = qk.sort(0, arr.length - 1);
     System.out.println(Arrays.toString(res));
 }

 static class quicksort{
     int[] arr;
     int[] sort(int low,int high){
         int i,j,t,tmp;
         if (low>high){
             return arr;
         }
         i=low;
         j=high;
         tmp = arr[low];//基准
         while (i!=j){
             //先从右向左找小于基准的数
             while (i<j && arr[j]>=tmp){
                 j--;
             }
             //再从左向右找大于基准的数
             while (i<j && arr[i]<=tmp){
                 i++;
             }
             //交换上边两个数的位置
             if(i<j){
                 t=arr[i];
                 arr[i]=arr[j];
                 arr[j]=t;
             }
             //循环交换位置,直到i==j退出循环,此时i的位置是基准该在的位置
         }
         //交换基准和循环得到的索引
         arr[low]=arr[i];//arr[low]就是tmp,这里不用再作临时变量了
         arr[i]=tmp;
         //递归处理基准左边数组
         sort(low,i-1);
         //递归处理基准右边数组
         sort(i+1,high);
         return arr;
     }
 }
}

插入排序的原理说明