JAVA 排序算法

冒泡排序 Bubble Sort

      排序方式：每次两两比较，大的在后面，每一趟排序都会确定一个元素的最终位置。

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;

/*
完成冒泡排序的优化算法
 */
public class BubbleSort {
    public static void main(String[] args) {
        //向数组中加入10个随机数(inflate返回的是一个数组)
        int[] bubble = inflate(10);
        System.out.println("排序前数组");
        //可以用Arrays.toString(),来输出数组，不需要重写toString()方法
        System.out.print(Arrays.toString(bubble));
        System.out.println();
        System.out.println("排序后数组");
        //对bubblesort数组进行冒泡排序
        bubbleSort(bubble);
    }

    public static int[] inflate(int size){//产生随机数
        Random random = new Random();//Random()类返回一个随机数
        int[] ints = new int[size];
        for (int j = 0; j < size ; j++) {
            ints[j] = random.nextInt(1000);//产生一个1000以内的随机数
        }
        return ints;
    }

    public static void bubbleSort(int[] target){
        //从小到大排列
        int len = target.length - 1;//len用来代表数组的下标，0 ~ length - 1
        boolean flag = true;   //标志位，
        for (int i = 0; i <len ; i++) {//外层循环用来计数
            flag = false;//flag 表示是否进行交换
            for (int j = 1; j < len; j++) {//内层循环用来完成数组交换
                if(target[j - 1] > target[j]){
                    swap(target,j ,j-1);
                    flag = true;
                }
            }
        }
        for (int i = 0; i <len ; i++) {
            System.out.print(target[i] +"\t");
        }
    }

    private static void swap(int[] target, int little, int large) {
        int temp ;
        temp = target[little];
        target[little] = target[large];
        target[large] = temp;
    }

}

插入排序

      排序思路：在一个数组中分为三部分：1.有序序列  2.待插入元素  3.无序序列 

      每次将待插入元素插入有序序列，然后再令无序序列第一个元素成为待插入元素。

     for (int i = 1;i < traget.length ; i++ ){   //i指向当前待插入元素，
      int ai = target[i];
      int j;
      for (j = i - 1;j >= 0 && ai < target[j] ; j-- ){
          target[j + 1] = target[j];      //target[i+1—j]为无序序列,target[0— i-1]为有序序列
      }
    }

选择排序

排序思路：每次从无序序列中选最小值（擂台法），和第一个交换放入有序序列。

    public static void selectSort(int[] target) {
        int len = target.length - 1;
        for (int i = 0; i < len; i++) {
            int minIndex = getMin(target, i, target.length - 1);
            swap(target, i, minIndex);
        }
    }

    private static int getMin(int[] target, int startPos, int endPos) {
        int minIndex = startPos;
        int min = target[startPos];
        for (int j = startPos + 1; j <= endPos; j++) {
            if (target[j] < min) {
                minIndex = j;
                min = target[j];
            }
        }

        return minIndex;
    }


   测试：  
        public static int[] inflate(int size) {
        int[] elements = new int[size];
        Random random = new Random();
        for(int i = 0; i < size; i++) {
            elements[i] = random.nextInt(1000);
        }
        return elements;
    }

    public static int[] inflate(int size){
    int[] elements = new int[size];
    Random random = new Random();
    for( int i = 0; i<size ;i++){
       elements[i] = random.nextIne(1000)

    }

}

归并排序（难点在  递归 ）

    两种归并 ：1.两个数组归并成一个数组  2.一个数组，分解成单个元素，则单个元素可以看出有序的，然后两两归并
    第一种好理解，用两个指针，分别指向两个数组的第一个结点，然后不断比较放入新数组
    第二种归并：

       代码思路：先将无序数组不断分裂（递归），直到成为一个个的单个元素，然后再进行两两归并，
                       把每次的元素按位置给到一个新数组，然后将每次的结果返回给原数组，表示此次归并完成
          

