Java常见的排序算法详解

已于 2022-01-26 17:53:44 修改
阅读量954 收藏 7
点赞数 16
分类专栏： JAVA 数据结构 编程 文章标签： java 排序算法 算法
于 2022-01-25 22:49:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dddddrrrzz/article/details/122657750
版权
编程 同时被 3 个专栏收录
38 篇文章 3 订阅
订阅专栏
JAVA
21 篇文章 3 订阅
订阅专栏
数据结构
13 篇文章 2 订阅
订阅专栏

目录

两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。

一、直接插入排序

整个区间被分为

  1. 有序区间
  2. 无序区间

每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。

   public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i - 1;
            for ( ; j >= 0 ; j--) {
                if (arr[j] > tmp){
                    arr[j + 1] = arr[j];
                }else{
                    //arr[j + 1] = tmp;//只要j回退的时候，遇到了比tmp小的元素，就结束了这次的比较
                    break;
                }
            }
            //j回退到了小于0的地方
            arr[j + 1] = tmp;
        }
    }
    public static void main(String[] args) {
        int[] array = {6,10,9,3,5};
        insertSort(array);
        System.out.println(Arrays.toString(array));
    }
}

输出结果：
在这里插入图片描述
时间复杂度:最好O(N)–>数据本身是有序的；
* 最坏O(N^2)；–>数据逆序；
* 当一组数据，数据量不大且趋近于有序，此时用插入排序时间更快，越有序越快。
空间复杂度：O(1)；
稳定性：稳定的排序；
一个稳定的排序可以实现为不稳定的排序，但是一个本身就不稳定的排序不可以变成稳定的排序。

二、希尔排序

希尔排序法又称缩小增量法。
希尔排序法的本质是插入排序，只不过是将待排序的序列按某种规则分成几个子序列，分别对几个子序列进行直接插入排序。这个规则就是增量，增量选取很重要，增量一般选序列长度一半，然后逐半递减，直到最后一个增量为1，为1相当于直接插入排序。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public static void shell(int[] arr,int gap){
    for (int i = 1; i < arr.length; i++) {
        int tmp = arr[i];
        int j = i - gap;
        for (; j >= 0 ; j-=gap) {
            if(tmp < arr[j]){
                arr[j + gap] = arr[j];
            }else{
                break;
            }
        }
        arr[j+gap] = tmp;
    }
}
    public static  void shellSort(int[] arr) {
        int gap = arr.length;
        //增量在缩小，最后一组的增量为1
        while (gap > 1){
            gap /= 2;
            shell(arr,gap);

        }
        shell(arr,1);
    }
    public static void main(String[] args) {
        int[] array = {9,1,2,5,7,4,8,6,3,5};
        shellSort(array);
        System.out.println(Arrays.toString(array));

输出结果：
在这里插入图片描述

时间复杂度：O（n^1.3 - n^1.5）；
空间复杂度：O(1)；
稳定性：不稳定；
看在比较的过程中，是否发生了跳跃式的交换，如果发生了跳跃式的交换，那么就是不稳定的排序。

三、选择排序

从指定元素开始，遍历其后面的元素，如遇到后面的元素比指定元素小，则进行交换，直到把整个数组遍历完，直到全部指定待排序的数据元素排完 。

public static void swap(int[] array,int i ,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {         
            for (int j = i + 1;; j <array.length ; j++) {
               if(array[j] < array[i]){
                   int tmp = array[i];
                   array[i] = array[j];
                   array[j] = tmp;
               }
            }
        }
    }

//优化
//遍历完指定元素后面的元素找到最小的一个数和其进行交换
 public static void selectSort1(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int min = i;
            for (int j = i + 1; j <array.length ; j++) {
                if(array[j] < array[min]){
                    min = j;
                }
            }
            //两元素进行交换的函数
            swap(array,i,min);
        }
    }
 public static void main(String[] args) {
        int[] array = {9,1,2,5,7,4,8,6,3,5};
        selectSort(array);
        System.out.println(Arrays.toString(array));

稳定性：不稳定的排序
时间复杂度：O(N^2)，时间复杂度不等于代码的运行时间
空间复杂度：O(1)。

四、堆排序

基本原理也是选择排序，只是不再使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。
注意： 排升序要建大堆；排降序要建小堆
堆排序动画演示

public static void swap(int[] array,int i ,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
public static void creatHeap(int[] arr){
        for (int parenr = (arr.length -1-1)/2; parenr >= 0 ; parenr--) {
            shiftDown(arr,parenr,arr.length);
        }
    }

    public static void heapSort(int[] arr){
            //建堆O(n)
        creatHeap(arr);
        int end = arr.length - 1;
        //交换然后调整O(n*log n)
        while (end > 0){
            swap(arr,0,end);
            shiftDown(arr,0,end);
            end--;
        }
    }
    public static void shiftDown(int[] arr,int parent,int len){
        int child = 2 * parent + 1;
        while (child < len){
            if (child+1 < len && arr[child] < arr[child + 1]){
                child++;
            }
            if (arr[child] > arr[parent]){
                swap(arr,child,parent);
                parent = child;
                child = 2 * parent +1;
            }else {
                break;
            }
        }
    }
 public static void main(String[] args) {
        int[] array = {9,1,2,5,7,4,8,6,3,5};
        heapSort(array);
        System.out.println(Arrays.toString(array));

稳定性：不稳定；
空间复杂度：O(1)；
时间复杂度：O(n*log n)。

五、冒泡排序

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。

 public static void swap(int[] array,int i ,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
 public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            boolean flg = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j+1] < arr[j]){
                    swap(arr,j+1,j);
                    flg = true;
                }
            }
            //如果走完一遍循环之后，flg依旧为false，则没有进行交换，此时就可以提前结束循环，提高了代码的运行时间。
            if (flg == false){
                break;
            }
        }
    }
