常见排序算法

最新推荐文章于 2021-03-02 15:49:59 发布
最新推荐文章于 2021-03-02 15:49:59 发布
阅读量1.8k 收藏 5
点赞数
分类专栏： C/C++

索引

1. 插入排序 
    1.1 直接插入 
    1.2 折半插入 
    1.3 希尔排序 
2. 交换排序 
    2.1 冒泡排序 
    2.2 快速排序 
3. 选择排序 
    3.1 直接选择 
    3.2 堆排序 
4. 归并排序  
    4.1 迭代归并  
总结

 

1. 插入排序

    思想：每步将一个待排序的对象, 按其排序码大小, 插入到前面已经排好序的一组对象的适当位置上, 直到对象全部插入为止。

1.1 直接插入

    1.1.1 方法： 
        当插入第i (i >= 1) 个对象时, 前面的V[0], V[1], …, V[i-1]已经排好序。这时, 用V[i]的排序码依次与V[i-1], V[i-2], …的排序码顺序进行比较, 找到插入位置即将V[i]插入, 原来位置上的对象向后顺移。 
      具体过程： 
        1. 把n个待排序的元素看成为一个“有序表”和一个“无序表”； 
        2. 开始时“有序表”中只包含1个元素，“无序表”中包含有n-1个元素； 
        3. 排序过程中每次从“无序表”中取出第一个元素，依次与“有序表”元素的关键字进行比较，将该元素插入到“有序表”中的适当位置，有序表个数增加1，直到“有序表”包括所有元素。

    1.1.2 实例图：

插入排序——直接插入    

1.1.3 代码：

/**
 * 直接插入排序：将数组从小到大排序
 */
#include <iostream>
using namespace std;

typedef int Index;//下标的别名
typedef int Type;//待排序的数组的元素类型

/**
 * 直接插入排序
 */
void direct_insert_sort(Type *array, int length) {
    Index i;
    Index j;//插入的位置
    Type temp;

    for(i=1; i<length; i++) {//i=1，即从第二个元素开始（第一个元素下标为0）
        temp = array[i];
        j=i;
        while(j>0 && array[j-1]>temp) {
            array[j] = array[j-1];
            j--;
        }
        //如果i!=j，说明要插入到前面的“已续表”中
        if(i!=j){
            array[j] = temp;
        }
    }
}

int main(int argc, char **argv) {
    Type array[19] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};//待排序的数组
    shell_sort(array, 19);

    //排序后，输出数组
    for(int i=0; i<19; i++) {
        cout<<array[i]<<"  ";
    }
    cout<<endl;

    return 0;
}

     1.1.4 分析： 
        时间复杂度：O(n^2)； 稳定的。 
        在下面两种情况，直接插入排序的效率较高：①序列中元素很少；②序列中的元素已经基本有序。

1.2 折半插入

    1.2.1 方法： 
        在“直接插入排序”中，将在“有序表”中查找符合要求的项，利用二分查找完成。

    1.2.2 实例图： 
        和“直接插入排序”排序过程相同。（两者只是“查找插入位置的方法”不同）

    1.2.3 代码： 

/**
 * 折半插入排序
 */
void binary_insert_sort(Type *array, int length) {
    Index i;
    Index k;
    Index left, right;//二分查找时记录左右两侧的下标
    Type temp;
    
    for(i=1; i<length; i++) {
        left = 0;
        right = i-1;//查找时，不包括第i个，因为是要将第i个插入到合适的位置
        temp = array[i];
        while(left<=right) {
            Index middle = (left+right)/2;
            if( array[middle]<=temp ){ //注意：当middle==temp时，要是left加1。否则，算法将“不稳定”
                left = middle+1;
            }else{
                right = middle-1;
            }
        }
        for(k=i; k>left; k--){
            array[k] = array[k-1];
        }
        array[left] = temp;
    }
}

int main(int argc, char **argv) {
    Type array[19] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};//待排序的数组
    shell_sort(array, 19);

    //排序后，输出数组
    for(int i=0; i<19; i++) {
        cout<<array[i]<<"  ";
    }
    cout<<endl;

    return 0;
}

    1.2.4 分析： 
        时间复杂度：O(N*logN)； 稳定的（注意若处于后面“无序表”中的项，若等于前面“有序表”中的项，要将该项插入到“有序表”中对应项的后面）。 
        相对于“直接插入排序”：比较次数比“直接插入排序”的最差情况要好得多，但是比“直接插入排序”的最好情况要差，尤其是当数组已经排好序或者接近有序的时候。也就是说，“折半插入排序”不是在所有情况都优于“直接插入排序”。

