冒泡插入选择希尔快排归并排序

1.冒泡排序

#include <stdio.h>
#define SIZE 8
 
void bubble_sort(int a[], int n);
 
void bubble_sort(int a[], int n)
{
    int i, 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\n", number[i]);
    }
    return 0;
}

2、选择排序

void selectSort(int arr[],int length)
{
	for(int i=0;i<length;i++){
		int min=i;
		for(int j=i+1;j<length;j++){
			if(arr[j]<arr[min])
				min=j;
		}
		if(min!=i)
			Swap(&arr[min],&arr[i]);
	}
}

3、插入排序

void insertSort(int arr[], int length)
{
	int j = 0;
	//先arr[1]与arr[0]比较
	for (int i = 1; i < length; i++)
	{
		if (arr[i] < arr[i - 1])
		{
			int temp = arr[i];//保存小于前面的值
			for (j = i - 1; j >= 0 && temp < arr[j]; j--)
			{
				arr[j + 1] = arr[j];//temp前面的值，向右移动，j向左移动
			}
			arr[j+1] = temp;//j=-1或temp大于前面的值
		}
	}

}

4、希尔排序
先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）
分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序
（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基
本有序的情况下（接近最好情况），效率是很高的，

//先分组再进行插入排序
void shellSort(int arr[], int length)
{
	int delt = length;
	int k = 0;
	
	do {
		delt = delt / 3 + 1;//arr[i]、arr[i+delt]、arr[i+2*delt]····为一组
		for (size_t i = 0; i < delt; i++)
		{
			for (int j = i+ delt; j < length; j+= delt)
			{
				if (arr[j] < arr[j - delt])
				{
					int temp = arr[j];
					for (k = j - delt; k>= 0 && temp < arr[k]; k-= delt)
					{
						arr[k + delt] = arr[k];
					}
					arr[k + delt] = temp;
				}
			}
		}
	} while (delt>1);

}

5.快速排序
原理

/**快速排序**/
//以第一个数为基准，获得分段后基准数的索引
int PartionIndex(int data[], int left, int right)
{
	
	int l = left;
	int r = right;
	int key = data[left];//第一个分割值
	while (l < r)
	{
		while (l <r && key <= data[r])
		{
			r--;/*向左寻找小于key*/
		}

		data[l] = data[r];
					

		while (l < r && key >= data[l])
		{
			l++;/*向右寻找大于key*/
		}
		data[r] = data[l];//交换
					
	}
	data[l] = key;//完成分段，此时l=r

	return l;
}

void fastSort(int data[], int left,int  right)
{
	if (left == right)
		return;
	int index = PartionIndex(data, left, right);
	
	//index=left时，第一个数为基准值且为最小值，只需对后面的数进行处理
	if(index>left)
		fastSort(data,left,index-1);
	if(index<right)
		fastSort(data,index+1,right);

}

6、归并排序

//将子数组排序合并
void Merge(int sourceArr[],  int startIndex, int midIndex, int endIndex)
{
	int *aux=new int[endIndex - startIndex + 1];
	for (int k = startIndex; k <= endIndex; k++)
		aux[k - startIndex] = sourceArr[k];//辅助数组
	
	int left = startIndex;
	int right = midIndex + 1;
	for (int k = startIndex; k <= endIndex; k++)
	{
		if (left>midIndex)
		{
			sourceArr[k] = aux[right - startIndex];
			right++;
		}
		else if (right>endIndex)//右子数组均比左子数组小，将右子数组全部放在左子数组后面
		{
			sourceArr[k] = aux[left - startIndex];
			left++;
		}
		else if (aux[left - startIndex]>aux[right - startIndex])//右边的小
		{
			sourceArr[k] = aux[right - startIndex];
			right++;
		}
		else//左边的小
		{
			sourceArr[k] = aux[left - startIndex];
			left++;
		}
	}
	delete[] aux;
}

//内部使用递归
void MergeSort(int sourceArr[], int startIndex, int endIndex)
{
	if (startIndex >= endIndex)
		return;

	int midIndex = (startIndex + endIndex) / 2;//避免溢出
		//拆分
	MergeSort(sourceArr, startIndex, midIndex);
	MergeSort(sourceArr, midIndex + 1, endIndex);
	Merge(sourceArr, startIndex, midIndex, endIndex);//分为两个数传入startIndex + 1 == endIndex
}