排序算法总结

来源：互联网发布：知乎离线版编辑：程序博客网时间：2024/06/01 08:59

冒泡排序

简介：

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。

原理：

冒泡排序算法的运作如下：（从后往前）

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

复杂度：

时间复杂度

若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数和记录移动次数均达到最小值：

，。

所以，冒泡排序最好的时间复杂度为。若初始文件是反序的，需要进行趟排序。每趟排序要进行

次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

冒泡排序的最坏时间复杂度为。综上，因此冒泡排序总的平均时间复杂度为。

算法描述：

c/c++版：

#include<stdio.h>

#defineSIZE8

voidbubble_sort(inta[],intn);

voidbubble_sort(inta[],intn)//n为数组a的元素个数

{

inti,j,temp;

for(j=0;j<n-1;j++)

for(i=0;i<n-1-j;i++)

{

if(a[i]>a[i+1])//数组元素大小按升序排列

{

temp=a[i];

a[i]=a[i+1];

a[i+1]=temp;

}

int main()

{

int number[SIZE]={95,45,15,78,84,51,24,12};

int i;

bubble_sort(number,SIZE);

for(i=0;i<SIZE;i++)

{

printf("%d",number[i]);

}

printf("\n");

}

java版：

public class BubbleSort

{

publicvoidsort(int[]a)

{

int temp=0;

for(inti=a.length-1;i>0;--i)

{

for(intj=0;j<i;++j)

{

if(a[j+1]<a[j])

{

temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

}

选择排序

1.直接选择排序

原理：将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序。

复杂度：

在简单选择排序过程中，所需移动记录的次数比较少。最好情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录。

最坏情况下，即待排序记录初始状态是按逆序排列的，则需要移动记录的次数最多为3（n-1）。简单选择排序过程中需要进行的比较次数与初始状态下待排序的

记录序列的排列情况无关。当i=1时，需进行n-1次比较；当i=2时，需进行n-2次比较；依次类推，共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2，即

进行比较操作的时间复杂度为O(n^2)，进行移动操作的时间复杂度为O(n)。

算法描述：

Void SelectSort(int a[ ],int size)

{

int i,j,k; //分别为有序区，无序区，无序区最小元素指针

for(i=0;i<size;i++)

{

k=i;

for(j=i+1;j<size;j++)

{

if(a[j]<a[k])

k=j;

}

if(k!=i) //若发现最小元素，则移动到有序区

{

int temp=a[k];

a[k]=a[i];

a[i]=a[temp];

}

快速排序算法Java实现

网上关于快速排序的算法原理和算法实现都比较多，不过java是实现并不多，而且部分实现很难理解，和思路有点不搭调。所以整理了这篇文章。如果有不妥之处还请建议。首先先复习一些基础。

1、算法概念。

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。

2、算法思想。

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

3、实现思路。

①以第一个关键字 K 1 为控制字，将 [K 1 ,K 2 ,…,K n ] 分成两个子区，使左区所有关键字小于等于 K 1 ，右区所有关键字大于等于 K 1 ，最后控制字居两个子区中间的适当位置。在子区内数据尚处于无序状态。
②把左区作为一个整体，用①的步骤进行处理，右区进行相同的处理。（即递归）
③重复第①、②步，直到左区处理完毕。

4、实现代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
     * description : 快速排序
     * @autor kwzhang
     * modify :2012-6-20
     *
     * @param pData
     * @param left
     * @param right
     * @return
     */
    static void quicksort(int n[], int left, int right) {
        int dp;
        if (left < right) {
            dp = partition(n, left, right);
            quicksort(n, left, dp - 1);
            quicksort(n, dp + 1, right);
        }
    }
 
    static int partition(int n[], int left, int right) {
        int pivot = n[left];
        while (left < right) {
            while (left < right && n[right] >= pivot)
                right--;
            if (left < right)
                n[left++] = n[right];
            while (left < right && n[left] <= pivot)
                left++;
            if (left < right)
                n[right--] = n[left];
        }
        n[left] = pivot;
        return left;
    }

0 0