java 排序算法

原创 2018年04月17日 15:35:48

想要学习更多的后台基础的可搜索博客号:weixin_41920152

/**  

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

/**  
 * 快速排序
 * 
 *从数列中挑出一个元素,称为“基准”
 * 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,  
 * 该基准是它的最后位置。这个称为分割(partition)操作。
 *递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。
 * 
 * @param numbers  
 * @param start  
 * @param end  
 */  
public static void quickSort(int[] numbers, int start, int end) {   
    if (start < end) {   
        int base = numbers[start]; // 选定的基准值(第一个数值作为基准值)   
        int temp; // 记录临时中间值   
        int i = start, j = end;   
        do {   
            while ((numbers[i] < base) && (i < end))   
                i++;   
            while ((numbers[j] > base) && (j > start))   
                j--;   
            if (i <= j) {   
                temp = numbers[i];   
                numbers[i] = numbers[j];   
                numbers[j] = temp;   
                i++;   
                j--;   
            }   
        } while (i <= j);   
        if (start < j)   
            quickSort(numbers, start, j);   
        if (end > i)   
            quickSort(numbers, i, end);   
    }   
}  

/**  
 * 选择排序
 * 在未排序序列中找到最小元素,存放到排序序列的起始位置
 * 再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。
 * 以此类推,直到所有元素均排序完毕
 *   
 * @param numbers  
 */  
public static void selectSort(int[] numbers) {   
    int size = numbers.length, temp;   
    for (int i = 0; i < size; i++) {   
        int k = 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;   
    }   
}

/**  
 * 插入排序 
 *
 * <li>从第一个元素开始,该元素可以认为已经被排序 
 * <li>取出下一个元素,在已经排序的元素序列中从后向前扫描 
 * <li>如果该元素(已排序)大于新元素,将该元素移到下一位置 
 * <li>重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
 * <li>将新元素插入到该位置中
 * <li>重复步骤2
 * 
 *   
 * @param numbers  
 */  
public static void insertSort(int[] numbers) {   
    int size = numbers.length, temp, j;   
    for(int i=1; i<size; i++) {   
        temp = numbers[i];   
        for(j = i; j > 0 && temp < numbers[j-1]; j--){   
            numbers[j] = numbers[j-1];  
      } 
        numbers[j] = temp;   
    }   
}  
/**  
 * 归并排序
 * 
 * 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列  
 * 设定两个指针,最初位置分别为两个已经排序序列的起始位置  
 * 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置  
 * 重复步骤3直到某一指针达到序列尾
 * 将另一序列剩下的所有元素直接复制到合并序列尾  
 *   
 *   
 * @param numbers  
 */  
public static void mergeSort(int[] numbers, int left, int right) {   
    int t = 1;// 每组元素个数   
    int size = right - left + 1;   
    while (t < size) {   
        int s = t;// 本次循环每组元素个数   
        t = 2 * s;   
        int i = left;   
        while (i + (t - 1) < size) {   
            merge(numbers, i, i + (s - 1), i + (t - 1));   
            i += t;   
        }   
        if (i + (s - 1) < right)   
            merge(numbers, i, i + (s - 1), right);   
    }   
}   
/**  
 * 归并算法实现  
 *   
 * @param data  
 * @param p  
 * @param q  
 * @param r  
 */  
private static void merge(int[] data, int p, int q, int r) {   
    int[] B = new int[data.length];   
    int s = p;   
    int t = q + 1;   
    int k = p;   
    while (s <= q && t <= r) {   
        if (data[s] <= data[t]) {   
            B[k] = data[s];   
            s++;   
        } else {   
            B[k] = data[t];   
            t++;   
        }   
        k++;   
    }   
    if (s == q + 1)   
        B[k++] = data[t++];   
    else  
        B[k++] = data[s++];   
    for (int i = p; i <= r; i++)   
        data[i] = B[i];   
}  


/**
 * 二分查找又称折半查找,它是一种效率较高的查找方法。 
  【二分查找要求】:1.必须采用顺序存储结构 2.必须按关键字大小有序排列。
 * @author wzj
 *
 */
public class BinarySearch { 
    public static void main(String[] args) {
        int[] src = new int[] {1, 3, 5, 7, 8, 9}; 
        System.out.println(binarySearch(src, 3));
        System.out.println(binarySearch(src,3,0,src.length-1));
    }

    /**
     * * 二分查找算法 * *
     * @param srcArray
     *            有序数组 *
     * @param des
     *            查找元素 *
     * @return des的数组下标,没找到返回-1
     */ 
   public static int binarySearch(int[] srcArray, int des){ 
        int low = 0; 
        int high = srcArray.length-1; 
        while(low <= high) { 
            int middle = (low + high)/2; 
            if(des == srcArray[middle]) { 
                return middle; 
            }else if(des <srcArray[middle]) { 
                high = middle - 1; 
            }else { 
                low = middle + 1; 
            }
        }
        return -1;
   }

java各种排序算法

  • 2008年02月01日 18:29
  • 12KB
  • 下载

各种排序算法java实现

  • 2011年06月17日 15:47
  • 13KB
  • 下载

Java所有排序算法大全

  • 2009年03月10日 22:41
  • 11KB
  • 下载

Java各种排序算法

  • 2012年01月04日 21:13
  • 83KB
  • 下载

java 常用排序算法

  • 2009年04月17日 09:44
  • 52KB
  • 下载

Java实现的常见排序算法.pdf

  • 2011年10月26日 11:26
  • 99KB
  • 下载

Java中常见的排序算法

详解java中几种常见的排序算法
  • xiaoge0103
  • xiaoge0103
  • 2016-04-07 17:38:11
  • 2028

十种常见的排序算法总结(java版)

排序是程序开发中非常常见的操作,对一组任意的数据元素经过排序操作后,就可以把他们变成一组一定规则排序的有序序列。排序算法属于算法中的一种,而且是覆盖范围极小的一种,但彻底掌握排序算法对程序开发是有很大...
  • canot
  • canot
  • 2016-03-06 23:03:54
  • 3347

几种常见排序算法总结(java版)

代码如下: /*************几种常见的排序算法总结***************************/ package paixu; public class PaiXu {...
  • zgrjkflmkyc
  • zgrjkflmkyc
  • 2013-09-13 12:50:28
  • 13612

java实现各种排序算法及比较

常见排序算法包括以下七种:选择排序、冒泡排序、插入排序、快速排序、希尔排序、堆排序、归并排序。 在学习具体算法实现并进行比较前,先来学习算法比较的几个维度。 一是稳定性 所谓稳定性,是指值相等的...
  • tang9140
  • tang9140
  • 2015-06-08 11:01:45
  • 5444
收藏助手
不良信息举报
您举报文章:java 排序算法
举报原因:
原因补充:

(最多只允许输入30个字)