public class merge {
  public static void mergeSort(int[] target) {
    int[] tmp = new int[target.length]; //临时数组
    mergeSort(target,0,target.length - 1,tmp)

  private static void mergeSort(int[] target, int start, int end, int[] tmp) {
    
    if(start < end){
        mid = (start + end) / 2;
    }
    //开始分解左边[0-mid]
    mergeSort(target,0,mid,tmp)


    //开始分解右边[mid+1,target.length-1]
    mergeSort(target,mid+1,target.length -1,tmp)

    //分解完了，开始归并
    merge(target , start , mid , end , tmp)
    }
}      

public static void merge(int[] target , int start , int mid , int end , int[] tmp){
    //待归并的左边
    int lstart = start;
    int lend = mid;

    //待归并的右边
    int rstart = mid + 1;
    int rend = end;

     int k = start;
    //如果 每边的 start <= end，说明元素还没有比较完
    while(lstart <= lend && rstart <= rend){
        //如果一表的第一个值 < 二表的第一个值，则将一表的第一个值给到新表tmp。指针均后移
        if(target[lstart] < target[rstart){
            tmp[k++] = target[lstart++];
        }else{
        //否则将二表的第一个值给到新表
        tmp[k++] = target[rstart];
        }
    }
    //某一个表比较完了，另一个表的其他元素就是最大的一些元素了，直接放入新表
    while(lstart <= lend){//表示左表还没比完
      tmp[k++] = target[lstart];
    }
    while(rstart <= rend){
      tmp[k++] = target[rstart];
    }

    //需要把tmp 里面的值重新给到 target，不能target = tmp，这样给到的是地址的引用
    //必须要遍历赋值
    for (int i = 0; i < target.length ; i++ ){
         target[i] = tmp[i];
    }
 }
}

归并详解

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

这其实就是归并排序的最主要想法和实现，归并排序的做法是:

将一个数组一直对半分，问题的规模就减小了，再重复进行这个过程，直到元素的个数为一个时，一个元素就相当于是排好顺序的。

首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

[cpp]  view plain  copy

1. //将有序数组a[]和b[]合并到c[]中  
2. void MemeryArray(int a[], int n, int b[], int m, int c[])  
3. {  
4.     int i, j, k;  
5.   
6.     i = j = k = 0;  
7.     while (i < n && j < m)  
8.     {  
9.         if (a[i] < b[j])  
10.             c[k++] = a[i++];  
11.         else  
12.             c[k++] = b[j++];   
13.     }  
14.   
15.     while (i < n)  
16.         c[k++] = a[i++];  
17.   
18.     while (j < m)  
19.         c[k++] = b[j++];  
20. }  

可以看出合并有序数列的效率是比较高的，可以达到O(n)。

解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

[cpp]  view plain  copy

1. //将有二个有序数列a[first...mid]和a[mid...last]合并。  
2. void mergearray(int a[], int first, int mid, int last, int temp[])  
3. {  
4.     int i = first, j = mid + 1;  
5.     int m = mid,   n = last;  
6.     int k = 0;  
7.       
8.     while (i <= m && j <= n)  
9.     {  
10.         if (a[i] <= a[j])  
11.             temp[k++] = a[i++];  
12.         else  
13.             temp[k++] = a[j++];  
14.     }  
15.       
16.     while (i <= m)  
17.         temp[k++] = a[i++];  
18.       
19.     while (j <= n)  
20.         temp[k++] = a[j++];  
21.       
22.     for (i = 0; i < k; i++)  
23.         a[first + i] = temp[i];  
24. }  
25. void mergesort(int a[], int first, int last, int temp[])  
26. {  
27.     if (first < last)  
28.     {  
29.         int mid = (first + last) / 2;  
30.         mergesort(a, first, mid, temp);    //左边有序  
31.         mergesort(a, mid + 1, last, temp); //右边有序  
32.         mergearray(a, first, mid, last, temp); //再将二个有序数列合并  
33.     }  
34. }  
35.   
36. bool MergeSort(int a[], int n)  
37. {  
38.     int *p = new int[n];  
39.     if (p == NULL)  
40.         return false;  
41.     mergesort(a, 0, n - 1, p);  
42.     delete[] p;  
43.     return true;  
44. }  

 

归并排序的效率是比较高的，设数列长为N，将数列分开成小数列一共要logN步，每步都是一个合并有序数列的过程，时间复杂度可以记为O(N)，故一共为O(N*logN)。因为归并排序每次都是在相邻的数据中进行操作，所以归并排序在O(N*logN)的几种排序方法（快速排序，归并排序，希尔排序，堆排序）也是效率比较高的。

 

在本人电脑上对冒泡排序，直接插入排序，归并排序及直接使用系统的qsort()进行比较（均在Release版本下）

对20000个随机数据进行测试：

对50000个随机数据进行测试：

再对200000个随机数据进行测试：

 

注：有的书上是在mergearray()合并有序数列时分配临时数组，但是过多的new操作会非常费时。因此作了下小小的变化。只在MergeSort()中new一个临时数组。后面的操作都共用这一个临时数组

排序详细过程的代码实现：

基本思想

n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

1. 初始状态：无序区为R[1..n]，有序区为空。
2. 第1趟排序: 在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1] 交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
3. ……
4. 第i趟排序: 第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。 该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[i]交换，使R[1..i] 和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

