JAVA实现经典排序算法(冒泡排序选择排序插入排序希尔排序堆排序归并排序快速排序)

Posted Java学习指南

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JAVA实现经典排序算法(冒泡排序选择排序插入排序希尔排序堆排序归并排序快速排序)相关的知识,希望对你有一定的参考价值。


点击蓝色“Java学习指南 关注我 ,

加个“星标,每天阅读Java干货文章




冒泡排序

依次比较相邻的元素,若发现逆顺序,则交换。小的向前换,大的向后换,本次循环完毕之后再次从头开始扫描,直到某次扫描中没有元素交换,说明每个元素都不比它后面的元素大,至此排序完成。

    import java.util.Arrays;
    public class BubbleSort {
     public static void main(String[] args) {
      int[] arr=new int[] {5,7,2,9,4,1,0,5,7};
      System.out.println(Arrays.toString(arr));
      bubbleSort(arr);
      System.out.println(Arrays.toString(arr));
     }
     public static void bubbleSort(int[]  arr) {
      for(int i=0;i<arr.length-1;i++) {
       for(int j=0;j<arr.length-1-i;j++) {
        if(arr[j]>arr[j+1]) {
         int temp=arr[j];
         arr[j]=arr[j+1];
         arr[j+1]=temp;
        }
       }
      }
     }
    }

结果展示
JAVA实现经典排序算法(冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序)


选择排序

每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。

    import java.util.Arrays;
    public class SelectSort {
     public static void main(String[] args) {
      int[] arr = new int[] {3,4,5,7,1,2,0,3,6,8};
      selectSort(arr);
      System.out.println(Arrays.toString(arr));
     }
     public static void selectSort(int[] arr) {
      for(int i=0;i<arr.length;i++) {
       int minIndex=i;
       for(int j=i+1;j<arr.length;j++) {
        if(arr[minIndex]>arr[j]) {
         minIndex=j;
        }
       }
       if(i!=minIndex) {
        int temp=arr[i];
        arr[i]=arr[minIndex];
        arr[minIndex]=temp;
       }
      }
     }
    }

结果展示
JAVA实现经典排序算法(冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序)


插入排序

  • 从第一个元素开始,该元素可以认为已经被排序
  • 取出下一个元素,在已经排序的元素序列中从后向前扫描
  • 如果该元素(已排序)大于新元素,将该元素移到下一位置
  • 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
  • 将新元素插入到该位置后
  • 重复上面步骤
    import java.util.Arrays;
    public class InsertSort {
     public static void main(String[] args) {
      int[] arr = new int[] {5,3,2,8,5,9,1,0};
      insertSort(arr);
      System.out.println(Arrays.toString(arr));
     }
     public static void insertSort(int[] arr) {
      for(int i=1;i<arr.length;i++) {
       if(arr[i]<arr[i-1]) {
        int temp=arr[i];
        int j;
        for(j=i-1;j>=0&&temp<arr[j];j--) 
         arr[j+1]=arr[j];
          arr[j+1]=temp; 
         }
       }
      }
     }

结果展示
JAVA实现经典排序算法(冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序)


希尔排序

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”。希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

    import java.util.Arrays;
    public class ShellSort {
     public static void main(String[] args) {
      int[] arr = new int[] { 3527812047438 };
      System.out.println(Arrays.toString(arr));
      shellSort(arr);
      System.out.println(Arrays.toString(arr));
     }
     public static void shellSort(int[] arr) {
      int k = 1;
      for (int d = arr.length / 2; d > 0; d /= 2) {
       for (int i = d; i < arr.length; i++) {
        for (int j = i - d; j >= 0; j -= d) {
         if (arr[j] > arr[j + d]) {
          int temp = arr[j];
          arr[j] = arr[j + d];
          arr[j + d] = temp;
         }
        }
       }
       System.out.println( Arrays.toString(arr));
       k++;
      }
     }
    }

结果展示
JAVA实现经典排序算法(冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序)

堆排序

在堆的数据结构中,堆中的最大值总是位于根节点(在优先队列中使用堆的话堆中的最小值位于根节点)。