public static void main(String[] args) {
        int[] array = {9,1,2,5,7,4,8,6,3,5};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));

时间复杂度：O(N^2)；有序情况下：O(N)；
空间复杂度：O(1)；
稳定性：稳定。

六、快速排序

原理：

  1. 从待排序区间选择一个数，作为基准值(pivot)；
  2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
  3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

6.1

挖坑法

其主要思想为：选取数组中的第一个元素tmp作为比较的对象，然后先将整个数组从后（end位置）往前遍历：如果后面的值比tmp值大，则end往前移动，直到遇到比tmp小的元素，则将此位置的值移动到第一个元素所在的位置，然后从该位置有从前（start）往后遍历，如果start的值小于tmp，则start往后移动，直到遇到比tmp大的元素，则将此位置的值移动到end所在的位置，按照此方法，依次遍历完整个数组，即可找到基准值所在位置。

 public static void quickSort1(int[] arr) {
        quick(arr, 0, arr.length - 1);
    }

    public static void quick(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int pivot = partition(arr, left, right);
        quick(arr, left, pivot - 1);
        quick(arr, pivot + 1, right);
    }
     public static int partition(int[] arr, int start, int end) {
        int tmp = arr[start];
        while (start < end) {
			//如果数组最后面的数比tmp大，则end往前走
            while (start < end && arr[end] >= tmp) {
                end--;
            }
            //end就遇到了小于tmp的值
            arr[start] = arr[end];
            while (start < end && arr[start] <= tmp) {
                start++;
            }
            //start就遇到了大于tmp的值
            arr[end] = arr[start];
        }
        //将tmp的值放到相遇start和end的位置
        arr[start] = tmp;
        return start;
    }

时间复杂度：最好【每次可以均匀的分割待排序序列】：O(n*log n) 最坏：【数据有序或者逆序的情况】O(n^2);
空间复杂度：最好[就是树的高度]：O(log n) 最坏:[退化成一颗单分支的树]：O(n);
稳定性：不稳定;

Hoare 法

