几种常见算法的精简版-

  1 package test;

import java.nio.channels.SelectableChannel;

import com.itqf.bean.User;

public class cTypeCode {

    /********************************************希尔排序和插入排序*******推荐严慧敏的那本数据结构，思想步骤我都加入到算法里面了，很精简了***********************************************************
     * 插入排序
     * 
     * @param values
     *            带排序数组
     */
    public void insertSort(int[] values) {
        int mod;// 中间值
        for (int i = 1; i < values.length; i++) {
            mod = values[i];// 记录初始位置的值，完成交换
            int index = 0;// 记录位置
            for (int j = i; j >= 1; j--) {
                // 如果前面的值比后面的值小，就后 移
                if (values[j - 1] > mod) {
                    values[j] = values[j - 1];
                } else {
                    index = j;
                    break;
                }
            }
            values[index] = mod;
        }

    }

    /**
     * shell sort
     * 希尔排序是对插入排序的一个改进，相隔几个增量的递进式排序，直到增量为1。。所有的增量必须只能被1除。
     * @param values
     *            valuies which wait for sroted
     * @param dk
     *            added values
     */
    public void shellSort(int[] values, int dk) {
        if (dk > values.length) {
            System.out.println("values is beyond the binder");
            return;
        }
        // * 1.使用增量循环遍历数组
        for (int i = dk; i < values.length; i++) {
            // * 2.创建保留初始比较值得变量，创建保存比较值的下标值的变量
            int mod = values[dk];
            int index = 0;
            // * 3.遍历后面已经排好序的序列，退出循环
            for (int j = i; j >= dk; j -= dk) {
                // 在合适的地方插入比较值，如果比较值小于当前值，就交换，
                if (values[j - dk] > mod) {
                    values[j] = values[j - dk];
                } else {
                    // 否则，记下比较值的下标，进行交换，
                    index = j;
                    break;
                }
            }
            // 4.在下标处填入初始比较值，第一轮比较完成
            values[index] = mod;
        }
    }

    /********************快速排序分割线***********************************************************************************
     * 快速排序方法 为什么会采用这种归位那，因为始终是在和枢轴进行比较，就没有必要进行枢轴的交换了。
     * 
     * @param values
     *            待排序数组
     * @param low
     *            最低位下标
     * @param high
     *            最高位下标
     */
    public static int quickSort(int[] values, int low, int high) {
        // 1.确定枢轴，以第一个为枢轴
        // 1.1 为了提高性能，采用三者取中方法，可大大提高乱序情况下的性能
        int pivotKey;
        int[] keys = { values[low], values[high], values[(low + high) / 2] };
        pivotKey = keys[0];
        for (int i = 0; i < keys.length - 1; i++) {
            if (pivotKey < keys[i]) {
                pivotKey = keys[i];
            }
        }
        // 2.循环数组
        while (low < high) {
            // 2.1 依最高位下标递减检查小于枢轴的关键字，和low交换
            while (low < high && values[high] >= pivotKey)
                --high;
            // 2.2 把高位赋值给低位
            values[low] = values[high];
            // 3.从最低位开始依次递增检查大于枢轴的关键字，和high交换
            while (low < high && values[low] <= pivotKey)
                ++low;
            // 把低位赋值给高位
            values[high] = values[low];
            // 4.重复2和3步骤
        }
        // 5.枢轴归位
        values[low] = pivotKey;
        // 6.返回枢纽位置
        return low;

    }

    /**
     * 快速排序完整部分
     * 
     * @param values
     * @param low
     * @param high
     */
    public static void overrallSort(int[] values, int low, int high) {
        if (low < high) {
            int index = quickSort(values, low, high);// 获得枢轴下标，把数组一分为二
            // 枢轴左半部排序
            overrallSort(values, low, index - 1);
            // 枢轴右半部排序
            overrallSort(values, index + 1, high);
        }
    }

    /**
     * 选择排序
     * 
     * @param values
     */
    public static void selectSort(int[] values) {
        for (int i = 0; i < values.length - 1; i++) {
            for (int j = i; j < values.length; j++) {
                if (values[i] > values[j]) {
                    // 交换关键字
                    int mad = values[i];
                    values[i] = values[j];
                    values[j] = mad;
                }
            }
        }

    }

    /****************************************************大顶堆排序算法************************************
     * 堆排序
     * @param a
     * @param b
     * @return
     */
    public boolean isBig(int a, int b) {
        if (a < b) {
            return false;
        }
        return true;
    }