1.3 希尔排序（缩小增量排序）

    1.3.1 方法： 
        因为在“直接插入排序”过程中，若元素已经基本有序，那么“直接插入排序”的效率较高。引出了“希尔排序”的基本思想： 
        1. 设待排序的序列有 n 个对象，首先取一个整数 gap < n 作为间隔, 将下标相差为gap的倍数对象放在一组。 
        2. 在组内作 直接插入排序。 
        3. 然后逐渐缩小间隔 gap, 例如取 gap = gap/2，重复上述的组划分和排序工作。直到最后取 gap == 1, 将所有对象放在同一个组中进行排序为止。

    1.3.2 实例图：

插入排序——希尔排序

    1.3.3 代码：

/**
 * 希尔排序：将数组从小到大排序
 */
#include <iostream>
using namespace std;

typedef int Index;//下标的别名
typedef int Type;//待排序的数组的元素类型

/**
 * 希尔排序
 */
void shell_sort(Type *array, int length) {
    Index i;
    Index j;//插入的位置
    Type temp;
    int gap = length/2;//子序列间隔，这里取长度的一半

    while(gap!=0) {
        for(i=gap; i<length; i+=gap) { //1. i从gap开始取值；2. i每次递增gap
            temp = array[i];
            j=i;
            while(j>=gap && array[j-gap]>temp) {
                array[j] = array[j-gap];
                j -= gap;
            }
            //如果i!=j，说明要插入到前面的“已续表”中
            if(i!=j) {
                array[j] = temp;
            }
        }
        gap /= 2;
    }
}

int main(int argc, char **argv) {
    Type array[19] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};//待排序的数组
    shell_sort(array, 19);

    //排序后，输出数组
    for(int i=0; i<19; i++) {
        cout<<array[i]<<"  ";
    }
    cout<<endl;

    return 0;
}

    1.3.4 分析： 
         时间复杂度：n^1.25 ~ 1.6*n^1.25之间（统计资料），是不稳定的；gap的取值会影响希尔排序的效率。

2. 交换排序

    思想：两两比较待排序对象的排序码,如果发生逆序，则进行交换。直到所有对象都排好序为止。

2.1 冒泡排序

    2.1.1 方法： 
        1. 对待排序序列从前向后（从下标较大的元素开始）依次比较相邻元素的关键字，若发现逆序则交换； 
        2. 使较小的元素逐渐前移（或者较大的元素逐渐后移）；（假定按照“从小到大”排序）  
      改进措施：  
          如果一趟比较下来没有进行过交换，就说明序列已经有序；可以通过设置一个标志exchange记录一趟遍历中是否进行了交换。

    2.1.2 实例图： 

 

 

交换排序——冒泡排序

    2.1.3 代码：

/**
 * 冒泡排序：将数组从小到大排序
 */
#include <iostream>
using namespace std;

typedef int Index;//下标的别名
typedef int Type;//待排序的数组的元素类型

/*
 * 方法一：每次将最小的元素推至前端
 */
void bubble_sort1(Type *array, int length) {
    Index i, j;
    bool exchange;//标志一次遍历中，是否进行了交换

    for(i=0; i<length-1; i++) {
        exchange = false;//每次循环开始时，值为false
        for(j=length-1; j>i; j--) {
            if(array[j]<array[j-1]) { //两两比较，当两者相等时，不交换，这样才能使该排序稳定，即原来在前面的排序后也在前面
                exchange = true;

                Type temp = array[j-1];
                array[j-1] = array[j];
                array[j] = temp;
            }
        }
        //如果本次循环没有交换，说明数组已经排序完毕
        if(!exchange) {
            break;
        }
    }
}
/*
 * 方法二：每次将最大的元素推至末尾
 */
void bubble_sort2(Type *array, int length) {
    Index i, j;
    bool exchange;//标志一次遍历中，是否进行了交换

    for(i=0; i<length-1; i++) {
        exchange = false;//每次循环开始时，值为false
        for(j=0; j<length-i-1; j++) {
            if(array[j]>array[j+1]) { //两两比较，和“将较小元素推至前端”相同，当两者相等时，不交换，这样才能使该排序稳定，即原来在后面的排序后也在后面
                exchange = true;

                Type temp = array[j+1];
                array[j+1] = array[j];
                array[j] = temp;
            }
        }
        //如果本次循环没有交换，说明数组已经排序完毕
        if(!exchange) {
            break;
        }
    }
}

