BlogJava-Johnny-文章分类-数据结构算法

希尔排序Java代码

瓢菝的雨夜 — Fri, 21 Sep 2012 09:30:00 GMT

/**
* 希尔排序
* @author sikaijian
*/
public class ShellSort {
    public static void sort(int[] data){
        int d = data.length/2;
        while(d!=0){
            directInsertSort(data, d);
            d/=2;
        }
    }

    /**
     * 带增量的直接插入排序
     * @param data 待排序数组
     * @param d 增量
     */
    private static void directInsertSort(int[] data, int d){
        int len = data.length;

        for(int i=0; i+d            int pCurrent = i+d;
            int left = i-1;
            while(pCurrent                int front = pCurrent-d;
                int key = data[pCurrent];
                while(front>left && data[front]>key){
                    data[front+d] = data[front];
                    front-=d;
                }
                data[front+d] = key;

                pCurrent+=d;
            }
        }
    }

    public static void showArray(int[] array){
        for (int t : array) {
            System.out.print(t);
            System.out.print(" ");
        }
    }

    /**
     * 测试代码
     * @param args
     */
    public static void main(String[] args) {
        int[] data = new int[] { 49, 23, 65, 13, 38, 96, 12, 33, 88, 123, 22,
                11, 9, 55, 111, 0 };

        showArray(data);
        System.out.println();
        System.out.println("------------------------------");
        ShellSort.sort(data);

        showArray(data);
    }
}

瓢菝的雨夜 2012-09-21 17:30 发表评论

直接插入排序Java代码

瓢菝的雨夜 — Fri, 21 Sep 2012 06:23:00 GMT

/**
* 直接插入排序
* @author sikaijian
*/
public class DirectInsertSort {
    public static void sort(int[] data){
        int pCurrent = 1;   // 认定第0个数是有序的，从第1个数开始插入排序
        int n = data.length;

        while(pCurrent            int front = pCurrent-1;
            int key = data[pCurrent];

            // 当前要插入的数和左边的有序队列比较（从右往左比较，比较一次移动一次）
            while(front>-1 && key                data[front+1] = data[front];
                front--;
            }

            data[front+1] = key;

            pCurrent++;
        }
    }

    /**
     * 测试代码
     * @param args
     */
    public static void main(String[] args) {
        int[] data = new int[] { 49, 23, 65, 13, 38, 96, 12, 33, 88, 123, 22,
                11, 9, 55, 111, 0 };

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
        System.out.println();
        System.out.println("------------------------------");
        DirectInsertSort.sort(data);

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
    }
}

瓢菝的雨夜 2012-09-21 14:23 发表评论

冒泡排序Java代码

瓢菝的雨夜 — Fri, 21 Sep 2012 05:32:00 GMT

/**
* 冒泡排序
* @author sikaijian
*/
public class BubbleSort {
    public static void sort(int[] data){
        if(data.length<=1) return;

/**

* 每一趟排序都把最大的数字放到最后

* 下一趟排序后，最大的数不参加

* 总共n-1趟（n为数组长度）

        for (int i = data.length-1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if(data[j]>data[j+1]){
                    int temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                }
            }
        }
    }

    /**
     * 测试代码
     * @param args
     */
    public static void main(String[] args) {
        int[] data = new int[] { 49, 23, 65, 13, 38, 96, 12, 33, 88, 123, 22,
                11, 9, 55, 111, 0 };

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
        System.out.println();
        System.out.println("------------------------------");
        BubbleSort.sort(data);

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
    }
}

瓢菝的雨夜 2012-09-21 13:32 发表评论

快速排序Java代码

瓢菝的雨夜 — Fri, 21 Sep 2012 03:01:00 GMT

/**
* @author sikaijian
*/
public class QuickSort {

    /**
     * 快速排序算法实现
     * @param data 待排序数组
     * @param left 左边界初始0
     * @param right 右边界初始数组长度-1
     * @author sikaijian
     */
    public static void sort(int[] data, int left, int right) {
        if (left > right)
            return;
        int pHead = left;  // 头部指针
        int pTail = right;  // 尾部指针
        int key = data[left];  // 哨兵

        while (pHead < pTail) {
            // 从右往左遍历，找到比key小的数，放到前面
            while (pHead < pTail && data[pTail] > key) pTail--;
            if (pHead < pTail) data[pHead++] = data[pTail];

            // 从左往右遍历，找到比key大的数，放到后面
            while (pHead < pTail && data[pHead] < key) pHead++;
            if (pHead < pTail) data[pTail--] = data[pHead];
        }

        data[pHead] = key; // 归位

        sort(data, left, pHead-1);  // 排序左边的数组
        sort(data, pHead+1, right);  // 排序右边的数组
    }

    /**
     * 测试代码
     * @param args
     */
    public static void main(String[] args) {
        int[] data = new int[] { 49, 23, 65, 13, 38, 96, 12, 33, 88, 123, 22,
                11, 9, 55 };

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
        System.out.println();
        System.out.println("------------------------------");
        QuickSort.sort(data, 0, data.length - 1);

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
    }
}

瓢菝的雨夜 2012-09-21 11:01 发表评论