七种排序总结及代码实现

版权声明：本文为博主原创文章，未经博主允许，欢迎随意转载，标好作者+原文地址就可以了！感谢欣赏！觉得好请回个贴！

笔记：

#include <stdio.h>

//几种常见的排序与查找算法

//		ONE    直接插入排序
//直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，
//如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。

//1.1外部作为存储地（监视哨）
void DirectSort(int* Arr, int n)  //n为数组Arr元素个数
{
	int j, temp;  //temp作为存储地（监视哨）
	for (int i = 1; i < n;i++)
		{
			temp = Arr[i];  //保存Arr[i]的值
			for (j = i - 1; temp<Arr[j];j--)
			{
					Arr[j + 1] = Arr[j];
			}
			Arr[j + 1] = temp;
		}
}
int main()
{
	int  Arr[] = { 1, 56, 32, 25, 48, 26, 45, 79, 13, 45 };
	int n = sizeof(Arr) / sizeof(int);
	DirectSort(Arr,n);
	for (int i = 0; i < n; i++)
		printf("%d ",Arr[i]);
	return 0;
}




//1.2数组第一个元素作为存储地（监视哨）
int main(char argc, char **argv)
{
	int i, j, n;
	int array[7] = { 0,3, 5, 7, 1, 0, 8 };//array[0]  不能使用
	n = sizeof(array) / sizeof(int);
	for (i = 2; i < n; i++)
	{
		array[0] = array[i];
		for (j = i - 1; array[0] < array[j]; --j)
		{
			array[j + 1] = array[j];
		}
		array[j + 1] = array[0];
	}


	for (i = 1; i<n; i++)
		printf("%d ", array[i]);
	return 0;

}



//  		TWO           希尔排序
//希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；
//随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
//希尔排序是基于插入排序的一种算法
#include<stdio.h>
#include<math.h>

#define MAXNUM 10

//根据当前增量进行插入排序
void shellInsert(int array[], int n, int dk)
{
	int i, j, temp;
	for (i = dk; i<n; i++)//分别向每组的有序区域插入
	{
		temp = array[i];
		for (j = i - dk; (j >= i%dk) && array[j]>temp; j -= dk)//比较与记录后移同时进行
			array[j + dk] = array[j];
		if (j != i - dk)
			array[j + dk] = temp;//插入
	}
}

//计算Hibbard增量
int dkHibbard(int t, int k)
{
	return (int)(pow(2, t - k + 1) - 1);
}

//希尔排序
void shellSort(int array[], int n, int t)
{
	void shellInsert(int array[], int n, int dk);
	int i;
	for (i = 1; i <= t; i++)
		shellInsert(array, n, dkHibbard(t, i));
}

void main()
{
	void shellSort(int arrayay[], int n, int t);//t为排序趟数
	int arrayay[MAXNUM], i;
	for (i = 0; i<MAXNUM; i++)
		scanf("%d", &arrayay[i]);
	shellSort(arrayay, MAXNUM, (int)(log(MAXNUM + 1) / log(2)));//排序趟数应为log2(n+1)的整数部分
	for (i = 0; i<MAXNUM; i++)
		printf("%d ", arrayay[i]);
	printf("\n");
}



//第2种
//增量为t = n/2  其中n为数组元素个数

void shellSort(int Arr[], int n)
{
	int t;
	for (t = n / 2; t >= 1; t = t / 2)
	{
		int j, temp;  //temp作为存储地（监视哨）
		for (int i = t; i < n; i++)
		{
			temp = Arr[i];  //保存Arr[i]的值
			for (j = i - t;( j>=i%t)&&temp<Arr[j]; j-=t)
				Arr[j + t] = Arr[j];
			if (j != i - t) 
				Arr[j + t] = temp;  
		}
	}
}
int main()
{
	int  Arr[] = { 1, 56, 32, 25, 48, 26, 45, 79, 13, 45 };
	int n = sizeof(Arr) / sizeof(int);
	shellSort(Arr, n);
	for (int i = 0; i < n; i++)
		printf("%d ", Arr[i]);
	return 0;
}


//交换排序

// THREE    冒泡排序

void BubbleSort(int* array, int n) //n为数组元素个数
{
	int temp;     //临时变量
	for (int i = 0; i < n - 1;i++)
	{
		for (int j = 0; j < n -1- i; j++)
		{
			if (array[j]>array[j + 1])
			{
				temp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = temp;
			}
		}
	}
}
int main()
{
	int  Arr[] = { 1, 56, 32, 25, 48, 26, 45, 79, 13, 45 };
	int n = sizeof(Arr) / sizeof(int);
	BubbleSort(Arr,n);
	for (int i = 0; i < n; i++)
		printf("%d ", Arr[i]);
	return 0;
}


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

void quickSort(int*  array, int left, int right)  //left为分组最低的元素下标，
													//right为分组最高的元素下标
{
	if (left < right) //左右不等则还未遍历完
	{
		int pivot = array[left]; //以分组第一个元素为键
		int low = left;
		int high = right;
		while (low < high)
		{
			while (low < high && array[high] >= pivot)
			{
				high--;
			}
			array[low] = array[high];
			while (low < high && array[low] <= pivot)
			{
				low++;
			}
			array[high] = array[low];
		} //183行到本行为第一次排序完成
		array[low] = pivot; 	//array[high] = pivot; //把键值放到中间区分左右分组
		quickSort(array, left, high - 1);//以相同方法排序左边分组 
		quickSort(array, low + 1, right);//以相同方法排序右边分组
	}
}
int main()
{
	int  Arr[] = { 1, 56, 32, 25, 48, 26, 45, 79, 13, 45 };
	int n = sizeof(Arr) / sizeof(int);
	quickSort(Arr, 0,n-1);
	for (int i = 0; i < n; i++)
		printf("%d ", Arr[i]);
	return 0;
}

