八大排序算法交换排序算法

一:冒泡排序

1:冒泡排序思想

从第一个元素开始，依次比较数组中的元素，如果比其小就交换(如果是升序的话)，经过n-1轮排序后我们就可以得到有序序列了

2:上码

• 版本一

public static void bubblingSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
   
        for (int j = arr.length - 2; j >= i; j--) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
           
            }
        }
    }
}

• 版本二（两两交换,并对其进行优化）

public static void bubblingSort(int[] arr) {

    for (int i = 0; i < arr.length - 1; i++) {

        boolean flag = false;

        for (int j = arr.length - 2; j >= i; j--) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag = true;
            }
        }

        if (flag == false) break;//如果没有发生交换，证明是有序的
        else flag = false;

    }
}

二:快速排序

1:快速排序的思想

我们选取出一个哨兵,然后将整个序列分成两部分，其中一部分中所记录的关键值都比该哨兵的值小,另外一部分所记录的关键值都比该哨兵值大。然后再对这两部分分别再选取哨兵，再进行划分,直到最终序列有序为止。

2:上码

public static void quickSort(int arr[], int left, int right) {
    int index;//哨兵
    if (left < right) {
        index = partIndex(arr, left, right);
        
        quickSort(arr, left, index - 1);
        quickSort(arr, index + 1, right);
    }
}

//注意我们是从右边开始比较,因为我们选取的哨兵是左边的,如果我们从左边开始比较的话那么就会丢失数据
public static int partIndex(int arr[], int left, int right) {
    int l = left;
    int r = right;
    int point = arr[l];

    while (l < r) {//一旦 r >= l 的话 那么我们就需要终止循环

        while (l < r && arr[r] >= point) {//直到遇见一个比arr[point]值小的然后进行交换
            r--;
        }

        swap(arr, l, r);

        while (l < r && arr[l] <= point) {//直到遇见一个比arr[point]值大的然后进行交换
            l++;
        }

        swap(arr, l, r);
    }



    return l;//返回我们的我们的哨兵位置，经过上面的运算,我们已经将数据分成了两部分,一部分比哨兵大,一部分比哨兵小
    //这里返回 l 和 r 都是可以的 因为我们最终跳出循环的时候,
}

public static void swap(int arr[], int a, int b) {
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}