排序算法总结

///
// 插入排序
void insertSort(int arr[], int n)
{
	for(int i = 1; i < n; i ++)
	{
		int key = arr[i];
		int j = i - 1;
		while(j >= 0 && arr[j] > key)
		{
			arr[j + 1] = arr[j];
			j --;
		}
		arr[j + 1] = key;
	}
}
//
// 希尔插入
void shellInsert(int arr[], int d, int n)
{
	for(int i = d; i < n; i ++)
	{
		int key = arr[i];
		int j = i - d;
		while(j >= 0 && arr[j] > key)
		{
			arr[j + d] = arr[j];
			j -= d;
		}
		arr[j + d] = key;
	}

}
void shellSort(int arr[], int n)
{
	int d = n / 2;
	while(d >= 1)
	{
		shellInsert(arr, d, n);

		d /= 2;
	}
}
///
// 冒泡排序
void swap(int x, int y, int arr[]) 
{
	int temp = arr[x];
	arr[x] = arr[y];
	arr[y] = temp;

}

void bubbleSort1(int arr[], int n)
{
	for(int i = 0; i < n; i ++)
	{

		for(int j = 0; j < n - i; j ++)
		{
			if(arr[j] > arr[j + 1])
			{
				swap(j, j + 1, arr);
			}
			
		}
	}
		
}

void bubbleSort2(int arr[], int n)
{
	int flag = true; // 初始标志， 1
	for(int i = 0; i < n && flag; i ++)// 若上一轮存在数据交换，继续执行排序
	{
		
		flag = false; // 每一轮初始，交换标志为0
		for(int j = 0; j < n - i; j ++)
		{
			if(arr[j] > arr[j + 1])
			{
				swap(j, j + 1, arr);
				flag = true; // 存在交换，标志位1
			}
			
		}
	}

}

void bubbleSort3(int arr[], int n)
{
	int flag = n;
	int k;
	while(flag > 0)
	{
		k = flag;
		flag = 0;
		for(int j = 0; j < k; j ++)
		{
			if(arr[j] > arr[j + 1])
			{
				swap(j, j + 1, arr);
				flag = j + 1; // flag记录本轮最后一个发生交换的位置，后面的都排好序了
			}
		}
		
	}
}

void bubbleSort4(int arr[], int n)
{

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

			if(arr[j] < arr[j - 1])
			{

				swap(j - 1, j, arr);
			}
		}
	}
}
/
// 快速排序
int partition(int arr[], int start, int end)
{
	if(arr == NULL || end < 0 || start < 0 || start > end)
	{
		throw new exception("Invalid Parameters");
	}
	
	int i = start;
	int j = end;
	int x = arr[start];

	while(i < j)
	{
		while(i < j && arr[j] >= x ) // 从右向左找第一个小于X的数
		{
			j --;
		}
		if(i < j)
		{
			arr[i] = arr[j];
			i ++;
		}

		while(i < j && arr[i] <= x)
		{
			i ++;
		}
		if(i < j)
		{
			arr[j] = arr[i];
			j --;
		}
	}
	arr[i] = x;

	return i;
}

void quickSort(int arr[], int start, int end)
{
	if(start < end)
	{
		int index = partition(arr, start, end);
		quickSort(arr, start, index - 1);
		quickSort(arr, index + 1, end);
	}
}
//快速排序 整理
void quick_sort(int s[], int l, int r)
{
    if (l < r)
    {
		//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
        int i = l, j = r, x = s[l];
        while (i < j)
        {
            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
				j--;  
            if(i < j) 
				s[i++] = s[j];
			
            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
				i++;  
            if(i < j) 
				s[j--] = s[i];
        }
        s[i] = x;
        quick_sort(s, l, i - 1); // 递归调用 
        quick_sort(s, i + 1, r);
    }
}

//
// 直接选择排序
void selectSort(int a[], int n)
{
	int k; // 记录最小关键字所在的位置
	for(int i = 0; i < n; i ++)
	{
		k = i;
		for(int j = i; j < n; j ++)
		{
			if(a[j] < a[k])
			{
				k = j;
			}
		}
		if(k != i)
		{
			swap(i, k, a);
		}
	}
}


// 堆排序
void heapSort(int arr[], int n)
{

}

///
// 归并排序
/*
** 合并两个子数组序列，以mid为中间点，start，end为前后界限，分割成两个子序列
*/
void merge(int arr[], int start, int mid, int end, int *tempArr)
{
	int lStart = start; // 左边序列的起始索引号
	int lEnd = mid; // 左边序列的最后索引号
	int rStart = mid + 1;//右边序列的起始索引号
	int rEnd = end;//右边序列的起始索引号

	int k = 0; // 两个子序列元素个数之和
	while(lStart <= lEnd && rStart <= rEnd) // 子序列遍历完了退出循环
	{
		if(arr[lStart] <= arr[rStart])
		{
			tempArr[k ++] = arr[lStart ++];
		}
		else
		{
			tempArr[k ++] = arr[rStart ++];
		}
	}
	while(lStart <= lEnd)
	{
		tempArr[k ++] = arr[lStart ++];
	}
	while(rStart <= rEnd)
	{
		tempArr[k ++] = arr[rStart ++];
	}

	for(int i = 0; i < k; i ++)
	{
		arr[start + i] = tempArr[i];
	}
}
void mergeSort(int arr[], int start, int end, int *tempArr)
{
	if(end > start)
	{
		int mid = start + (end - start)/ 2;
		mergeSort(arr, start, mid, tempArr); // 左边序列排序
		mergeSort(arr, mid + 1, end, tempArr); // 右边序列排序
		merge(arr, start, mid, end, tempArr);  // 合并两个序列

	}
}


// 基数排序
/** 找到num的从低到高的第POS位的数据
*** num: 一个整形数据
*** pos: 表示要获取的整形的第POS位数据，从低位到高位
**/
int getNumInPos(int num, int pos)
{
	int temp  = 1;
	for(int i = 0; i < pos - 1; i ++)
	{
		temp *= 10;
	}

	return (num / temp) % 10;
}

/**
*** 基数排序
*** pDataArry 无序数组
*** iDataNum 无序数组的数据个数
**/
#define RADIX_10 10 // 整形排序
#define KEYNUM_31 10 // 关键字个数，这里为整形为数
void radixSort(int *pDataArray, int iDataNum)
{
	int *radixArrays[RADIX_10]; // 分别为0-9的序列空间
	for(int i = 0; i < 10; i ++)
	{
		radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
		radixArrays[i][0] = 0; 
	}

	for(int pos = 1; pos < KEYNUM_31; pos ++) // 从个位开始到31位
	{
		for(int i = 0; i < iDataNum; i++) // 分配过程
		{
			int num = getNumInPos(pDataArray[i], pos);
			int index = ++radixArrays[num][0];
			radixArrays[num][index] = pDataArray[i];
		}
	}

	int j;
	for(j = 0, i = 0; i < RADIX_10; i ++) // 收集
	{
		for(int k = 1; k <= radixArrays[i][0]; k ++)
		{
			pDataArray[j ++] = radixArrays[i][k];
		}
		radixArrays[i][0] = 0; // 复位
	}
}