用c语言实现排序方法（上）

四种排序方法

后面的几种方法接下来会更新

---

---

前言

指针数组：int *p1[n]; 本质是一个数组，这个数组每个元素是 int 型的指针类型

                                （优先级使p先和[n]结合说明这是一个数组，再和*结合）

数组指针：int (*p2）[n]; 本质是一个指针，这个指针指向这个数组

                                 （p首先和 *结合，说明这是一个指针，再和[n]结合）

若是指针，需用括号将变量名和*阔在一起（*s1）,如果不阔上，会优先结合[ ],这样本质上就是数组不是指针了

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、BubbleSort

冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
   重复步骤1~3，直到排序完成。

时间复杂度O(n^2)
空间复杂度O(1)
空间复杂度O(n^2)

void BubbleSort(int *arry,int n)
{
    int i,j;
    for(i=1;i<n;i++) //注意第0个位置的数组未存取数值
    {
        for(j=1;j<n-i+1;j++)  //j也可以就j<=n-i
        {
            if(arry[j]>arry[j+1])
            {
                arry[0] = arry[j];
                arry[j] = arry[j+1];
                arry[j+1] = arry[0];
             }
        }
    }
}

二、SelectionSort

选择排序

1. 初始状态：无序区为R[1…n]，有序区为空；
2. 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
3. n-1趟结束，数组有序化了。

时间复杂度O(n^2)
空间复杂度O(1)
空间复杂度O(1)

void SelectionSort(int *arry,int n)
{
    int i,j,k;
    for(i=1;i<n;i++)  //注意不可以等与n就比较n-1次就可以第n个元素不在比较就是最后的
    {
        k = i;
        for(j=i+1;j<=n;j++)  //这个必须等于，因为要和全部的元素相比
        {
            if(arry[j]<arry[k])
            {
                k = j;
            }
        }
        if(k!=i)
        {
         arry[0] = arry[k];
         arry[i] = arry[k];
         arry[k] = arry[0];
        }
    }
}

三、InsertSort

插入排序

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
   4 .重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
4. 将新元素插入到该位置后；
5. 重复步骤2~5。

时间复杂度O(n^2)
空间复杂度O(1)

void InsertSort(int *arry,int n)
{
    int i,j;
    for(i=2;i<=n;i++)
    {
        if(arry[i]<arry[i-1])
        {
            arry[0] = arry[i];
            for(j=i-1;j>0&&arry[j]>arry[0];j--)
            {
                arry[j+1] = arry[j];
            }
            arry[j+1] = arry[0];
        }
    }
}

四、QuickSort

快速排序

1. 从数列中挑出一个元素，称为 “基准”（pivot）；
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

时间复杂度O(nlog2n)
空间复杂度O(nlog2n)

int Partition(int *arry,int low,int high)
{
    int i,j;
    i = low;
    j = high;
    while(i<j)  //大前提，必须确保low低于high，当不低于的时候证明找到i
	{
		while(i<j&&arry[i]<arry[j])j--;  //从高端往底端走
		if(i<j)
		{
			arry[0]=arry[i];
			arry[i]=arry[j];
			arry[j]=arry[0];
			i++;
		}
		while(i<j&&arry[i]<=arry[j])i++;  //从底端往高端走
		if(i<j)
		{
			arry[0]=arry[i];
			arry[i]=arry[j];
			arry[j]=arry[0];
			j--;
		}

	}
	return i;

}
void QuickSort(int *arry,int low,int high)
{
	int pivot;  //中间点
	if(low<high)
	{
		pivot = Partition(arry,low,high);
		QuickSort(arry,low,pivot-1);
		QuickSort(arry,pivot+1,high);
	}
}

所有的代码在这了：

operation.cpp

#include <iostream>
#include "Sort.h"
void BubbleSort(int *arry,int n)
{
    int i,j;
    for(i=1;i<n;i++) //注意第0个位置的数组未存取数值
    {
        for(j=1;j<n-i+1;j++)  //j也可以就j<=n-i
        {
            if(arry[j]>arry[j+1])
            {
                arry[0] = arry[j];
                arry[j] = arry[j+1];
                arry[j+1] = arry[0];
             }
        }
    }
}

void SelectionSort(int *arry,int n)
{
    int i,j,k;
    for(i=1;i<n;i++)  //注意不可以等与n就比较n-1次就可以第n个元素不在比较就是最后的
    {
        k = i;
        for(j=i+1;j<=n;j++)  //这个必须等于，因为要和全部的元素相比
        {
            if(arry[j]<arry[k])
            {
                k = j;
            }
        }
        if(k!=i)
        {
         arry[0] = arry[k];
         arry[i] = arry[k];
         arry[k] = arry[0];
        }
    }
}

void SelectionSort2(int *arr, int size)
{
    int i, j, k, tmp;
    for (i = 1; i < size; i++) {
        k = i;
        for (j = i + 1; j <= size; j++) {
            if (arr[j] < arr[k]) {
                k = j;
            }
        }
        tmp = arr[k];
        arr[k] = arr[i];
        arr[i] = tmp;
    }
}
void InsertSort(int *arry,int n)
{
    int i,j;
    for(i=2;i<=n;i++)
    {
        if(arry[i]<arry[i-1])
        {
            arry[0] = arry[i];
            for(j=i-1;j>0&&arry[j]>arry[0];j--)
            {
                arry[j+1] = arry[j];
            }
            arry[j+1] = arry[0];
        }
    }
}

int Partition(int *arry,int low,int high)
{
    int i,j;
    i = low;
    j = high;
    while(i<j)  //大前提，必须确保low低于high，当不低于的时候证明找到i
	{
		while(i<j&&arry[i]<arry[j])j--;  //从高端往底端走
		if(i<j)
		{
			arry[0]=arry[i];
			arry[i]=arry[j];
			arry[j]=arry[0];
			i++;
		}
		while(i<j&&arry[i]<=arry[j])i++;  //从底端往高端走
		if(i<j)
		{
			arry[0]=arry[i];
			arry[i]=arry[j];
			arry[j]=arry[0];
			j--;
		}

	}
	return i;

}
void QuickSort(int *arry,int low,int high)
{
	int pivot;  //中间点
	if(low<high)
	{
		pivot = Partition(arry,low,high);
		QuickSort(arry,low,pivot-1);
		QuickSort(arry,pivot+1,high);
	}
}

Sort.h

#include <stdio.h>

void BubbleSort(int *arry,int n);
void SelectionSort(int *arry,int n);
void InsertSort(int *arry,int n);
int Partition(int *arry,int low,int high);
void QuickSort(int *arry,int low,int high);
void SelectionSort2(int *arr, int size);

mian.cpp

#include <iostream>
#include <stdio.h>
#include "Sort.h"

using namespace std;

int main()
{
    int i;
    int a[]={0,45,3,62,85,4,6,9,20,9};
    int *arry = a;
    //BubbleSort(arry,9);
    SelectionSort2(arry,9);
    //InsertSort(arry,9);
    //QuickSort(arry,1,9);
    for(i=1;i<10;i++)
    {
        printf("%d\t",a[i]);
    }
    return 0;
}