int main(int argc, char **argv) {
    Type array[19] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};//待排序的数组
    bubble_sort1(array, 19);

    //排序后，输出数组
    for(int i=0; i<19; i++) {
        cout<<array[i]<<"  ";
    }
    cout<<endl;

    return 0;
}


    2.1.4 分析： 
        时间复杂度：O(n^2)； 稳定的。

2.2 快速排序

    2.2.1 方法：  
        “冒泡排序”中，元素的比较是从一端到另一端进行，每次移动一个位置；如果要是能“从两端到中间”进行，比“基准元素”大的一次就能交换到后面单元，比“基准元素”小的一次就能交换到前面单元，每次移动的距离较远，从而总的比较次数和移动次数都会减少。 
        步骤：（利用分治的算法思想） 
            1. 任取待排序序列中的某个元素作为基准（一般取第一个元素）； 
            2. 通过一趟排序，将待排元素分为左右两个子序列： 
                  左子序列元素的关键字均小于或等于基准元素的关键字； 
                  右子序列的关键字则大于基准元素的关键字； 
            3. 分别对两个子序列继续进行排序，重复以上步骤，直至整个序列有序。（是一个递归的过程）

    2.2.2 实例图： 交换排序——快速排序

         当 i 为1时，执行过程为：

交换排序——快速排序（当i为1的执行过程） 
    2.2.3 代码：   

/**
 * 快速排序：将数组从小到大排序
 */
#include <iostream>
using namespace std;

typedef int Index;//下标的别名
typedef int Type;//待排序的数组的元素类型

void quick_sort_recursion(Type *array, Index left, Index right);
int partition(Type *array, Index left, Index right);

/**
 * 快速排序，接口，内部调用“递归实现函数”quick_sort_recursion
 */
void quick_sort(Type *array, int length) {
    quick_sort_recursion(array, 0, length-1);
}
/**
 * 快速排序，递归实现函数
 */
void quick_sort_recursion(Type *array, Index left, Index right) {
    if(left<right) {
        int pivot_index = partition(array, left, right);//获得基准位置
        quick_sort_recursion(array, left, pivot_index-1);//递归调用，将子序列排序，注意不包括pivot_index位置的元素
        quick_sort_recursion(array, pivot_index+1, right);
    }
    /*
     调用这里的left和right都是有效的下标。如果类似C++ STL中，right是末尾的下一位，应写为下面的形式：
      原则：①调用partition函数的参数都是有效的；②调用自身quick_sort_recursion的参数right是末尾的下一个；  
     if(left<right) {
        int pivot_index = partition(array, left, right-1);//使用right-1
        quick_sort_recursion(array, left, pivot_index);//使用pivot_index
        quick_sort_recursion(array, pivot_index+1, right);
    }
     相应的，在quick_sort函数中的调用形式应修改为：quick_sort_recursion(array, 0, length);
     */
}
/**
 * 利用第一元素作为基准元素，将整个序列划分为两个部分。
 * 步骤：
 *   1. 比基准元素小的都移动到左侧，比基准元素大的都移动到右侧，变量pivot_position始终记录着比基准元素小的元素的最后一个元素。
 *   2. 最后将基准元素（第一个）与pivot_position位置上的元素交换，就可以达到目的。
 * 这时基准元素所在的位置也就是最终排序完成后，应该在的位置
 * 注意：这个实现中，参数中的left和right都是有效的，特别注意的是，这里的right是序列最后一个元素的下标，不是最后一个元素的下一个。
 */
int partition(Type *array, Index left, Index right) {
    Type pivot = array[left];//基准元素值
    Index pivot_index = left; //记录已比较的元素中，比基准元素小的元素的最后一个位置；也是最后要返回的位置

    Index i;
    for(i=left+1; i<=right; i++) {//这里 i 能够等于right，就要求传给partition的参数中的right参数，一定要是有效的
        if(array[i]<pivot) {
            pivot_index++;
            //交换array[pivot_index]和array[i]
            if(i!=pivot_index) {
                Type temp = array[i];
                array[i] = array[pivot_index];
                array[pivot_index] = temp;
            }
        }
    }
    //交换基准元素（第一个元素）和array[pivot_index]
    array[left] = array[pivot_index];
    array[pivot_index] = pivot;
    return pivot_index;
}

#define ARRAY_LENGTH 18

