基本排序算法(java实现)

基本概念

• 稳定性
  

• 内排序和外排序
  

排序的主要分类

选择排序

import java.util.Arrays;
/**
 * 选择排序
 *1.找到数组中最小的那个元素,将他和数组中第一个元素交换位置;
 *2.再在剩下的元素中找到最小的元素,将它与第二个元素交换位置
 *3.如此往复,直到整个数组排序
 *特点:
 *1.运行时间和输入无关.为了找出最小的元素而扫描一边数组并不能为下一遍扫描提供什么信息
 *2.数据移动是最少的.每次交换都会改变两个数组元素的值
 */
public class SelectionSort
{
    public static void sort(int[] arr){

        for(int i = 0; i < arr.length; i++){
            int min = arr[i];

            for(int j = i+1; j < arr.length; j++){

                    if(arr[j] < min){
                    arr[i] = arr[j];
                    arr[j] = min;
                    min = arr[i];
                }
            }
        }
    }

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

插入排序

/**
 * 插入排序
 * 1.每次将一个待排序的元素与已排序的元素进行逐一比较，直到找到合适的位置按大小插入
 * 
 * 
 */
public class InsertionSort
{
    public static void sort(int[] arr){
        for(int i = 1; i<arr.length; i++){
            if(arr[i] < arr[i-1]){
                int temp = arr[i];
                int j=0;
                //将大于temp的数据往后挪一个位置
                for(j = i-1; j >= 0 && arr[j] > temp; j--){
                    arr[j+1] = arr[j];
                }
                //将temp赋给j+1位置
                arr[j+1] = temp;
            }
        }

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

希尔排序

/**
 * 希尔排序
 * 在排序算法加入一个外循环来将h按照递增序列递减,就能得到简介的希尔排序
 * 
 */
public class ShellSort
{
    public static void sort(int[] arr){
        int h = arr.length;
        while(h>=1){
            //将距离为h的元素编为一个组,扫描所有组
            for(int i = h; i<arr.length; i++){
                if(arr[i] < arr[i-h]){
                    int temp = arr[i];
                    int j=0;
                    //对距离为h的元素进行排序
                    for(j = i-h; j >= 0 && arr[j] > temp; j-=h){
                        arr[j+h] = arr[j];
                    }
                    arr[j+h] = temp;
                }
            }//减小增量
            h = h/2;
        }
    }

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

归并排序

import java.util.Arrays;

/**归并排序
 * 采用分治思想
 * 
 * 
 */
public class MergeSort
{
    public static void sort(int[] arr){
        decompose(arr, 0, arr.length-1);
    }

    public static void decompose(int[] arr,int lo,int hi){
        //递归终止
        if(hi <= lo)
            return;
        int mid = lo + (hi-lo)/2;
        //采用递归
        decompose(arr, lo, mid);
        decompose(arr, mid+1, hi);
        merger(arr, lo, mid, hi);
    }

    public static void merger(int[] arr,int lo,int mid, int hi){
        int i = lo;
        int j = mid+1;
        int k = 0;
        int[] arr_temp = new int[hi-lo+1];
        //扫描第一段和第二段,直到有一个扫描结束
        while(i <= mid && j <= hi){
            if(arr[i] <= arr[j]){
                arr_temp[k] = arr[i];
                i++;
                k++;
            }else {
                arr_temp[k] = arr[j];
                j++;
                k++;
            }   
        }//若第一段还没有扫描完,将其全部复制到合并序列
        while(i <= mid){
            arr_temp[k] = arr[i];
            i++;
            k++;
        }//若第二段还没有扫描完,将其全部复制到合并序列
        while(j <= hi){
            arr_temp[k] = arr[j];
            j++;
            k++;
        }
        //将arr_temp排好序赋给arr
        for(k=0,i=lo; i<=hi; i++,k++){
            arr[i] = arr_temp[k];
        }

    }

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

}

快速排序

import java.util.Arrays;


/**快速排序
 * 
 * 
 * 
 * 
 */
public class QuickSort
{
    public static void sort(int[] arr){
        sort(arr,0,arr.length-1);
    }

    public static void sort(int[] arr,int lo,int hi){
        if(hi <= lo)
            return;

        int base_index = partition(arr, lo, hi);
        sort(arr,0,base_index-1);
        sort(arr,base_index+1,hi);
    }

    public static int partition(int[] arr, int lo, int hi){
        int base = arr[lo];

        while(lo < hi){
            while(lo < hi && arr[hi] >= base)
                hi--;
            arr[lo] = arr[hi];

            while(lo < hi && arr[lo] <= base)
                lo++;
            arr[hi] = arr[lo];
        }

        arr[lo] = base;
        return lo;
    }
    public static void main(String[] args)
    {
        int[] arr = {4,2,9,3,7,5,1,8,8};
        QuickSort.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

堆排序

import java.util.*;

/**
 *堆排序 :分为大根堆和小根堆,左子树和右子树只要求比根大或小,其他没有严格的要求
 * 
 * 基本思想:
 * 1.先利用数组排成一个大堆
 * 2.将大堆的根元素与最后一个元素互换
 * 
 */
public class HeapSort
{
    public static void sort(int[] arr){

        //构建一个大顶堆
        int i = 0;
        for(i = arr.length/2;i>=0;i--){
            heapAdjust(arr, i, arr.length-1);
        }

        //完成排序
        for(i = arr.length-1; i>0; i--){
            //将最后一个和最大的一个进行交换
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            heapAdjust(arr, 0, i);
        }
    }

    public static void heapAdjust(int[] arr, int parent, int length){
        int temp = arr[parent];
        //取左孩子节点
        int child = 2 * parent + 1;

        while(child < length){
            //如果有孩子节点比左孩子节点大,取有孩子节点
            if(child+1 < length && arr[child] < arr[child+1]){
                child++;
            }
            //若父节点大于孩子节点,则直接结束
            if(temp >= arr[child])
                break;

            //若arr[parent]<arr[child]
            arr[parent] = arr[child];

            //将孩子节点赋给父节点,继续
            parent = child;
            child = 2 * child +1;
        }
        //将当初的temp赋给遍历完后的parent
        arr[parent] = temp;
    }

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

各排序算法性能比较

上面只是在参考下面资料下做得读书笔记,下面的资料有详细的介绍各种算法的实现过程,时间关系这里没有详细介绍!!!

参考资料

• 大话数据结构

• http://www.cnblogs.com/jingmoxukong/p/4303826.html