[转载]一些常用的排序（查找）算法

一些常用的排序（查找）算法

 

/**
 * 排序算法
 * <p>
 * 插入排序 |____直接插入排序 |____折半排序 |____希尔排序
 * <p>
 * 交换排序 |____冒泡排序 |____快速排序
 * <p>
 * 选择排序 |____简单选择排序 |____堆排序 |____归并排序
 * <p>
 * 分配排序 |____箱排序 |____基数排序
 * 
 * 
 * @author kevin
 * 
 */
public class Sorting {

    /**
     * 直接插入排序,降序 把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，
     * 无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，
     * 将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。
     * 
     * @param array
     */
    public void Straight_Insert_Sort(int[] array) {
        // i<len的话，j+1会超出数组下标，j+1也取到最后一个了，所有len-1
        for (int i = 0, temp = 0; i < array.length - 1; i++) {
            for (int j = i; 0 <= j; j--) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                } else
                    break;
            }
        }
    }

    /**
     * 折半排序,降序 
     * 在一个有序的子文件中，用折半查找方法查找代插入记录应插入的位置。 
     * 直接插入用的是顺序查找。
     * 
     * @param array
     */
    public void Binary_Insert_Sort(int[] array) {
        for (int i = 1, temp = 0, m = 0, high = 0, low = 0; i < array.length; i++) {
            low = 0;
            high = i - 1;
            temp = array[i];
            while (high >= low) {
                m = (high + low) >> 1;
                if (array[m] > temp)
                    high = m - 1;
                else
                    low = m + 1;
            }
            for (int j = i - 1; j >= low; j--) {
                array[j + 1] = array[j];
            }
            array[low] = temp;
        }
    }

    /**
     * 希尔排序,降序 
     * 把记录按一定的增量分组，对每组用直接插入排序排序； 
     * 随着增量的减少，各分组中包含的记录将越来越多，
     * 当增量减少为1时，所有记录序列变成一组。
     * 
     * @param array
     */
    public void Shell_Sort(int[] array) {
        int t = 0;
        if (array.length % 2 == 0)
            t = array.length >> 1;
        else
            t = (array.length >> 1) + 1;

        while (t >= 1) {
            for (int i = t,temp = 0; i < array.length; i++) {
                for (int j = i - t; j >= 0; j =j - t) {
                    if (array[j] > array[j + t]) {
                        temp = array[j];
                        array[j] = array[j + t];
                        array[j + t] = temp;
                    }
                }
            }
            if (t == 1) 
                break;
            if (t % 2 == 0)
                t = t >> 1;
            else
                t = (t >> 1) + 1;
        }
    }

    /**
     * 冒泡排序,降序 
     * 从第一个记录开始两两比较，次序不对就交换它们的位置。
     * 
     * @param array
     */
    public void Bubblle_Sort(int[] array) {
        for (int i = 0, temp = 0, flag = 1; flag == 1 && i < array.length - 1; i++) {
            flag = 0;
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = 1;
                }
            }
        }
    }

    /**
     * 快速排序,降序 
     * 选择记录中一个适合的关键字，以此关键字对应的记录为基准，然后重新安排待排序列的记录。
     *  对该关键字前面和后面的记录重复这个过程。
     * 
     * @param array
     * @param p
     *            子文件的下界
     * @param q
     *            子文件的上界
     */
    public void Quick_Sort(int[] array, int p, int q) {
        int i = p;
        int j = q;
        int temp = array[i];
        while (i != j) {
            while (array[j] > temp && j > i)
                j--;
            if (j > i) {
                array[i] = array[j];
                i++;
            }
            while (array[i] < temp && j > i)
                i++;
            if (j > i) {
                array[j] = array[i];
                j--;
            }
        }
        array[i] = temp;
        if (p < i - 1)
            Quick_Sort(array, p, j - 1);
        if (j + 1 < q)
            Quick_Sort(array, j + 1, q);
    }

    /**
     * 简单选择排序,降序 
     * 首先找出所有记录中最小的记录，将它也第一个记录交换位置。 
     * 然后再找次小的记录，再与第二个记录交换位置，依此类推这个过程。
     * 
     * @param array
     */
    public void Simple_Selection_Sort(int[] array) {
        for (int i = 0, k = 0, temp = 0; i < array.length - 1; i++) {
            k = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[k])
                    k = j;
            }
            if (k != i) {
                temp = array[i];
                array[i] = array[k];
                array[k] = temp;
            }
        }
    }
 /**
 * 二路归并排序是将两个有序记录合并成一个有序记录
 * 从两个有序记录中最小关键记录开始比较输出较小者，然后继续比较，直到输出所有记录为止。
 * @param A,B
 * @return int[]
 */
 public int[] Two_Way_Merge_Sort(int[] A, int[] B) {
  int[] C = new int[A.length + B.length];
  int k = 0;
  int i = 0;
  int j = 0;
  while(i < A.length && j < B.length) {
   if (A[i] < B[j])
    C[k++] = A[i++];
   else
    C[k++] = B[j++];
  }
  while (i < A.length) 
   C[k++] = A[i++];
  while (j < B.length) 
   C[k++] = B[j++];
  return C;
 }

}