堆中定义以下几种操作:

  • 最大堆调整:将堆的末端子节点作调整,使得子节点永远小于父节点创建最大堆,将堆所有数据重新排序。
  • 堆排序:移除位在第一个数据的根节点,并做最大堆调整的递归运算。
    import java.util.Arrays;
    public class HeapSort {
     public static void main(String[] args) {
      int[] arr = new int[] {9,6,8,7,0,1,10,4,2};
      heapSort(arr);
      System.out.println(Arrays.toString(arr));
     }
     public static void heapSort(int[] arr) {
      int start = (arr.length-1)/2;
      for(int i=start;i>=0;i--) {
       maxHeap(arr, arr.length, i);
      }
      for(int i=arr.length-1;i>0;i--) {
       int temp = arr[0];
       arr[0]=arr[i];
       arr[i]=temp;
       maxHeap(arr, i, 0);
      }
     }
     public static void maxHeap(int[] arr,int size,int index) {
      int leftNode = 2*index+1;
      int rightNode = 2*index+2;
      int max = index;
      if(leftNode<size&&arr[leftNode]>arr[max]) {
       max=leftNode;
      }
      if(rightNode<size&&arr[rightNode]>arr[max]) {
       max=rightNode;
      }
      if(max!=index) {
       int temp=arr[index];
       arr[index]=arr[max];
       arr[max]=temp;
       maxHeap(arr, size, max);
      }
     }
    }

结果展示
JAVA实现经典排序算法(冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序)


归并排序

归并操作的工作原理如下:

  • 第一步:申请空间,使其大小为两个已经 排序序列之和,该空间用来存放合并后的序列
  • 第二步:设定两个 指针,最初位置分别为两个已经排序序列的起始位置
  • 第三步:比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置重复步骤3直到某一指针超出序列尾,将另一序列剩下的所有元素直接复制到合并序列尾
    import java.util.Arrays;
    public class MergeSort {
     public static void main(String[] args) {
      int[] arr = new int[] {1,3,5,2,4,6,8,10};
      System.out.println(Arrays.toString(arr));
      mergeSort(arr, 0, arr.length-1);
      System.out.println(Arrays.toString(arr));
     }
     public static void mergeSort(int[] arr,int low,int high) {
      int middle=(high+low)/2;
      if(low<high) {
       mergeSort(arr, low, middle);
       mergeSort(arr, middle+1, high);
       merge(arr,low,middle,high);
      }
     }
     public static void merge(int[] arr,int low,int middle, int high) {
      int[] temp = new int[high-low+1];
      int i=low;
      int j=middle+1;
      int index=0;
      while(i<=middle&&j<=high) {
       if(arr[i]<=arr[j]) {
        temp[index]=arr[i];
        i++;
       }else {
        temp[index]=arr[j];
        j++;
       }
       index++;
      }
      while(j<=high) {
       temp[index]=arr[j];
       j++;
       index++;
      }
      while(i<=middle) {
       temp[index]=arr[i];
       i++;
       index++;
      }
      for(int k=0;k<temp.length;k++) {
       arr[k+low]=temp[k];
      }
     }
    }

结果展示
JAVA实现经典排序算法(冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序)

快速排序

快速排序算法利用的是一趟快速排序,基本内容是选择一个数作为准基数,然后利用这个准基数将遗传数据分为两个部分,第一部分比这个准基数小,都放在准基数的左边,第二部分都比这个准基数大,放在准基数的右边。

    import java.util.Arrays;
    public class QuickSort {
     public static void main(String[] args) {
      int[] arr = new int[] {3,4,6,7,2,7,2,8,0,9,1};
      quickSort(arr,0,arr.length-1);
      System.out.println(Arrays.toString(arr));
     }
     public static void quickSort(int[] arr,int start,int end) {
      if(start<end) {
       int stard=arr[start];
       int low=start;
       int high=end;
       while(low<high) {
        while(low<high&&stard<=arr[high]) {
         high--;
        }
        arr[low]=arr[high];
        while(low<high&&arr[low]<=stard) {
         low++;
        }
        arr[high]=arr[low];
       }
       arr[low]=stard;
       quickSort(arr, start, low);
       quickSort(arr, low+1, end);
      }
     }
    }

结果展示
JAVA实现经典排序算法(冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序)



JAVA实现经典排序算法(冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序)

如有文章对你有帮助,

在看”和转发是对我最大的支持

JAVA实现经典排序算法(冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序)


关注Java学习指南

每天学习Java技术






你点的每个“在看”,我都认真当成了喜欢

以上是关于JAVA实现经典排序算法(冒泡排序选择排序插入排序希尔排序堆排序归并排序快速排序)的主要内容,如果未能解决你的问题,请参考以下文章

排序 | 秒懂排序算法(Java)

排序算法之冒泡选择插入排序(Java)

排序算法之冒泡选择插入排序(Java)

九种经典排序算法详解(冒泡排序,插入排序,选择排序,快速排序,归并排序,堆排序,计数排序,桶排序,基数排序)

算法 排序lowB三人组 冒泡排序 选择排序 插入排序

排序算法基础总结