int main(int argc, char **argv) {
    Type array[ARRAY_LENGTH] = { 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0};//待排序的数组
    //调用接口函数
    quick_sort(array, ARRAY_LENGTH);

    //排序后，输出数组
    for(int i=0; i<ARRAY_LENGTH; i++) {
        cout<<array[i]<<"  ";
    }
    cout<<endl;

    //调用递归实现函数
    quick_sort_recursion(array, 0,ARRAY_LENGTH);
    //排序后，输出数组
    for(int i=0; i<ARRAY_LENGTH; i++) {
        cout<<array[i]<<"  ";
    }
    cout<<endl;

    return 0;
}

 

    2.2.4 分析： 
        快速排序是一个“递归算法”，快速排序的趟数等于递归树的高度。         时间复杂度：最好 O(N*logN)；最差 O(N^2)； 
        空间复杂度：最好 O(logN)； 最差 O(N)； 
        是一种不稳定的算法。但是当序列元素数量较多时，快速排序的效率一般很好，所以经常采用；但是当元素较少时，其比一般方法可能要慢（因为要递归）。

3. 选择排序

    思想：每一趟遍历，都从序列中找到最小的元素，将其放到队列的开始位置。或者找到序列的最大元素，放到队列的末尾。

3.1 直接选择排序

    3.1.1 方法： 
        1. 在一组对象 V[i]～V[n-1] 中选择最小的对象； 
        2. 将它与这组对象中的第一个对象对调; 
        3. 在剩下的对象V[i+1]～V[n-1]中重复执行第①、②步, 直到剩余对象只有一个为止。 

    3.1.2 实例图：     

 

选择排序——直接选择排序

 

/**
 * 直接选择排序：将数组从小到大排序
 */
#include <iostream>
using namespace std;

typedef int Index;//下标的别名
typedef int Type;//待排序的数组的元素类型

/**
 * 直接选择排序，每次选取最小的替换到开头
 */
void direct_select_sort(Type *array, int length) {
    Index i, j;
    Index min_index;//每趟循环中，最小元素的下标
    Type temp;
    for(i=0; i<length-1; i++) {// i 的取值范围是从0到length-2，不包括最后一个元素（下标为 length-1），因为只剩一个元素时不需要判断
        min_index = i;
        for(j=i+1; j<length; j++) {//从i+1开始
            if(array[j]<array[min_index]) {
                min_index = j;
            }
        }
        temp = array[i];
        array[i] = array[min_index];
        array[min_index] = temp;
    }
}

#define ARRAY_LENGTH 18

int main(int argc, char **argv) {
    Type array[ARRAY_LENGTH] = { 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0};//待排序的数组
    direct_select_sort(array, ARRAY_LENGTH);

    //排序后，输出数组
    for(int i=0; i<ARRAY_LENGTH; i++) {
        cout<<array[i]<<"  ";
    }
    cout<<endl;

    return 0;
}

    3.1.4 分析： 
        时间复杂度：O(n^2)。不稳定。 
        总的比较次数固定为：n*(n-1)/2次，即O(n^2)级别。

3.2 堆排序

    3.2.1 方法：  
        1. 根据初始输入数据，利用堆的“下滤调整算法”形成初始最大堆； 
        2. 将最大元素换到最后一个元素，对前面的元素构建最大堆。 
        3. 重复执行以上两步，直到所有元素排序完成。

    3.2.2 实例图： 

选择排序——堆排序    

3.2.3 代码：

/**
 * 堆排序：将数组从小到大排序
 *  方法：依次建立最大堆，将堆顶元素（最大元素）与最后一个元素交换；
 */
#include <iostream>
using namespace std;

typedef int Index;//下标的别名
typedef int Type;//待排序的数组的元素类型

void filter_down(Type *heap, Index pos, int length);
void build_heap(Type *array, int length);
void heap_sort(Type *array, int length);

/**
 * 堆的下滤操作
 */
void filter_down(Type *heap, Index pos, int length) {
    Index current=pos;//记录下滤过程中的当前节点
    Index child = 2*pos+1;//当前节点的子节点，当下标从0开始时，找到左孩子的下标
    
    Type temp = heap[pos];
    
    while(child<length) {
        //若左右孩子都存在，找到左右孩子中最大的那个
        if(child+1<length && heap[child]<heap[child+1]) {
            ++child;
        }
        //如果当前节点小于 其 孩子，将“子节点的值”赋给“当前节点”
        if(temp<heap[child]) {
            heap[current] = heap[child];
        } else {
            break;
        }
        current = child;
        child = 2*child + 1;
    }
    heap[current] = temp;
}
/**
 * 建立 堆
 */