算法实现

归并排序算法，Java实现，代码如下所示：

public abstract class Sorter {
    public abstract void sort(int[] array);
}

public class MergeSorter extends Sorter {

    @Override
    public void sort(int[] array) {
        int[] auxArray = new int[array.length];
        mergeSort(array, auxArray, 0, array.length - 1);
    }

    /**
     * 基于分治思想，执行归并排序
     * @param low 待排序数组下标下界
     * @param high 待排序数组下标上界
     */
    private void mergeSort(int[] array, int[] auxArray, int low, int high) {
        int dividedIndex = 0; // 分治位置索引变量
        if (low < high) {
            dividedIndex = (low + high) / 2; // 计算分治位置(采用简单的二分思想)
            mergeSort(array, auxArray, low, dividedIndex); // 左侧递归归并排序
            mergeSort(array, auxArray, dividedIndex + 1, high); // 右侧递归归并排序
            merge(array, auxArray, low, dividedIndex, high); // 合并分治结果
        }
    }

    private void merge(int[] array, int[] auxArray, int low, int dividedIndex, int high) {
        int i = low; // 指向左半分区数组的指针
        int j = dividedIndex + 1; // 指向右半分区数组的指针
        int auxPtr = 0; // 指向辅助区数组的指针
        // 合并两个有序数组：array[low..dividedIndex]与array[dividedIndex+1..high]。
        while (i <= dividedIndex && j <= high) { // 将两个有序的数组合并，排序到辅助数组auxArray中
     // 左侧数组array[low..dividedIndex]中的array[i]大于右侧数组array[dividedIndex+1..high]中的array[j]
            if (array[i] > array[j]) {
                auxArray[auxPtr++] = array[j++];
            } else {
                auxArray[auxPtr++] = array[i++];
            }
        }
        // 如果array[low..dividedIndex].length>array[dividedIndex+1..high].length，经过上面合并
        // array[low..dividedIndex]没有合并完，
        //则直接将array[low..dividedIndex]中没有合并的元素复制到辅助数组auxArray中去
        while (i <= dividedIndex) {
            auxArray[auxPtr++] = array[i++];
        }
        // 如果array[low..dividedIndex].length<array[dividedIndex+1..high].length，经过上面合并
        // array[dividedIndex+1..high]没有合并完，
        //则直接将array[dividedIndex+1..high]中没有合并的元素复制到辅助数组auxArray中去
        while (j <= high) {
            auxArray[auxPtr++] = array[j++];
        }
        // 最后把辅助数组auxArray的元素复制到原来的数组中去，归并排序结束
        for (auxPtr = 0, i = low; i <= high; i++, auxPtr++) {
            array[i] = auxArray[auxPtr];
        }
    }
}

假设待排序数组为array = {94,12,34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49}，数组大小为20，我们以该数组为例，执行归并排序的具体过程，如下所示：

[94,12,34,76,26,9,0,37,55,76,    37,5,68,83,90,37,12,65,76,49]
            [94,12,34,76,26,    9,0,37,55,76]
            [94,12,34,    76,26]
            [94,12,    34]
            [94,    12]
            {12,    94}
            {12,34,    94}
            [76,    26]
            {26,    76}
            {12,26,34,    76,94}
            [9,0,37,    55,76]
            [9,0,    37]
            [9,    0]
            {0,    9}
            {0,9,    37}
            [55,    76]
            {55,    76}
            {0,9,37,    55,76}
            {0,9,12,26,34,    37,55,76,76,94}
            [37,5,68,83,90,    37,12,65,76,49]
            [37,5,68,    83,90]
            [37,5,    68]
            [37,    5]
            {5,    37}
            {5,37,    68}
            [83,    90]
            {83,    90}
            {5,37,68,    83,90}
            [37,12,65,    76,49]
            [37,12,    65]
            [37,    12 ]
            {12,    37 }
            {12,37,    65 }
            [76,    49 ]
            {49,    76}
            {12,37,49,    65,76}
            {5,12,37,37,49,    65,68,76,83,90}
            {0,5,9,12,12,26,34,37,37,37,    49,55,65,68,76,76,76,83,90,94}