private static int partition(int[] array, int left, int right) {
	int i = left;
	int j = right;
	int pivot = array[left];
	while (i < j) {
		while (i < j && array[j] >= pivot) {
			j--;
		}
		while (i < j && array[i] <= pivot) {
			i++;
		}
	swap(array, i, j);
	}
	swap(array, i, left);
	return i;
}

前后遍历法

private static int partition(int[] array, int left, int right) {
	int d = left + 1;
	int pivot = array[left];
	for (int i = left + 1; i <= right; i++) {
			if (array[i] < pivot) {
				swap(array, i, d);
				d++;
			}
		}
	swap(array, d, left);
	return d;
}

6.2基准值的选择

1.随机选取基准法：有可能每次随机的数据，作为基准的时候，也会出现单分支的情况；
2.选择边上（左或者右）挖坑法；
3.几数取中（例如三数取中）：array[left], array[mid], array[right] 大小是中间的为基准值。
4.把基准值相同的数据，从两边移动跟前；
5.利用直接插入排序越有序越快的规则来进行优化。

6.3三数取中法示例

public static void quickSort1(int[] arr) {
        quick(arr, 0, arr.length - 1);
    }
    public static void quick(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        //找基准之前找到中间大小的数  几数取中（使用三数取中法）
        int midValue = findMidValue(arr, left, right);
        swap(arr,midValue,left);//找到中间大小的数之后和最左边的数进行交换
        int pivot = partition(arr, left, right);
        quick(arr, left, pivot - 1);
        quick(arr, pivot + 1, right);
    }
    //找基准之前找到中间大小的数  三数取中
    public static int findMidValue(int[] arr, int start, int end) {
        int mid = start + (end - start)/2;
//        int mid = start + ((end - start)>>>1);
        if (arr[start] < arr[end]){  //最前面的值小于最后面的值
            if (arr[mid] < arr[start]){ //中间的值又小于最前面的值
                return start;  //则三数中中间大的值为start位置的值
            }else if (arr[mid] > arr[end]){
                return end;
            }else {
                return mid;
            }
        }else {//最前面的值大于最后面的值
            if (arr[mid] > arr[start]){
                return start;
            }else if (arr[mid] < arr[end]){
                return end;
            }else {
                return mid;
            }
        }
    }

    public static int partition(int[] arr, int start, int end) {
        int tmp = arr[start];
        while (start < end) {

            while (start < end && arr[end] >= tmp) {
                end--;
            }
            //end就遇到了小于tmp的值
            arr[start] = arr[end];
            while (start < end && arr[start] <= tmp) {
                start++;
            }
            //start就遇到了大于tmp的值
            arr[end] = arr[start];
        }
        //将tmp的值放到相遇start和end的位置
        arr[start] = tmp;
        return start;
    }

6.4直接插入法排序优化示例

 public static void insertSort2(int[] arr,int start,int end ) {
        for (int i = 1; i < end; i++) {
            int tmp = arr[i];
            int j = i - 1;
            for (; j >= start; j--) {
                if (arr[j] > tmp) {
                    arr[j + 1] = arr[j];
                } else {
                    //arr[j + 1] = tmp;//只要j回退的时候，遇到了比tmp小的元素，就结束了这次的比较
                    break;
                }
            }
            //j回退到了小于0的地方
            arr[j + 1] = tmp;
        }
    }

    public static void quickSort1(int[] arr) {
        quick(arr, 0, arr.length - 1);
    }

    public static void quick(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        //如果区间内的数字，在排序的过程当中，小于某个范围，可以使用直接插入排序
        if (left - right + 1 <= 40) {  //40这个数可以自己规定
            //使用直接插入排序
            insertSort2(arr,left,right);
            return;
        }
        //找基准之前找到中间大小的数  几数取中（使用三数取中法）
        int midValue = findMidValue(arr, left, right);
        swap(arr,midValue,left);//找到中间大小的数之后和最左边的数进行交换
        int pivot = partition(arr, left, right);
        quick(arr, left, pivot - 1);
        quick(arr, pivot + 1, right);
    }
    //找基准之前找到中间大小的数  三数取中
    public static int findMidValue(int[] arr, int start, int end) {
        int mid = start + (end - start)/2;
//        int mid = start + ((end - start)>>>1);
        if (arr[start] < arr[end]){  //最前面的值小于最后面的值
            if (arr[mid] < arr[start]){ //中间的值又小于最前面的值
                return start;  //则三数中中间大的值为start位置的值
            }else if (arr[mid] > arr[end]){
                return end;
            }else {
                return mid;
            }
        }else {//最前面的值大于最后面的值
            if (arr[mid] > arr[start]){
                return start;
            }else if (arr[mid] < arr[end]){
                return end;
            }else {
                return mid;
            }
        }
    }

    public static int partition(int[] arr, int start, int end) {
        int tmp = arr[start];
        while (start < end) {

            while (start < end && arr[end] >= tmp) {
                end--;
            }
            //end就遇到了小于tmp的值
            arr[start] = arr[end];
            while (start < end && arr[start] <= tmp) {
                start++;
            }
            //start就遇到了大于tmp的值
            arr[end] = arr[start];
        }
        //将tmp的值放到相遇start和end的位置
        arr[start] = tmp;
        return start;
    }

