6种主要排序方式

/**
     * 插入排序法 ---简单插入排序排序 整体思路--后面得元素向前搜索 其插入位置
     */
    static void InsertSort(int[] sqList, boolean is_smallTbig) {
 
        // is_smallTbig排练方式 //不放入for中是因为考虑算法运行速度
        int sentinel = 0;// 哨兵
        int j, i;
        if (is_smallTbig) {
            for (i = 1; i < sqList.length; i++) {
                sentinel = sqList[i];
                for (j = i - 1; j >= 0; j--) {
                    if (sqList[j] > sentinel) // 小到大顺序
                        sqList[j + 1] = sqList[j];// 比sentinel大则向后移动 直到空出j的位置
                    else {
                        break;
                    }
                }
                sqList[j + 1] = sentinel; // 把sentinel 放到 空出的j的位置 因为for出来j-1了
                // 所以j+1
            }
        } else {
            for (i = 1; i < sqList.length; i++) {
                sentinel = sqList[i];
                for (j = i - 1; j >= 0; j--) {
                    if (sqList[j] < sentinel) // 大到小顺序
                        sqList[j + 1] = sqList[j];// 比sentinel大则向后移动 直到空出j的位置
                    else {
                        break;
                    }
                }
                sqList[j + 1] = sentinel; // 把sentinel 放到 空出的j的位置 因为for出来j-1了
                // 所以j+1
            }
        }
 
    }
 
    /**
     * 插入排序法 ---shell(希尔)排序(不稳定)
     */
    static void ShellSort(int[] sqList, boolean is_smallTbig) {
        // 使数组部分有序 整体上 大（小）的在后面小（大）的在前面 时间复杂度为O(n^(3/2))
        int[] step = { 9, 5, 3, 1 };// 最后一位必须为1
        int s, t;
        int sentinel = 0;// 哨兵
        if (is_smallTbig) {
            for (int i = 0; i < step.length; i++) {
                s = step[i]; // 取步长
                for (int j = s; j < sqList.length; j++) {
                    // 分组进行排序 组的步长就是S
                    sentinel = sqList[j];
                    t = j - s;
                    // 对步长为s的组进行排序 使之有序
                    for (; t >= 0 && (t <= sqList.length); t = t - s) {
                        if (sentinel < sqList[t])// 小到大排序
                        {
                            sqList[t + s] = sqList[t];
                        } else {
                            break;
                        }
                    }
                    sqList[t + s] = sentinel;
                }
            }
        } else {
            for (int i = 0; i < step.length; i++) {
                s = step[i]; // 取步长
                for (int j = s; j < sqList.length; j++) {
                    // 分组进行排序 组的步长就是S
                    sentinel = sqList[j];
                    t = j - s;
                    // 对步长为s的组进行排序 使之有序
                    for (; t >= 0 && (t <= sqList.length); t = t - s) {
                        if (sentinel > sqList[t]) // 大到小排序
                        {
                            sqList[t + s] = sqList[t];
                        } else {
                            break;
                        }
                    }
                    sqList[t + s] = sentinel;
                }
            }
        }
 
    }
 
    /**
     * 交换排序法-----冒泡排序 整体思路（已两两交换） 先找出数组中最大(小)的元素放在其位置
     */
    static void BubbleSort(int[] sqList, boolean is_smallTbig) {
        int sentinel = 0;
        int i = sqList.length, j = 0;
        if (is_smallTbig) {
            for (boolean change = true; i > 0 && change; i--) {
                change = false;// 如何已经有序则不用拍
                for (j = 1; j < i; j++) {
                    sentinel = sqList[j];
                    if (sentinel < sqList[j - 1]) {
                        change = true;
                        sqList[j] = sqList[j - 1];
                        sqList[j - 1] = sentinel;
                    }
 
                }
            }
        } else {
            for (boolean change = true; i > 0 && change; i--) {
                change = false;// 如何已经有序则不用拍
                for (j = 1; j < i; j++) {
                    sentinel = sqList[j];
                    if (sentinel > sqList[j - 1]) {
                        sqList[j] = sqList[j - 1];
                        sqList[j - 1] = sentinel;
                        change = true;
                    }
 
                }
            }
        }
 
    }
 
    /**
     * 交换排序法----- 快速排序 没有检测如入的合法性(不稳定)
     */
    int myQuicksort(int a[], int indexI, int indexJ) {
        int tempindex, start = indexI, end = indexJ, res;
        tempindex = indexI;
        if (indexI < 0 || indexJ < 0) {
            res = 0;
        }
        if (indexI >= indexJ) {
            res = 0;
        } else {
            boolean swich = true;
            while (true) {
                if (swich) {
                    if (a[indexJ] < a[tempindex]) {
                        int t;
                        t = a[indexJ];
                        a[indexJ] = a[tempindex];
                        a[tempindex] = t;
                        tempindex = indexJ;
                        swich = false;
                    } else {
                        indexJ--;
                    }
 
                } else {
                    if (a[indexI] > a[tempindex]) {
                        int t;
                        t = a[indexI];
                        a[indexI] = a[tempindex];
                        a[tempindex] = t;
                        tempindex = indexI;
                        swich = true;
                    } else {
                        indexI++;
                    }
                }
                if (indexJ <= indexI)
                    break;
            }
            res = myQuicksort(a, start, tempindex - 1);
            res = myQuicksort(a, tempindex + 1, end);
        }
        return res;
    }
 
    /**
     * 选择排序法-----简单选择排序(不稳定)
     */
    static void selectSort(int[] sqList, boolean is_smallTbig) {
        int sentinel = 0, tempIndex = 0;
        if (is_smallTbig) {
            for (int i = 0; i < sqList.length; i++) {
                tempIndex = i;
                sentinel = sqList[i];
                for (int j = i + 1; j < sqList.length; j++) {
                    sentinel = (sentinel < sqList[j]) ? sentinel
                            : sqList[tempIndex = j];// 记录最小值的index
                }
                sqList[tempIndex] = sqList[i];
                sqList[i] = sentinel;
            }
        } else {
            for (int i = 0; i < sqList.length; i++) {
                sentinel = sqList[i];
                tempIndex = i;
                for (int j = i + 1; j < sqList.length; j++) {
                    sentinel = (sentinel > sqList[j]) ? sentinel
                            : sqList[tempIndex = j];
                }
                sqList[tempIndex] = sqList[i];
                sqList[i] = sentinel;
            }
        }
 
    }
 
    /**
     * 选择排序法-----堆排（不稳定）
     */
    public class HeapSort {
        public void sort(int[] number) {
            int[] tmp = new int[number.length + 1]; // 配合說明，使用一個有徧移的暫存陣列
            for (int i = 1; i < tmp.length; i++) {
                tmp[i] = number[i - 1];
            }
            createHeap(tmp);
            int m = number.length;
            while (m > 1) {
                swap(tmp, 1, m);
                m--;
                int p = 1;
                int s = 2 * p;
                while (s <= m) {
                    if (s < m && tmp[s + 1] < tmp[s])
                        s++;
                    if (tmp[p] <= tmp[s])
                        break;
                    swap(tmp, p, s);
                    p = s;
                    s = 2 * p;
                }
            } // 這邊將排序好的暫存陣列設定回原陣列
            for (int i = 0; i < number.length; i++) {
                number[i] = tmp[i + 1];
            }
        }
 
        private void createHeap(int[] tmp) {
            int[] heap = new int[tmp.length];
            for (int i = 0; i < heap.length; i++)
                heap[i] = -1;
            for (int i = 1; i < heap.length; i++) {
                heap[i] = tmp[i];
                int s = i;
                int p = i / 2;
                while (s >= 2 && heap[p] > heap[s]) {
                    swap(heap, p, s);
                    s = p;
                    p = s / 2;
                }
            }
            for (int i = 1; i < tmp.length; i++)
                tmp[i] = heap[i];
        }
 
        private void swap(int[] number, int i, int j) {
            int t;
            t = number[i];
            number[i] = number[j];
            number[j] = t;
        }
    }
 
http://bbs.csdn.net/topics/330132210
posted @ 2013-10-18 15:16  hanks  阅读(4491)  评论(0)    收藏  举报