常用算法--基本排序算法(冒泡排序,选择排序,插入排序,快速排序,归并排序,桶排序)

1.冒泡排序:
思想:以小到大排序为例,对无序的数据两两进行比较,大的放在右面,小的放在左面.
(1,2),(1,3)...(2,3),(2,4)...(n-1,n-1),(n-1,n)
时间复杂度: O(n) ~ O(n2)O(n2~

Java代码实现:
public class MaopaoSort {
public static void main(String[] args) {
int arr[] = {43,32,12,64,14,-1,37};
int temp;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
if(arr[i]<arr[j]){
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
                //遍历排序后的数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}

}
2.选择排序:
思想: 以从小到大为例:从无序数组取第一个元素,然后与其他元素进行比较,若找到比他小的,就进行交换,遍历完之后就确定了第一个元素,然后再取第二个元素,也是进行一组遍历,找到第二个最小数.遍历完之后就确定了第一个元素,然后再取第二个元素,也是进行一组遍历,找到第二个最小数.

时间复杂度:O(n2)
Java代码实现:
public class selectSort { //选择排序
public static void main(String[] args) {
int arr[] = {43,32,12,64,14,-1,37};
int temp,min;
for (int i = 0; i < arr.length; i++) {
min = arr[i];
//遍历一轮,找到最小的,放到第一个位置
for (int j = 0; j < arr.length; j++) {
if(arr[j]>min){
temp = min;
min = arr[j];
arr[j] = temp;
}
}
arr[i] = min;

}
                //遍历排序后的数组

for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}

}
3.插入排序:
思想:以从小到大为例:以第一个元素为基准,第二个元素与第一个进行比较,如果二比一小,则一二位置互换.第三个元素与前面一二进行比较,如果比二小,就二三互换,互换后三再与一比较,比一小就一三互换.交换完后三就确定好了,继续判断四,以此类推...
时间复杂度:O(n2)

Java代码实现:

public class directSelectSort {
public static void main(String[] args) {
int src[] = { 43, 32, 12, 64, 14, -1, 37 };
int len = src.length;
// 从第二个元素开始比
for (int i = 1; i < len; i++) {
int j;
int temp = src[i];
// 从后往前逐一判断比前面是否有比它小的元素,有就交换位置
for (j = i; j > 0; j--) {
if (src[j - 1] > temp) {
src[j] = src[j - 1];

} else// 如果当前的数，不小前面的数，那就说明不小于前面所有的数，
break;// 因为前面已经是排好了序的，所以直接退出当前一轮的比较
}
src[j] = temp;
for (int k = 0; k < src.length; k++) {
System.out.println(src[k]);
}
}
for (int k = 0; k < src.length; k++) {
System.out.println(src[k]);
}
}

}
4.快速排序(特点:速度快,省空间):
原理: 以第一个元素作为基准元素,判断其他元素比它大还是小,大的放到元素右侧,小的放到元素左侧.确定左侧都是比第一个元素小的元素,右侧都是比它大的元素.然后递归判断左侧和右侧的元素们,用同样的方法进行分割,直到分割到一个元素,就将全部元素排成有序的序列了.
时间复杂度: O(nlog2n) ~ O<
de3d
/span>(n2)  ~~O(n2)O(nlog2n

Java代码实现:

public class QuickSort {
public static void quickSort(int[] arr, int low, int high) {
int i, j, num, temp;
if (low > high) {
return;
}
i = low;
j = high;
// num就是基准位,取得第一个元素
num = arr[low];
// 最外层循环限定下标的位置,当左右比较到中点时停止
//比较一遍会把第一个数的左右排好,左边都比它小,右边都比它大
while (i < j) {
//第一个元素从右侧找一个比它大的.找到退出
while (num <= arr[j] && i < j) {
j--;
}
//第一个元素从左侧找一个比它小的,找到退出,
while (num >= arr[i] && i < j) {
i++;
}
// 如果满足条件则交换(再次确保左右比较时没有过界)
if (i < j) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
// 最后将基准为与i和j相等位置的数字交换
arr[low] = arr[i];
arr[i] = num;
// 递归调用左半数组
quickSort(arr, low, j - 1);
// 递归调用右半数组
quickSort(arr, j + 1, high);
}

public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        //输出排序后的数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
5.归并排序(特点:比较稳定):
思想: 将要排序序列分成多个子序列,然后将子序列两两合并.使其有序.其中用到了递归的思想.通过递归层层合并.也就是归并的含义.
时间复杂度:O(nlog2n)
Java代码实现:
public class MergeSort
{
    public static int[] sort(int[] nums, int low, int high)
    {
        int mid = (low + high) / 2;
        if (low < high)
        {
            // 左边
            sort(nums, low, mid);
            // 右边
            sort(nums, mid + 1, high);
            // 左右归并
            merge(nums, low, mid, high);
        }
        return nums;
    }
    public static void merge(int[] nums, int low, int mid, int high)
    {
        int[] temp = new int[high - low + 1];
        int i = low;// 左指针
        int j = mid + 1;// 右指针
        int k = 0;
        // 把较小的数先移到新数组中
        while (i <= mid && j <= high)
        {
            if (nums[i] < nums[j])
            {
                temp[k++] = nums[i++];
            }
            else
            {
                temp[k++] = nums[j++];
            }
        }
        // 把左边剩余的数移入数组
        while (i <= mid)
        {
            temp[k++] = nums[i++];
        }
        // 把右边边剩余的数移入数组
        while (j <= high)
        {
            temp[k++] = nums[j++];
        }
        // 把新数组中的数覆盖nums数组
        for (int k2 = 0; k2 < temp.length; k2++)
        {
            nums[k2 + low] = temp[k2];
        }
    }
    // 归并排序的实现
    public static void main(String[] args)
    {
        int[] nums = { 2, 7, 8, 3, 1, 6, 9, 0, 5, 4 };
        MergeSort.sort(nums, 0, nums.length - 1);
        System.out.println(Arrays.toString(nums));
    }

}
6.桶排序(特点:速度最快,占用空间最大):
思想:我们需要知道该序列中最大的一个数,然后申请一块空间(桶群),能容下从0到该数的所有数,然后判断序列中的元素在桶群中那个桶中,以及出现的次数.判断完成后对桶群进行遍历.输出有序的序列.
时间复杂度:O(N+C)
Java代码实现:
import java.util.ArrayList;
import java.util.Collections;
public class bucketSort {
public static void bucketSort(int[] arr) {
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for (int i = 0; i < arr.length; i++) {
max = Math.max(max, arr[i]);
min = Math.min(min, arr[i]);
}
// 桶数
int bucketNum = (max - min) / arr.length + 1;
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
for (int i = 0; i < bucketNum; i++) {
bucketArr.add(new ArrayList<Integer>());
}
// 将每个元素放入桶
for (int i = 0; i < arr.length; i++) {
int num = (arr[i] - min) / (arr.length);
bucketArr.get(num).add(arr[i]);
}
// 对每个桶进行排序
for (int i = 0; i < bucketArr.size(); i++) {
Collections.sort(bucketArr.get(i));
}
System.out.println(bucketArr.toString());
}
public static void main(String[] args) {
int[] nums = { 2, 7, 8, 3, 1, 6, 9, 0, 5, 4 };
bucketSort(nums);
}

}
觉得对你有帮助或者喜欢的可以点个赞哦~~