快速排序优化方法：

  1. 选择基准值很重要，通常使用几数取中法；
  2. partition 过程中把和基准值相等的数也选择出来；
    就是把数组中和基准值相等的数都移动到基准值的周围，这样与基准值相等的值都汇集到了一起，然后只需遍历与基准值不相等的前面和后面即可。
  3. 待排序区间小于一个阈值时（例如 40），使用直接插入排序；

6.5非递归实现快速排序

1.找基准
2.栈 划分之后把左右的数都放到队列中，划分前提：pivot左边有两个元素 pivot > left +1，右边有两个元素
3.判断栈是否为空，如果栈不为空，则依次弹出栈中的两个元素，分别作为数组的右边元素和左边元素，然后再找基准，直到栈为空为止。

public static void quickSort(int[] arr) {
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = arr.length - 1;
        int pivot = partition(arr, left, right);
        //划分之后把左右的数对都放到栈当中
        //前提：pivot左边有两个元素  右边有两个元素
        if (pivot > left + 1) {
            stack.push(left);
            stack.push(pivot - 1);
        }
        if (pivot < right - 1) {
            stack.push(pivot + 1);
            stack.push(right);
        }
        while (!stack.isEmpty()) {
            right = stack.pop();
            left = stack.pop();
            pivot = partition(arr, left, right);
            if (pivot > left + 1) {
                stack.push(left);
                stack.push(pivot - 1);
            }
            if (pivot < right - 1) {
                stack.push(pivot + 1);
                stack.push(right);
            }
        }
    }

七、归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

首先，先写一下两个有序数组合并为一个有序数组的代码：

 public static int[] mergeArray(int[] arr1, int[] arr2) {
        //判断数组是否为空
        int[] tmp = new int[arr1.length + arr2.length];
        int k = 0;//代表tmp数组的下标
        int s1 = 0;
        int e1 = arr1.length - 1;
        int s2 = 0;
        int e2 = arr2.length - 1;
        while (s1 <= e1 && s2 <= e2) {
            if (arr1[s1] <= arr2[s2]) {
                tmp[k] = arr1[s1];
                k++;
                s1++;
            } else {
                tmp[k++] = arr2[s2++];
            }
        }
        while (s1 <= e1) {
            tmp[k++] = arr1[s1++];
        }
        while (s2 <= e2) {
            tmp[k++] = arr2[s2++];
        }
        return tmp;
    }

    public static void main(String[] args) {
        int[] array1 = {1,3,5,7,9};
        int[] array2 = {2,4,6,8,10};
       int[] ret = mergeArray(array1,array2);
        System.out.println(Arrays.toString(ret));
    }

输出结果：
在这里插入图片描述

