java的简单排序算法

最新推荐文章于 2022-07-22 15:49:53 发布

慕容屠苏

最新推荐文章于 2022-07-22 15:49:53 发布

阅读量288

点赞数

分类专栏：算法文章标签： java 简单排序算法

本文链接：https://blog.csdn.net/kerryqpw/article/details/78240099

版权

算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

java的简单排序算法

排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。

　　内排序有可以分为以下几类：

　　(1)、插入排序：直接插入排序、二分法插入排序、希尔排序。

　　(2)、选择排序：简单选择排序、堆排序。

　　(3)、交换排序：冒泡排序、快速排序。

　　(4)、归并排序

　　(5)、基数排序

冒泡排序：

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

　　冒泡排序的示例：

1、冒泡排序的算法实现如下:【排序后，数组从小到大排列】：

　/**
     * 冒泡排序
     * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。  
     * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。  
     * 针对所有的元素重复以上的步骤，除了最后一个。
     * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 
     * @param numbers 需要排序的整型数组
     */
    public static void bubbleSort(int[] numbers)
    {
        int temp = 0;
        int size = numbers.length;
        for(int i = 0 ; i < size-1; i ++)
        {
        for(int j = 0 ;j < size-1-i ; j++)
        {
            if(numbers[j] > numbers[j+1])  //交换两数位置
            {
            temp = numbers[j];
            numbers[j] = numbers[j+1];
            numbers[j+1] = temp;
            }
        }
        }
    }

2、简单选择排序

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

简单选择排序的示例：

实现代码：

    public class ChoiceSort {  
      
        public static void _choiceSort(Integer[] a) {  
            if (a == null || a.length <= 0) {  
                return;  
            }  
            for (int i = 0; i < a.length; i++) {  
                int min = i; /* 将当前下标定义为最小值下标 */  
      
                for (int j = i + 1; j < a.length; j++) {  
                    if (a[min] > a[j]) { /* 如果有小于当前最小值的关键字 */  
                        min = j; /* 将此关键字的下标赋值给min */  
                    }  
                }  
                if (i != min) {/* 若min不等于i，说明找到最小值，交换 */  
                    int tmp = a[min];  
                    a[min] = a[i];  
                    a[i] = tmp;  
                }  
            }  
        }  
    }

    public static void main(String[] args) {  
            // TODO Auto-generated method stub  
             Integer[] list={49,38,65,97,76,13,27,14,10};  
             //快速排序  
            /* QuicSort qs=new QuicSort();  
             qs.quick(list);*/  
             //冒泡排序  
            /* BubbleSort bs=new BubbleSort();  
             bs.bubble(list);*/  
             //选择排序  
             ChoiceSort._choiceSort(list);  
               
             for(int i=0;i<list.length;i++){  
                 System.out.print(list[i]+" ");  
             }  
             System.out.println();  
        }

3.直接插入排序
思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置，直到全部插入排序完为止。

•关键问题：在前面已经排好序的序列中找到合适的插入位置。

•方法：

–直接插入排序

–二分插入排序

–希尔排序

①直接插入排序（从后向前找到合适位置后插入）

　　1、基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。

　　2、实例

实现代码：

 package com.sort;
  
  public class 直接插入排序 {
  
      public static void main(String[] args) {
          int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1};
          System.out.println("排序之前：");
          for (int i = 0; i < a.length; i++) {
              System.out.print(a[i]+" ");
         }
         //直接插入排序
         for (int i = 1; i < a.length; i++) {
             //待插入元素
             int temp = a[i];
             int j;
             /*for (j = i-1; j>=0 && a[j]>temp; j--) {
                 //将大于temp的往后移动一位
                 a[j+1] = a[j];
             }*/
             for (j = i-1; j>=0; j--) {
                 //将大于temp的往后移动一位
                 if(a[j]>temp){
                     a[j+1] = a[j];
                 }else{
                     break;
                 }
             }
             a[j+1] = temp;
         }
         System.out.println();
         System.out.println("排序之后：");
         for (int i = 0; i < a.length; i++) {
             System.out.print(a[i]+" ");
         }
     }
 
 }

4.快速排序

思路：

1、选取一个元素作为基准元素，通常选择第一个元素或最后一个元素。

2、经过一轮排序后，将比基准元素小的放在元素放在左边，形成左序列，将比基准元素小的元素放在右边，形成右数列。

3、再用同样的方法递归地排序划分的两部分。对左序列和又序列做1、2步操作

　　2、实例

实现代码:

package com.sort;

//不稳定
public class 快速排序 {
    public static void main(String[] args) {
        int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1,8};
        System.out.println("排序之前：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        //快速排序
        quick(a);
        System.out.println();
        System.out.println("排序之后：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }

    private static void quick(int[] a) {
        if(a.length>0){
            quickSort(a,0,a.length-1);
        }
    }

    private static void quickSort(int[] a, int low, int high) {
        if(low<high){ //如果不加这个判断递归会无法退出导致堆栈溢出异常
            int middle = getMiddle(a,low,high);
            quickSort(a, 0, middle-1);
            quickSort(a, middle+1, high);
        }
    }

    private static int getMiddle(int[] a, int low, int high) {
        int temp = a[low];//基准元素
        while(low<high){
            //找到比基准元素小的元素位置
            while(low<high && a[high]>=temp){
                high--;
            }
            a[low] = a[high]; 
            while(low<high && a[low]<=temp){
                low++;
            }
            a[high] = a[low];
        }
        a[low] = temp;
        return low;
    }
}

5.归并排序:

1、基本思想:归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

　　2、实例

　　3、java代码实现

package com.sort;
 2 
 3 //稳定
 4 public class 归并排序 {
 5     public static void main(String[] args) {
 6         int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1,8};
 7         System.out.println("排序之前：");
 8         for (int i = 0; i < a.length; i++) {
 9             System.out.print(a[i]+" ");
10         }
11         //归并排序
12         mergeSort(a,0,a.length-1);
13         System.out.println();
14         System.out.println("排序之后：");
15         for (int i = 0; i < a.length; i++) {
16             System.out.print(a[i]+" ");
17         }
18     }
19 
20     private static void mergeSort(int[] a, int left, int right) {
21         if(left<right){
22             int middle = (left+right)/2;
23             //对左边进行递归
24             mergeSort(a, left, middle);
25             //对右边进行递归
26             mergeSort(a, middle+1, right);
27             //合并
28             merge(a,left,middle,right);
29         }
30     }
31 
32     private static void merge(int[] a, int left, int middle, int right) {
33         int[] tmpArr = new int[a.length];
34         int mid = middle+1; //右边的起始位置
35         int tmp = left;
36         int third = left;
37         while(left<=middle && mid<=right){
38             //从两个数组中选取较小的数放入中间数组
39             if(a[left]<=a[mid]){
40                 tmpArr[third++] = a[left++];
41             }else{
42                 tmpArr[third++] = a[mid++];
43             }
44         }
45         //将剩余的部分放入中间数组
46         while(left<=middle){
47             tmpArr[third++] = a[left++];
48         }
49         while(mid<=right){
50             tmpArr[third++] = a[mid++];
51         }
52         //将中间数组复制回原数组
53         while(tmp<=right){
54             a[tmp] = tmpArr[tmp++];
55         }
56     }
57 }