冒泡排序、快速排序 java代码实现

冒泡排序

源码实现

package csdn.dreamzuora.sort;

import java.util.List;

/**
 * Title: 冒泡排序
 * Description:
 * 冒泡排序思想是把相邻的元素进行两两比较，当前面元素大于后面元素则进行交换
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/22 17:50
 */
public class BubbleSort extends Sort<Integer>{
    @Override
    public void sort(List<Integer> array) {
        if (array == null || array.isEmpty()){
            return;
        }
        int size = array.size();
        for (int i = 0; i < size - 1; i++){
            for (int j = 0; j < size - 1; j++){
                if (array.get(j) > array.get(j + 1)){
                    int temp = array.get(j + 1);
                    array.set(j + 1, array.get(j));
                    array.set(j, temp);
                }
            }
        }
    }
}

单元测试

package csdn.dreamzuora.sort;

import com.sun.deploy.util.StringUtils;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;

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

import static org.junit.Assert.*;

/**
 * Title:
 * Description:
 *
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/22 18:33
 */
public class BubbleSortTest {

    BubbleSort bubbleSort = new BubbleSort();


    @Test
    public void sort() {
        List<Integer> sortList = Arrays.asList(3, 5, 4, 0, 1);
        List<Integer> expectList = Arrays.asList(0, 1, 3, 4, 5);
        bubbleSort.sort(sortList);
        Assertions.assertEquals(expectList, sortList);
    }
}

优化

package csdn.dreamzuora.sort;

import java.util.List;

/**
 * Title: 冒泡排序优化
 * Description:
 * 优化：在外层循环处，设置标志isSort，默认为排好，如果不交换则跳出本次循环
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/22 18:50
 */
public class BubbleSortPlus extends Sort<Integer>{
    @Override
    public void sort(List<Integer> array) {
        if (array == null || array.isEmpty()){
            return;
        }
        int size = array.size();
        for (int i = 0; i < size - 1; i++){
            boolean isSort = true;
            for (int j = 0; j < size - 1; j++){
                if (array.get(j) > array.get(j + 1)){
                    isSort = false;
                    int temp = array.get(j + 1);
                    array.set(j + 1, array.get(j));
                    array.set(j, temp);
                }
            }
            if (isSort){
                break;
            }
        }
    }
}

快速排序

源码实现

package csdn.dreamzuora.sort;

import java.util.List;

/**
 * Title: 快速排序
 * Description:
 * 快速排序每一轮找出一个标准值，大于该值的放在右边，小于该值放在左边，从而把数组拆分成两部分，这种思路叫做分治法
 *
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/22 17:50
 */
public class QuickSort extends Sort<Integer> {


    /**
     *
     * @param a 数组
     * @param left 头指针
     * @param right 尾指针
     */
    @Override
    public void sort(List<Integer> a, int left, int right) {
        if (left >= right){
            return;
        }
        int value = a.get(left);
        //用来控制分治头指针、尾指针
        int i = left;
        int j = right;
        while (left < right){
            //先移动尾指针
            while (right != left && a.get(right) >= value){
                right --;
            }
            //再移动头指针
            while (left != right && a.get(left) <= value){
                left ++;
            }
            //如果指针重合，则确定了value下标，进行交换
            if (left == right){
                a.set(i, a.get(left));
                a.set(left, value);
                //分治
                sort(a, i, left - 1);
                sort(a, left + 1, j);
            }
            //如果指针没有重合则进行交换头尾指针值
            else {
                int temp = a.get(left);
                a.set(left, a.get(right));
                a.set(right, temp);
            }
        }
    }

    /**
     * 单边循环法:以后再研究
     * @param array
     */
    public void sort2(List<Integer> array){

    }
}

单元测试

package csdn.dreamzuora.sort;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;

import static org.junit.Assert.*;

/**
 * Title:
 * Description:
 *
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/23 18:18
 */
public class QuickSortTest {

    QuickSort quickSort = new QuickSort();

    @Test
    public void sort() {
        List<Integer> list = Arrays.asList(5, 8, 6, 3, 9, 2, 1, 7);
        quickSort.sort(list, 0, list.size() - 1);
        System.out.println(list);
    }
}