7.1归并排序代码示例

 public static void mergeSort(int[] arr) {
        mergeSortInternal(arr, 0, arr.length - 1);
    }

    private static void mergeSortInternal(int[] arr, int low, int high) {
        if (low >= high) {
            return;
        }
        int mid = low + ((high - low) >>> 1);//无符号右移一位
        //左边
        mergeSortInternal(arr, low, mid);
        //右边
        mergeSortInternal(arr, mid + 1, high);
        //合并
        merge(arr, low, mid, high);
    }

    private static void merge(int[] arr, int low, int mid, int high) {
        int s1 = low;
        int e1 = mid;
        int s2 = mid + 1;
        int e2 = high;
        int[] tmp = new int[high - low + 1];
        int k = 0;

        while (s1 <= e1 && s2 <= e2) {
            if (arr[s1] <= arr[s2]) {
                tmp[k++] = arr[s1++];
//                k++;
//                s1++;
            } else {
                tmp[k++] = arr[s2++];
            }
        }
        while (s1 <= e1) {
            tmp[k++] = arr[s1++];
        }
        while (s2 <= e2) {
            tmp[k++] = arr[s2++];
        }
        //拷贝tmp数组的元素放到arr里面
        for (int i = 0; i < k; i++) {
            arr[i + low] = tmp[i];
        }
    }

    public static void main(String[] args) {
        int[] arr = {3,5,1,2,34,0,98,-1,56};
        mergeSort(arr);
        System.out.println(Arrays.toString(arr));
    }

输出结果：
在这里插入图片描述
时间复杂度：O(n*logn)；
空间复杂度：O(n)；
稳定性：稳定的排序。

7.2非递归方法实现归并排序

 public static void mergeSort1(int[] arr) {
        int nums = 1;//每组数据的个数
        while (nums < arr.length){
            //数组每次都要进行遍历,确定要归并的区间
            for (int i = 0; i < arr.length; i+=nums * 2) {
                int left = i;
                int mid = left + nums - 1;
                if (mid >= arr.length){//防止越界
                    mid = arr.length - 1;
                }
                int right = mid + nums;
                if (right >= arr.length){//防止越界
                    right  = arr.length - 1;
                }
                //下标确定之后，合并
                merge(arr,left,mid,right);
            }
            nums *= 2;
        }
    }
public static void main(String[] args) {
        int[] arr = {3,5,1,2,34,0,98,-1,56};
        mergeSort1(arr);
        System.out.println(Arrays.toString(arr));
    }

输出结果：
在这里插入图片描述

八、海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序。
前提：内存只有 1G，需要排序的数据有 100G；
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序。

  1. 先把文件切分成 200 份，每个 512 M；
  2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以；
  3. 进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序了。

关于各种排序算法的时间复杂度、空间复杂度及稳定性列表

排序算法最好时间复杂度最坏时间复杂度最好空间复杂度最坏空间复杂度稳定性
直接插入排序O(N)O(N^2)O(1)O(1)稳定
希尔排序O(N^1.3)O(N^1.5)O(1)O(1)不稳定
选择排序O(N^2)O(N^2)O(1)O(1)不稳定
堆排序O(NlogN)O(NlogN)O(1)O(1)不稳定
冒泡排序O(N^2)O(N^2)O(1)O(1)稳定
快速排序O(NlogN)O(N^2)O(logN)O(N)不稳定
归并排序O(NlogN)O(NlogN)O(N)O(N)稳定

其他非基于比较的排序

基数排序

桶排序
在这里插入图片描述
计数排序

 public static void countSort(int[] arr){
        int maxValue = arr[0];
        int minValue = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < minValue){
                minValue = arr[i];
            }
            if (arr[i] > maxValue){
               maxValue = arr[i];
            }
        }
        int[] count = new int[maxValue-minValue + 1];
        for (int i = 0; i < arr.length ; i++) {
            int index = arr[i];
            //为了空间的合理使用，需要减去minValue
            count[index - minValue]++;
        }
        //说明在计数数组当中已经把arr数组中每个数据出现的次数已经统计好了
        //接下来遍历计数数组把数据写回arr即可
        int indexArray = 0;
        for (int i = 0; i < count.length; i++) {
            while (count[i] > 0){
                arr[indexArray] = i + minValue;
                count[i]--;//拷贝一个之后，此时也就是少一个
                indexArray++;//
            }
        }
    }