上面示例的排序过程中，方括号表示“分解”操作过程中，将原始数组进行递归分解，直到不能再继续分割为止；花括号表示“归并”的过程，将上一步分解后的数组进行归并排序。因为采用递归分治的策略，所以从上面的排序过程可以看到，“分解”和“归并”交叉出现。

算法分析：

• 时间复杂度

对长度为n的文件，需进行FLOOR(logn) 趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。

• 空间复杂度

需要一个辅助向量来暂存两有序子文件归并的结果，故其辅助空间复杂度为O(n)，显然它不是就地排序。

• 排序稳定性

归并排序是一种稳定的排序。

转载原地址：http://shiyanjun.cn/archives/820.html

1. //归并排序复杂度分析：
2. 一趟归并需要将待排序列中的所有记录 扫描一遍，因此耗费时间为O(n),而由完全二叉树的深度可知， 整个归并排序需要进行[log2n],因此，总的时间复杂度为  O(nlogn),而且这是归并排序算法中最好、最坏平均的时间性能 
   
3. //空间复杂度：由于归并过程中需要与原始记录序列同样数量级的 存储空间去存放归并结果及递归深度为log2N的栈空间，因此空间复杂度为O(n+logN)
   
4.  //也就是说，归并排序是一种比较占内存，但却效率高且稳定的算法 

迭代法

非递归的方法，避免了递归时深度为log2N的栈空间，空间只是用到归并临时申请的跟原来数组一样大小的空间，并且在时间性能上也有一定的提升，因此，使用归并排序是，尽量考虑用非递归的方法。

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 10

void MergeSort(int k[],int n)
{
    int i,next,left_min,left_max,right_min,right_max;
    //开辟一个与原来数组一样大小的空间用来存储用
    int *temp = (int *)malloc(n * sizeof(int));
    //逐级上升，第一次比较2个，第二次比较4个，第三次比较8个。。。
    for(i=1; i<n; i*=2)
    {
        //每次都从0开始，数组的头元素开始
        for(left_min=0; left_min<n-i; left_min = right_max)
        {
            right_min = left_max = left_min + i;
            right_max = left_max + i;
            //右边的下标最大值只能为n
            if(right_max>n)
            {
                right_max = n;
            }
            //next是用来标志temp数组下标的，由于每次数据都有返回到K，
            //故每次开始得重新置零
            next = 0;
            //如果左边的数据还没达到分割线且右边的数组没到达分割线，开始循环
            while(left_min<left_max&&right_min<right_max)
            {
                if(k[left_min] < k[right_min])
                {
                    temp[next++] = k[left_min++];
                }
                else
                {
                    temp[next++] = k[right_min++];
                }
            }
            //上面循环结束的条件有两个，如果是左边的游标尚未到达，那么需要把
            //数组接回去，可能会有疑问，那如果右边的没到达呢，其实模拟一下就可以
            //知道，如果右边没到达，那么说明右边的数据比较大，这时也就不用移动位置了
            
            while(left_min < left_max)
            {
                //如果left_min小于left_max，说明现在左边的数据比较大
                //直接把它们接到数组的min之前就行
                k[--right_min] = k[--left_max];    
            }
            while(next>0)
            {
                //把排好序的那部分数组返回该k
                k[--right_min] = temp[--next];        
            }
        }
    }
}

int main(){
    int i,a[10] = {5,2,6,0,3,9,1,7,4,8};
    MergeSort(a,10);
    
    printf("排序后的结果是:");
    for(i=0; i<10; i++)
    {
        printf("%d",a[i]);
    }
    printf("\n\n");
    
    return 0;
    
}

快速排序

     快排的思路：每次选取无序数组的第一个数


代码实现：
public class Sorts {
    public static void quickSort(int[] target) {
        quickSort(target, 0, target.length - 1);
    }

