Java-18:冒泡排序，选择排序，快速排序

以下为冒泡排序，选择排序，快速排序的简单实现代码，略做记录：

（1）冒泡排序，参考：

https://www.cnblogs.com/LearnAndGet/p/10237399.html

（2）选择排序，参考：

https://www.cnblogs.com/remainsu/p/java-xuan-ze-pai-xu.html

https://blog.youkuaiyun.com/cricket_7/article/details/91778089

（3）快速排序，参考：

https://blog.youkuaiyun.com/qq_38741971/article/details/81661144

https://blog.youkuaiyun.com/shujuelin/article/details/82423852

 

--第一部分：源码

package org.szxu.sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class SortAlgorithm {
	
	public static void main(String[] args) {
		/*
		List<Integer> list = new SortAlgorithm().GetUserInput();
		
		List<Integer> list1 = new SortAlgorithm().initList();
		*/
		
		/*int[] array = new int[] {6,1,2,7,9,3,4,5,10,8};
		new SortAlgorithm().fastSort(array, 0, array.length - 1);*/
		
		int[] array = new int[] {6,1,2,7,9,3,4,5,10,8};
		new SortAlgorithm().selectSort(array);
	}
	
	//获取IO输入的整数列表
	public List<Integer> GetUserInput(){
		Scanner sc = new Scanner(System.in);
		String input = sc.nextLine();
		//System.out.print(input);
		
		//String[] stringArray = input.split("\\||\\^|@");  //split说明：正则符号 | ^  .  :  *等必须转义，使用“\\”；而分割符号用“|”
		String[] strArray = input.split(" ");
		List<String> list3 = Arrays.asList(strArray);
		
		List<Integer> list4 = new ArrayList<Integer>();
		list3.forEach(i -> list4.add(Integer.valueOf(i)));   //字符串list转整形list
		
		System.out.print(list4);
		
		return list4;
	}
	
	//初始化list
	public List<Integer> initList() {
		//列表初始化方式1：
		List<Integer> list = new ArrayList<Integer>();
		for(int i=10; i > 0; i--){
			list.add(i);
		}
		
		//列表初始化方式2：
		List<Integer> list1 = Arrays.asList(10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
				
		//列表初始化方式3：外层{}定义了arraylist匿名内部类。内层{}定义了一个实例初始化代码块。
		List<Integer> list2 = new ArrayList<Integer>() {{
			add(10); add(9); add(8); add(7); add(6);
			add(5);  add(4); add(3); add(2); add(1);
		}};
		
		//列表初始化方式5：数组转list
		int[] intArray = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		List<int[]> list5 = Arrays.asList(intArray);
		Integer[] intArray1 = new Integer[] { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		List<Integer> list5_1 = Arrays.asList(intArray1);
		
		return list5_1;
	}
	
	
	//冒泡排序（while循环）
	public void bubbleSort_1(int[] array) {
		if(array == null || array.length <= 0) {
			return; 
		}
		
		int i = 0;
		int j = 1;
		boolean flag = true;
		int length = array.length;
		while(flag) {
			i = 0;
			flag = false;
			while(i < length - j) {
   				if(array[i] > array[i + 1]) {
					array[i] += array[i+1];
					array[i+1] = array[i] - array[i+1];
					array[i] = array[i] - array[i+1];
					
					flag = true;
				}
				
				i++;
			}
			
			j++;
		}
		
		//System.out.print(Arrays.asList(array));
	}
	
	//冒泡排序
	public void bubbleSort_2(int[] array) {
		if(array == null || array.length <= 0) {
			return; 
		}
		
		int tmp = 0;
		int length = array.length;
		
		for(int i = 0; i < length-1; i++) {  //第一层for控制循环趟数
			
			boolean flag = false;
			
			for(int j = 0; j < length - 1 - i; j++) { //第二层for控制一趟还需循环多少次
				if(array[j] > array[j + 1]) {
					tmp = array[j];
					array[j] = array[j+1];
					array[j+1] = tmp;
					
					flag = true;
				}
			}
			
			if(flag == false){
				break;
			}
		}
		
		//System.out.print(Arrays.asList(array));
	}
	
	
	//选择排序
	public void selectSort(int[] array){
		if(array == null || array.length <= 0) {
			return; 
		}
		
		int tmp = 0;
		int length = array.length;	
		int minIdx = 0;
		boolean flag = false;
		for(int i = 0; i < length - 1; i++ ) {
			
			minIdx = i;
			flag = false;
		
			for(int j = i + 1; j < length; j++) {
				if(array[minIdx] > array[j]) {
					minIdx = j;
					flag = true;
				}
			}
			
			if(true == flag) {
				tmp = array[i];
				array[i] = array[minIdx];
				array[minIdx] = tmp;
			}
		}
		
		//System.out.print(Arrays.asList(array));
	}
	
	
	//快速排序
	public void fastSort(int[] array, int left, int right) {
		if(array == null || array.length <= 0 || left > right) {
			return;
		}
		
		int tmp = array[left];
		int i = left;
		int j = right;
		while(i != j) {
			//一定要先从右边开始找 ，直到找到一个小于基准的值
			while(array[j] >= tmp && i < j) {
				j--;
			}
			
			//然后从左边找，直到找到一个大于基准的值
			while(array[i] <= tmp && i < j) {
				i++;
			}
			
			if(i < j) {
				array[i] += array[j];
				array[j] = array[i] - array[j];
				array[i] = array[i] - array[j];
			}
		}
		
		//将基准数归位（重要）
		array[left] = array[i];
		array[i] = tmp;
		
		if(left < i - 1) {
			fastSort(array, left, i - 1);  //将会优先递归左侧区域，然后是对应的右侧区域
		}
		
		if(i + 1 < right) {
			fastSort(array, i+1, right);
		}   
	}
}

 

--第二部分：测试 - junit:新建项目 - 新建包 - 添加junit的lib - 模仿模板方法写测试代码（可断点，但是貌似不能进入测试方法）

package org.szxu.sort;

import static org.junit.Assert.*;

import java.util.List;

import org.junit.Test;

public class SortAlgorithmTest {

    /*@Test
    public void selectSort() {
        int[] sourseArray = new int[] {10,9,8,7,6,5,4,3,2,1};
        new SortAlgorithm().selectSort(sourseArray);
        
        int[] expectedArray = new int[] {1,2,3,4,5,6,7,8,9,10};
        assertArrayEquals(expectedArray, sourseArray);
    }
    
    @Test
    public void selectBubble_1() {
        int[] sourseArray = new int[] {10,9,8,7,6,5,4,3,2,1};
        new SortAlgorithm().bubbleSort_1(sourseArray);
        
        int[] expectedArray = new int[] {1,2,3,4,5,6,7,8,9,10};
        assertArrayEquals(expectedArray, sourseArray);
    }

    @Test
    public void BubbleSort_2() {
        int[] sourseArray = new int[] {10,9,8,7,6,5,4,3,2,1};
        new SortAlgorithm().bubbleSort_2(sourseArray);
        
        int[] expectedArray = new int[] {1,2,3,4,5,6,7,8,9,10};
        assertArrayEquals(expectedArray, sourseArray);
    }
    */
    
    @Test
    public void fastSort() {
        int[] sourseArray = new int[] {10,9,8,7,6,5,4,3,2,1};
        new SortAlgorithm().fastSort(sourseArray, 0, sourseArray.length - 1);
        
        int[] expectedArray = new int[] {1,2,3,4,5,6,7,8,9,10};
        assertArrayEquals(expectedArray, sourseArray);
    }
}