非递归实现快速排序 
void QuickSortNoneR(int* a,int left,int right)
{
	assert(a);
	stack<int> s;//创建一个栈
	s.push(right);
	s.push(left);
 
	while(!s.empty())
	{
		int start = s.top();//先取左边界
		s.pop();
		int end = s.top();//再取右边界
		s.pop();
		//int div = PartSort1(a,start,end);
		//int div = PartSort2(a,start,end);
		int div = PartSort3(a,start,end);
 
		if (start < div-1)
		{
			s.push(div - 1);
			s.push(start);
		}
		if (end > div+1)
		{
			s.push(end);
			s.push(div + 1);
		}
	}
}


//选择排序

//  FIVE 直接选择排序
//第一次从R[0]~R[n-1]中选取最小值，与R[0]交换，第二次从R[1]~R[n-1]中选取最小值，与R[1]交换，....，
//第n-1次从R[n-2]~R[n-1]中选取最小值，与R[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

void selectSort ( int* array,int n)
{
	int i, j, index;
	for ( i = 0; i < n; i++)
	{
		index = i;
		for ( j = i+1; j < n; j++)
		{
			if (array[j]<array[index])
				index = j;
		}
		if (index != i)
		{
			int temp = array[i];
			array[i] = array[index];
			array[index] = temp;
		}
	}
}
int main()
{
	int  Arr[] = { 1, 56, 32, 25, 48, 26, 45, 79, 13, 45 };
	int n = sizeof(Arr) / sizeof(int);
	selectSort(Arr,n);
	for (int i = 0; i < n; i++)
		printf("%d ", Arr[i]);
	return 0;
}

//SIX 二叉堆排序
/*Heap函数：从i下标开始使i下标后所有的数满足父大于子这一特性*/

void Heap(int * array, int i,int size)//i为父节点，size二叉树节点个数
{
	if (i < size)  //防止父节点超过数组总个数
	{
		int maxindex = i;
		int left = 2 * i + 1, right = 2 * i + 2;

		if (left < size && array[maxindex] < array[left]) maxindex = left;
		if (right < size && array[maxindex] < array[right]) maxindex = right;
		if (maxindex != i)
		{
			int temp = array[maxindex];
			array[maxindex] = array[i];
			array[i] = temp;
			Heap(array, maxindex, size); //递归调用，使交换后的子树叶也满足父大于子
		}
	}
}
void max_heap(int* array, int size) //size该数组元素个数
{
	for (int j = size - 1; j >= 0; j--)
	{
		Heap(array, j, size);
	}
}

void HeapSort(int* array, int size)//size该数组元素个数
{

	for (int i = size-1; i >= 0; i--)
	{
		max_heap(array, i);
		int temp = array[0]; //进行一次筛选后，把最大值与无序的最后一个数值进行交换
		array[0] = array[i];
		array[i] = temp;
	}
}

int main()
{
	int  Arr[] = { 1, 56, 32, 25, 48, 26, 45, 79, 13, 45 };
	int n = sizeof(Arr) / sizeof(int); //元素个数
	HeapSort(Arr, n);
	for (int i = 0; i < n; i++)
		printf("%d ", Arr[i]);
	printf("\n");
	return 0;
}


//SEVEN 归并排序

//归并排序是一种比较占内存，但却效率高且稳定的算法
//指的是将两个顺序序列合并成一个顺序序列的方法

#define MAX_SIZE 100  //中间变量的空间大小
int merging(int* list_f,int f_size,int* list_r, int r_size)  //对list_f和list_r中的元素排序，
															//并最终保存到list_f中
{
	int f ,r ,k ;
	int temp[MAX_SIZE] = {0};
	f = r = k = 0;
	while (f < f_size &&r < r_size)
	{
		if (list_f[f] < list_r[r])
			temp[k++] = list_f[f++];
		else
			temp[k++] = list_r[r++];
	}
	if (f<f_size)
	{
		while (f <= f_size)
			temp[k++] = list_f[f++];
	}
	if (r<r_size)
	{
		while (r<= r_size)
			temp[k++] = list_r[r++];
	}
	for (k = 0; k<f_size + r_size; k++) //把temp[]赋值到list_f[]中
	{
		list_f[k] = temp[k];
	}
	return 0;
}
int mergeSort(int* Array, int size) //size 为数组的元素的个数  
{
	if (size > 1)
	{
		int* list_f = Array;
		int f_size = size / 2;
		int* list_r = Array + size / 2;
		int r_size = size - f_size;
		mergeSort(list_f,f_size);
		mergeSort(list_r, r_size);
		merging(list_f, f_size, list_r, r_size);//把数组位变为有序排列 并保留到list_f中
	}
	return 0;
}
int main()
{
	int  Arr[] = { 1, 56, 32, 25, 48, 26, 45, 79, 13, 45 };
	int n = sizeof(Arr) / sizeof(int);
	mergeSort(Arr, n);
	for (int i = 0; i < n; i++)
		printf("%d ", Arr[i]);
	return 0;
}