    private static void quickSort(int[] target, int start, int end) {
        if(start < end) {
            int pivot = target[start];
            int pivotPostion = partion(target, start, end, pivot);
            //左表
            quickSort(target, start, pivotPostion - 1);

            //右表
            quickSort(target, pivotPostion + 1, end);
        }
    }

    private static int partion(int[] target, int start, int end, int value) {
        int pivot = value;

        //其实，看上去形式上是双重循环，但实质上一个循环的效果，
        // 是因为循环的终结条件只考虑是否遍历完数组的条件（start < end)
        while(start < end) {
            while(start < end && target[end] >= pivot) end--;
            target[start] = target[end];

            while(start < end && target[start] < pivot) start++;
            target[end] = target[start];
        }
        target[start] = pivot;
        return start;
    }

}


测试：

public class Test {
    public static void main(String[] args) {
    int[] elments = inflate(10);
    //对比
    System.out.println("origin is : " + Arrays.toString(elments));
    Sort.quickSort(elements);
    System.out.println("after is : " + Arrays.toString(elments));
    
    }
    //产生随机数
    public static int[] inflate(int size) {
        int[] elements = new int[size];
        Random random = new Random();
        for(int i = 0; i < size; i++) {
            elements[i] = random.nextInt(1000);
        }
        return elements;
    }

}

堆排序（难点在理解 建堆过程）

代码思路：
        1.先建堆(大根堆满足:父节点大于儿子结点，Ki >= K(2i) , Ki >= K(2i+1))
        2.然后将堆的根节点和最后一个元素对换，然后 size--，表示最大的元素已经删除出数组
        3.然后再重新构建大根堆，然后再重复步骤2

    难点：1.如何删除堆顶元素   
              2.如何重构堆
    
    代码实现：

import java.lang.annotation.ElementType;
import java.util.Arrays;

public class HomeWork1_Heap {
    //成员变量
    int[] elements;
    int size;

    //构造方法
    public HomeWork1_Heap(int[] target){

        int len = target.length;

        int[] temp = new int[len + 1];

        System.arraycopy(target,0, temp ,1, len);

        elements = temp;

        size = len;

        heapify();
    }

    //构造堆
    public void heapify(){
        for (int i = size / 2; i >= 1 ; i--) {
            fixDown(i,size);
        }
    }

    //堆排序
    public void heapSort(){
        for (int i = size; i > 1 ; ) {

            //交换第一个和最后一个元素
            swap(elements,1, i);

            //elements中元素个数减少一个
            i--;

            //再重新构造堆
            fixDown(1,i);

        }
    }
     private void fixDown(int index , int size) {
               if(index <= size) {
                   int child = 2 * index;
                   if(child > size) {
                       return;
                   }
                   if(child + 1 <= size && elements[child + 1] > elements[child]) {
                       child++;
                   }
                   if(elements[index] < elements[child]) {
                       swap(elements, index, child);
                       fixDown(child,size);
                   }
               }
           }

    private void swap(int[] elements, int child, int index) {
        int tmp;
        tmp = elements[child];
        elements[child] = elements[index];
        elements[index] = tmp;
    }

    //重写toString
    public String toString(){
        StringBuilder builder = new StringBuilder();
        if(size == 0){
            builder.append("[]");
        }
        builder.append("[");
        for (int i = 1; i < size ; i++) {
            builder.append(elements[i]+" ");
            builder.append(",");
        }
        builder.append(elements[size]);
        builder.append("]");

        return builder.toString();
    }
}

测试：
    public class TestHeap {
    public static void main(String[] args) {
         int[] arr = {20,50,30,80,10,60};
         //已经在new的时候构造好了堆
        HomeWork1_Heap homeWork1_heap = new HomeWork1_Heap(arr);
        System.out.println("原始堆为" + homeWork1_heap);

        //进行堆排序
        homeWork1_heap.heapSort();
        System.out.println("排序后" + homeWork1_heap);

        //如果用默认的输出结果是 [0,....],因为index是从1开始的，所以0号位为默认值
        System.out.println("排序后" + Arrays.toString(homeWork1_heap.elements));
    }
}

输出结果：

原始堆为[80 ,50 ,60 ,20 ,10 ,30]
排序后[10 ,20 ,30 ,50 ,60 ,80]
排序后[0, 10, 20, 30, 50, 60, 80]