    /**
     * 此部分算法，视为最简洁堆排序算法。比网上大部分都要好，但是难理解，把这个算法理解了，你会发现很简洁的算法。
     * @param values
     * @param start
     * @param high
     */
    public void heapAdjust(int[] values, int start, int high) {
        int rc = values[start];
        for (int i = 2 * start; i <= high; i *= 2) {// 沿着key较大的孩子节点向下筛选
            if (i < high && !isBig(values[i], values[i + 1])) {// i为较大的记录的下标
                i++;// 如果i是小的记录，就把i加一，变为沿着另一个子节点向下跑
            }
            if (isBig(rc, values[i])) {//如果rc大于最大的子节点，就把rc插入到start的位置，也就是父节点，然后这一部分的堆排序结束
                break;// rc应该插入到s位置上
            }
            values[start] = values[i];//rc不大于最大的子节点，就把最大的子节点放到父节点的位置，进行下一次循环堆排序
            start = i;//沿着key值最大的节点向下筛选
        }
        values[start] = rc;// 插入，也可以理解为归位
    }

    public void heapSort(int[] values) {
        /**
         * 堆排序要解决两个问题。 第一，如何由无序序列建成一个堆 第二，如何在输出堆顶元素之后，调整剩余元素成为一个新的堆 现在建立大根堆
         */
        for (int i = (values.length - 1) / 2; i >= 0; i--) {
            heapAdjust(values, i, values.length - 1);
        }
        for (int i = values.length - 1; i > 0; i--) {
            // 交换堆顶最大值和最后一个记录
            int mad = values[0];
            values[0] = values[i];
            values[i] = mad;
            heapAdjust(values, 0, i - 1);
        }
    }

    /***********************************************************************归并排序算法分割线*********************************************
     * 归并部分排序算法
     * 
     * @param values
     * @param low
     * @param mad
     * @param high
     */
    public static void merge(int[] values, int low, int mad, int high) {
        int[] tr = new int[high + 1];// 辅助序列
        int low1 = low;
        int high1 = high;
        int i;
        int j = mad + 1;
        // * 第一步：循环整个序列，分为两部分进行比较，数值大的加入到辅助序列中，重复此步骤
        for (i = low; low <= mad && j <= high; i++) {
            if (values[low] > values[j]) {
                tr[i] = values[low++];
            } else {
                tr[i] = values[j++];
            }
        }
        // * 第二步，把还有剩余的部分加入到辅助序列中
        if (j <= high) {
            tr[i] = values[j++];
        }
        if (low <= mad) {
            tr[i] = values[low++];
        }
        // * 第三步：把辅助序列中排好序的序列恢复到原先的存储中
        // 把排序好的序列恢复到原序列中
        for (int j2 = low1; j2 <= high1; j2++) {
            values[j2] = tr[j2];
        }

    }

    /**
     * 归并排序
     * @param values
     * @param low
     * @param high
     */
    public static void mSort(int[] values, int low, int high) {
        if (low == high) {// 如果相等，就返回
            return;
        } else {
            int mad = (low + high) / 2;
            mSort(values, low, mad);
            mSort(values, mad + 1, high);
            merge(values, low, mad, high);
        }
    }
 
    
    /**************************************************************************************简单哈希算法分割线*************************************************
     * 在hash表中查找指定值
     * 首先看一下，用hash函数得出来的hash地址位置上是否有值并且和要查找的值相等，如果相等，就返回，如果不相等，就继续查找下一个。、
     * 不为空和不相等，同时成立，才会有找下去的必要，其他情况没有必要找下去。比如，位置为空，就可以直接退出了。
     * 
     * @param hashTable
     * @param value
     */
    public boolean searchHash(int[] hashTable, int value) {
        // 计算hash值
        int hashCode = getHashCode(value, hashTable.length);
        // 检测用hash函数得出来的hash地址位置上是否有值并且和要查找的值相等,两者都不想等，继续查找。找到退出循环
        // 不为空和不相等，同时成立，才会有找下去的必要，其他情况没有必要找下去。比如，位置为空，就可以直接退出了。
        while (hashTable[hashCode] != 0 && hashTable[hashCode] != value) {
            hashCode++;
        }
        // 找到就返回成功
        if (hashTable[hashCode] == value) {
            return true;
        }
        return false;

    }

    /**
     * 计算hash值
     * 
     * @param value
     *            关键字
     * @param length
     *            hash表长度
     * @return
     */
    public int getHashCode(int value, int hashLength) {

        return value % hashLength;

    }

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        int[] values = { 12, 8, 2, 3, 4, 78, 96, 52 };
        //
        // //overrallSort(values, 0, values.length-1);
        // //int index = quickSort(values, 0, values.length-1);
        // selectSort(values);
        // System.out.println(index);


        // user.heapSort(values);堆排序
        mSort(values, 0, values.length - 1);// 归并排序 这个归并排序有点问题，最后一个为什么是0，我看不出来，有看出来的，请回答，谢谢。
        for (int i = 0; i < values.length; i++) {
            System.out.print(values[i] + " ");
        }
    }
}