计数排序 一般适用于有n个数；
时间复杂度：O(N)；
空间复杂度：O(M) M代表当前数据的范围；
稳定性：不稳定， 当前代码是不稳定的，但是本质是稳定的；

以上。
来学习的小张
关注
  • 16
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
希尔排序java_Java常见排序算法详解——希尔排序
weixin_36303305的博客
02-12 316
概念：希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了(此时插入排序较快)。希尔排序是基于插入排序的以下两点性质而提出改进方法的：插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率但插入排序一般来...
java常见排序算法_Java常见排序算法详解——希尔排序
weixin_39726379的博客
02-25 60
原标题：Java常见排序算法详解——希尔排序概念：希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了(此时插入排序较快)。希尔排序是基于插入排序的以下两点性质而提出改进方法的：插入排序在对几乎已经排好序的数据操作时， 效率高...
java八大排序算法详解
qq_57420582的博客
06-29 731
java八大排序算法详解
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
热门推荐
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
java 快速排序算法详解_Java常见排序算法之快速排序
weixin_31463675的博客
02-13 324
从今天开始，我们将要进行基本的排序算法的讲解。Are you ready？Let‘s go~~~1、排序算法的基本概念的讲解时间复杂度:需要排序的的关键字的比较次数和相应的移动的次数。空间复杂度:分析需要多少辅助的内存。稳定性:如果记录两个关键字的A和B它们的值相等，经过排序后它们的位置没有发生交换，那么我们称这个排序算法是稳定的。否则我们称这个排序算法是不稳定的。排序算法的常见分类:1、内部排序...
详解Java常用排序算法（10种，含演示动画）
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-30 2万+
Java常用的排序算法有以下几种： 1. 冒泡排序；2. 选择排序；3. 插入排序；4. 希尔排序；5. 归并排序；6. 快速排序；7. 堆排序；8. 计数排序；9. 桶排序；10. 基数排序。 这些排序算法都有各自的优缺点，应根据具体情况选择适合的算法。
直接插入排序java_Java常见排序算法详解——直接插入排序
weixin_31147827的博客
02-21 117
原标题：Java常见排序算法详解——直接插入排序直接插入排序Straight Insertion Sort概念：将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录递增1的有序表。插入排序是进行值移动，而是不值交换。所以在量较小的情况下插入排序性能要优于冒泡和简单选择排序。原理：设有一组关键字{K1， K2，…， Kn｝;排序开始就认为 K1 是一个有序序列;让 K2 插入上述表长为 1 ...
Java十种经典排序算法详解与应用
最新发布
weixin_69595694的博客
01-06 1311
Java中提供了多种排序算法实现，涵盖了简单排序和高级排序技术。这些算法包括但不限于冒泡排序（Bubble Sort）、选择排序（Selection Sort）、插入排序（Insertion Sort）、希尔排序（Shell Sort）、归并排序（Merge Sort）、快速排序（Quick Sort）、堆排序（Heap Sort）、计数排序（Counting Sort）、桶排序（Bucket Sort）以及基数排序（Radix Sort）。每种排序算法在时间复杂度、空间复杂度、稳定性等方面各有优劣。
java 二分排序_Java常见排序算法详解—— 二分插入排序
weixin_29069575的博客
02-12 688
转载请注明出处：二分插入排序Binary Insert Sort概念：二分(折半)插入排序是一种在直接插入排序算法上进行小改动的排序算法。其与直接排序算法最大的区别在于查找插入位置时使用的是二分查找的方式，在速度上有一定提升。原理：总共有N个元素，当插入第i个元素时，对前面的0~i-1个元素进行折半，先跟他们中间的那个元素比，如果小，那么再对前半折半，否则对后半进行折半，知道左关说原理可能大家不是...
Java中常见排序算法详解
iteen的博客
11-05 4288
插入排序 基本思想：从数组的第二个元素开始，若比前一个元素小，就向前移动（若大于就不用移动），直到插入到合适的位置，然后再去排第三个元素，依次类推，最后一个插入到合适位置时，数组的排序就完成了。 流程如图所示： 代码如下： /** * 直接插入排序 * @date 2018-10-18 * @param arr */ public static void sort1(i...
java实现数据结构常见排序算法及详解
11-08
详细讲述了8中常见算法的原理及思想，并用JAVA进行了实现，代码中有详细的注释，解释了算法的实现逻辑和一些小技巧。
Java排序算法详解.rar
03-23
本篇将深入探讨几种常见的Java排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序以及TimSort等。 1. **冒泡排序**： 冒泡排序是最基础的排序算法，通过不断交换相邻的逆序元素来逐步排序。...
常用Java排序算法详解
08-31
本文将深入探讨Java中七种常见的排序算法，包括选择排序、插入排序、冒泡排序、归并排序、快速排序、希尔排序和最小堆排序。这些算法各有特点，适用于不同的场景。 一、选择排序(SelectSort) 选择排序的基本思想是...
Java常见经典算法详解-选择排序(Selection Sort)
12-21
选择排序是一种简单直观的排序算法，它的工作原理可以分为以下几个步骤： 1. **初始化**：在开始时，数组被看作未排序的序列。 2. **寻找最小元素**：从数组的第一个元素开始，遍历整个数组，找出当前未排序序列中...
Java经典排序算法之归并排序详解
08-30
**Java归并排序详解** 归并排序是一种基于分治策略的高效排序算法，它通过将序列不断分成更小的子序列，然后将这些子序列合并成一个有序序列，最终达到整个序列排序的目的。以下是归并排序的详细解析。 ### 一、...
标识符的命名规则及命名规范
dddddrrrzz的博客
01-30 9225
标识符可以标识：类名、接口名、变量名、常量名。 标识符的命名规则： 1：标识符只能由数字、字母（包括中文）、下划线_、美元符号$组成，不能含有其他符号。 2：标识符不能以数字开头。标识符中不能有空格。 3：关键字不能做标识符。 例如： public/class/static/void 4：标识符是严格区分大小写的。 5：标识符理论上是没有长度限制的。 标识符的命名规范： 1：见名知意 2：遵循驼峰命名方式。（就是一高一低，一高一低…） 驼峰有
Java中关于二叉树详解
dddddrrrzz的博客
01-10 3099
目录一、树形结构1.1 相关概念1.2树的表示形式1.3树的应用：文件系统管理（目录和文件）二、二叉树2.1相关概念2.2 二叉树的基本形态2.3 两种特殊的二叉树2.4 二叉树的性质2.5 二叉树的存储2.6 二叉树的基本操作2.6.1二叉树的遍历2.6.2 二叉树的基本操作总结 一、树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，
Java中顺序表及链表详解
dddddrrrzz的博客
11-03 1897
目录一、线性表二、顺序表应用示例：实现一个动态顺序表1.打印顺序表2.获取顺序表长度3.在 pos 位置新增元素4.判定是否包含某个元素5.查找某个元素对应的位置6.获取pos位置的元素7.给 pos 位置的元素设为/更新 value8.删除第一次出现的关键字key9.清空顺序表总结 一、线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但
Java关于二叉树的16个经典例题
dddddrrrzz的博客
01-22 1741
目录一、二叉树的前序遍历二、二叉树的中序遍历三、二叉树的后序遍历四、判断两棵树是否相同五、判断一棵树是否是另一棵树的子树六、判断一棵树是否为平衡二叉树（AVL树）七、判断一棵树是否为对称二叉树 一、二叉树的前序遍历 144.二叉树的前序遍历 方法一： class Solution { List <Integer> tmp = new ArrayList<>(); public List<Integer> preorderTraversal(Tree
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值