java排序算法

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.快速排序

快速排序就是找一个基准位,一般就取第一个,然后两个标记为i,j。一个从左往右开始找一个比基准位大或者相等的数,记录他的下标为i,另一个就是从右往左找一个比基准位小或者相等的数,记录他的小标为j,然后如果i在j的左边,就交换两个位置的值,然后再找下两个元素进行交换,当i,j相等时交换基准位和j,i的值,然后做两个递归。

package sort;

public class QuickSort {
    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];

        while (i<j) {
            //先看右边,依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边,依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[low] = arr[i];
        arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }


    public static void main(String[] args){
        int[] arr = {6,1,2,5,9,12,4,7,10,8};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

3.选择排序

基本思想:在要排序的一组数中,选出最小的一个数与第一个位置的数交换;然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止。

/**
     * 选择排序算法
     * 在未排序序列中找到最小元素,存放到排序序列的起始位置  
     * 再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。 
     * 以此类推,直到所有元素均排序完毕。 
     * @param numbers
     */
    public static void selectSort(int[] numbers)
    {
    int size = numbers.length; //数组长度
    int temp = 0 ; //中间变量
    
    for(int i = 0 ; i < size ; i++)
    {
        int k = i;   //待确定的位置
        //选择出应该在第i个位置的数
        for(int j = size -1 ; j > i ; j--)
        {
        if(numbers[j] < numbers[k])
        {
            k = j;
        }
        }
        //交换两个数
        temp = numbers[i];
        numbers[i] = numbers[k];
        numbers[k] = temp;
    }
    }

4.插入排序

每步将一个待排序的记录,按其顺序码大小插入到前面已经排序的字序列的合适位置(从后向前找到合适位置后),直到全部插入排序完为止。

例子:
  待比较数据:7, 6, 9, 8, 5,1

  第一轮:指针指向第二个元素6,假设6左面的元素为有序的,将6抽离出来,形成7,_,9,8,5,1,从7开始,6和7比较,发现7>6。将7右移,形成_,7,9,8,5,1,6插入到7前面的空位,结果:6,7,9,8,5,1

  第二轮:指针指向第三个元素9,此时其左面的元素6,7为有序的,将9抽离出来,形成6,7,_,8,5,1,从7开始,依次与9比较,发现9左侧的元素都比9小,于是无需移动,把9放到空位中,结果仍为:6,7,9,8,5,1

  第三轮:指针指向第四个元素8,此时其左面的元素6,7,9为有序的,将8抽离出来,形成6,7,9,_,5,1,从9开始,依次与8比较,发现8<9,将9向后移,形成6,7,_,9,5,1,8插入到空位中,结果为:6,7,8,9,5,1

  第四轮:指针指向第五个元素5,此时其左面的元素6,7,8,9为有序的,将5抽离出来,形成6,7,8,9,_,1,从9开始依次与5比较,发现5比其左侧所有元素都小,5左侧元素全部向右移动,形成_,6,7,8,9,1,将5放入空位,结果5,6,7,8,9,1。

  第五轮:同上,1被移到最左面,最后结果:1,5,6,7,8,9。

package sort;


import java.util.Arrays;

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


    }
    /**
     * 插入排序
     * @param b
     */
    public static void insertSort(int[] b){
        for (int i=1;i<b.length;i++){
            int tmp = b[i];
            int j;
            for (j=i-1;j>=0 && b[j]>tmp;j--){
                b[j+1] = b[j];
            }
            b[j+1]=tmp;
        }
    }
}

5.希尔排序

分组的插入排序

package sort;

public class shell {
    public static void main(String[] args) {
        int a[] = {3,1,5,7,2,4,9,6,10,8};
        int dk = a.length/2;
        while (dk>=1){
            shellSort(a,dk);
            dk = dk/2;
        }
    }
    /**
     * 希尔排序
     * @param b
     * @param dk
     */
    public static void shellSort(int[] b,int dk){
        for (int i=dk;i<b.length;i++){
            int tmp = b[i];
            int j;
            for (j=i-dk;j>=0 && b[j]>tmp;j=j-dk){
                b[j+dk] = b[j];
            }
            b[j+dk] = tmp;
        }
    }
}

6.堆排序

package sort;

import java.util.Arrays;

public class heap {

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

    public static void heapSort(int[] arr) {
        //1.构建大顶堆
        for (int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上,从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for (int j=arr.length-1;j>0;j--){
            //将堆顶元素与末尾元素进行交换
            swap(arr,0,j);
            //重新对堆进行调整
            adjustHeap(arr,0,j);
        }
    }
    public static void adjustHeap(int[] arr,int i,int length){
        //先取出当前元素i
        int temp = arr[i];
        //从i结点的左子结点开始,也就是2i+1处开始
        for(int k=i*2+1;k<length;k=k*2+1){
            //如果左子结点小于右子结点,k指向右子结点
            if(k+1<length && arr[k]<arr[k+1]){
                k++;
            }
            //如果子节点大于父节点,将子节点值赋给父节点(不用进行交换)
            if(arr[k] >temp){
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        //将temp值放到最终的位置
        arr[i] = temp;
    }

    public static void swap(int []arr,int a,int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值