void build_heap(Type *array, int length) {
    Index i;
    for(i=(length-2)/2; i>=0; i--) {
        filter_down(array, i, length);
    }
}

/**
 * 堆排序
 */
void heap_sort(Type *array, int length) {
    //建立堆
    build_heap(array, length);
    
    Index i;
    Type temp;
    for(i=length-1; i>0; i--) {// i 的范围从length-1 到 1，共length-2次循环（不包括i=0），若只剩一个元素，则说明整个序列已经有序了。
        //交换
        temp = array[0];
        array[0] = array[i];
        array[i] = temp;
        //下滤
        filter_down(array, 0, i);
    }
}

#define ARRAY_LENGTH 18

int main(int argc, char **argv) {
    Type array[ARRAY_LENGTH] = { 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0};//待排序的数组

    heap_sort(array, ARRAY_LENGTH);

    //排序后，输出数组
    for(int i=0; i<ARRAY_LENGTH; i++) {
        cout<<array[i]<<"  ";
    }
    cout<<endl;

    return 0;
}

   3.2.4 分析： 
        时间复杂度：O(n*logn)； 
        空间复杂度：O(1)； 
        不稳定。

4. 归并排序  

    思想：将两个或两个以上的“有序表”合并成一个新的“有序表”。

4.1迭代归并

   4.1.1 方法：  
        利用“两路归并”过程进行，步骤如下： 
            1. 把序列看成是 n 个长度为 1 的有序子序列 (归并项)，先做两两归并，得到 n / 2 个长度为 2 的归并项 (如果 n 为奇数，则最后一个有序子序列的长度为1)； 
            2. 然后看成长度为2, 4, 8……的有序子序列，两两归并，直到得到长度为n的有序序列； 
      注意： 
         如果n不是2len的整数倍, 则一趟归并到最后,可能遇到两种情形： 
             1. 剩下一个长度为len的归并项和另一个长度不足len的归并项, 可用merge算法将它们归并成一个长度小于 2len 的归并项； 
             2. 只剩下一个归并项，其长度小于或等于 len, 将它直接抄到目标序列中。

    4.1.2 实例图： 

归并排序算法（迭代）     

4.1.3 代码： 

/**
 * 归并排序（迭代实现）：将数组从小到大排序
 */
#include <iostream>
using namespace std;

typedef int Index;//下标的别名
typedef int Type;//待排序的数组的元素类型

void merge(Type *src, Type *dest, Index left, Index middle, Index right);
void merge_pass(Type *src, Type *dest, int section, int length);
void merge_sort(Type *array, int length);

/**
 * 合并两个列表
 * 将src中[left, middle]位置，和src中[middle+1, right]开始位置的元素合并到dest中
 *  注意：上面的区间是闭区间
 */
void merge(Type *src, Type *dest, Index left, Index middle, Index right) {
    Index i = left; //在src的[left, middle]中前进
    Index j = middle+1; //在src的[middle+1, right]中前进
    Index k = left; //在dest中前进
    while(i<=middle && j<=right) {
        if(src[i]<=src[j]) { //注意：因为src[i]在前面，为了是算法稳定，当src[i]==src[j]时，应先添加stc[i]
            dest[k++] = src[i++];
        } else {
            dest[k++] = src[j++];
        }
    }
    //[left, middle]还没有走完
    while(i<=middle) {
        dest[k++] = src[i++];
    }
    //[middle+1, right]还没有走完
    while(j<=right) {
        dest[k++] = src[j++];
    }
}
/**
 * 归并排序的具体执行函数
 */
void merge_pass(Type *src, Type *dest, int section, int length) {
    Index i=0;
    //1. 合并开始部分
    while(i+2*section <= length) {//因为序列下标从0开始，有等号
        merge(src, dest, i, i+section-1, i+2*section-1);
        i += 2*section;
    }
    //2.剩余部分有两块
    if(i+section<length) {
        merge(src, dest, i, i+section-1, length-1);
    } else {
        //3. 只剩一部分，直接添加到末尾
        while(i<length) {//这里没有等号
            dest[i] = src[i];
            i++;
        }
    }
}

/**
 * 归并排序
 */
void merge_sort(Type *array, int length) {
    int section = 1;//小部分的长度
    Type *help_array = new Type[length];//辅助数组
    while(section<length) { //section不需要等于length
        //从array归并到help_array
        merge_pass(array, help_array, section, length);
        section *= 2;
        //从help_array归并到array
        merge_pass(help_array, array, section, length);
        section *= 2;
    }
    delete []help_array;
}

#define ARRAY_LENGTH 18

int main(int argc, char **argv) {
    Type array[ARRAY_LENGTH] = { 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0};//待排序的数组
    merge_sort(array, ARRAY_LENGTH);

    //排序后，输出数组
    for(int i=0; i<ARRAY_LENGTH; i++) {
        cout<<array[i]<<"  ";
    }
    cout<<endl;

    return 0;
}

    4.1.4 分析： 
        时间复杂度：O(N*logN)； 
        空间复杂度：一个和原来数组一样大小的数组，O(N)； 
        该算法是稳定的。

5. 总结

 

排 序 方 法

 比较次数

 移动次数

稳定性 

附加存储

最好

最差

最好

最差

最好

最差

直接插入排序

n

n^2

 0

n^2

 Ö

  1

折半插入排序

n logn

 0

n^2

 Ö

  1

起泡排序

n

n^2

 0

n^2

 Ö

  1

快速排序

nlogn

n^2

< nlogn

n^2

 ´

logn

n

直接选择排序

n^2

 0

n

 ´

  1

堆排序

n logn

n logn

 ´

  1

归并排序

n logn

n logn

 Ö

  n

ctthuangcheng
关注
专栏目录
java实现数据结构常见排序算法及详解
11-08
### Java 实现数据结构常见排序算法及详解 #### 排序算法概述 排序算法是计算机科学中的基础概念之一，主要用于将一系列数据按照特定规则进行排列。根据数据处理方式的不同，排序算法大致分为两大类：比较排序与非...
常用的排序算法
yaoming168
12-19 1501
一、冒泡排序： 对一个队列里的数据，挨个进行轮询和交换，每次轮询出一个当前最大或者最小的值放在队尾，然后继续下次轮询，轮询长度-1，就跟冒泡一样，所以称为冒泡排序，运算时间复杂度N平方 二、选择排序： 对一个队列里的数据，选出当前最大或者最小的值，然后将他与队首的数据交换，然后从第二个开始，进行相同的操作，运算时间复杂度N平方，但由于他不像冒泡一样需要不停的交换位置，所以会比冒泡快一些 ...
常见的排序算法
fhzh520的专栏
07-24 603
1.快速排序算法 事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来，且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。 步骤： ·       从数列中挑出一个元素，称为 "基准"（pivot）， ·       重新排序数列，所有元素比基准值小的摆放在基准前面，所有元
常用排序算法
Andy
03-02 184
面试一个经典的老问题就是排序算法思想，本篇先回顾基础内部排序算法，之后简单分析外部排序算法，并以腾讯的一道面试题作结. 随机数生成器 要排序，首先得有数据，因此，手写一个随机数生成器 private void generate_random_numbers(int n) { BufferedWriter writer = null; try { writer = new BufferedWriter(new FileWriter("data.txt")); .
常见排序算法分享：排序算法.zip
最新发布
06-05
在"排序算法.zip"这个压缩包中，很可能是包含了关于各种常见排序算法的源代码、示例或教程。 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的交换排序方法，通过重复遍历数组，比较相邻元素并交换位置，使得较...
七种常见排序算法动态演示图.rar
08-08
以下是对七种常见排序算法的详细解释： 1. **冒泡排序**：冒泡排序是最基础的排序算法之一，其工作原理是通过不断地交换相邻的逆序元素，使得最大的元素逐渐“冒”到数组的末尾。该过程会重复进行，直到所有元素都...
php实现的常见排序算法汇总
10-25
本文将详细介绍几种常见排序算法的基本概念、PHP实现方法和各自的优缺点。 1. 插入排序： 插入排序的基本思想是将数组分为已排序和未排序两部分，每次从未排序的部分取出一个元素插入到已排序部分的适当位置。在PHP...
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
Java的几种常见排序算法
csdn_life18的博客
04-24 439
　　一、所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。 　　二、排序算法可以分为内部排序和外部排序。 　　　　内部排序...
算法——常见排序算法
少年啦飞啦的博客
02-21 211
基本介绍 举例说明 代码如下 package day0515; public class demo_sort { public static void main(String[] args) { //冒泡排序算法 int[] numbers=new int[]{3, 9, -1, 10, 20}; int i,j; ...
C语言实现的常见排序算法详解
本文主要介绍了常见排序算法的C语言实现，包括了内排序的基本类型以及稳定性，重点关注了插入排序、选择排序和冒泡排序，并提供了冒泡排序的C语言代码示例。 排序算法是计算机科学中基础且重要的部分，它们在处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值