1.冒泡排序:
思路:一个数组中,从a[0]到a[n] 遍历的过程中,将此轮最大(最小)的数放在a[n]位置,
下一轮从之前元素的下一个在进行一次遍历,将最大(最小)的数放在a[n]处.
代码:
void Bubble(in a[],int length)
{
for(int i=0;i<length;i++)
{
for(int j=1;j<length-i;j++)
{
if(a[j-1]>a[j])
{
swap(a[j-1],a[j]);
}
}
}
}
2.改进冒泡排序:
思路:在原始冒泡是方式中,判断是否交换,对交换步骤进行了控制,设置了标志量。
代码:
int flag = 0;
void Bubble(in a[],int length)
{
for(int i=0;i<length&&flag==0;i++)
{
flag =1;
for(int j=1;j<length-i;j++)
{
if(a[j-1]>a[j])
{
flag = 0;
swap(a[j-1],a[j]);
}
}
}
}
3.插入排序
思路:将数组a[0]作为一个已经有序的数组,从第二个元素开始,判断大小规则,所做操作:将将当前元素保存到一个临时变量中,然后通过一个循环,条件是当前下标大于等于0,而且临时变量中比他要小(与大小规则一致),就进行交换,否则就将临时变量给当前数组比较元素。
代码:
void insert_sort(int a[],int length)
{
intj=0;
for(inti=1;i<length;i++)
{
if(a[i]<a[i-1])
{
int temp = a[i];
for(j=i-1;j>=0&&temp<a[j];j--)
{
a[j+1] = a[j];
}
a[j+1] = temp;
}
}
}
4.选择排序
思路:一个数组,从开始遍历,假设最小的数下标为0,然后将这个下标暂时保留min,然后从下一个元素进行遍历,如果当前元素小于标记的最小数,则将把这时最小的下标给min,
当内循环结束,判断最小值min !=i; 则交换元素。
代码:
void select_sort(int a[],int length)
{
for(int i=0;i<length;i++)
{
Int min = I;
For(int j=i+1;j<length,j++)
{
If(a[min]>a[j])
{
min = j;
}
}
If(min!=i)
{
swap(&a[min],&a[i]);
}
}
}
5.希尔排序
思路:对数组进行分组,其实,将数组中小标跳跃似地遍历,再配合插入排序的规则,就可以了。分组增量 = 分组增量/3 +1;
代码:
void shell(int a[],int length)
{
Int increase = length;
IntI,j,k;
do{
increase = increase/3+1;
for(i = 0;i<increase;i++)
{
for(j=i+increase;j<length;j+=increase)
{
if(a[j]<a[j-increase])
{
Int temp = a[j];
For(k =j-increase;k>=0&&temp<a[k];k-=increase)
{
a[k+ increase] = a[k];
}
a[k+increase] = temp;
}
}
}
} while(increase >1);
6.快速排序
思路:将数组开始和结束做标记,暂且将最开始元素保存起来temp,比较满足,后坐标向前移动,前坐标,向后移动。不满足条件a[j]给a[i],之后递归解决问题。
void QuickSort(int arr[], int start,intend)
{
inti = start;
intj = end;
inttemp = arr[start];
if(i<j){
while(i<j){
while(i < j && temp <=arr[j]){
j--;
}
if(i<j){
arr[i]= arr[j];
i++;
}
while(i<j && temp > arr[i]){
i++;
}
if(i<j){
arr[j]= arr[i];
j--;
}
}
arr[i] = temp;
QuickSort(arr,start, i - 1);
QuickSort(arr,i+ 1,end);
}
}
7.堆排序
思路:借用堆数据结构,-一个二叉树,父节点要比孩子节点要大(小).
void HeapAdjust(int arr[], int index, intlen){
//先保存当前结点的下标
intmax = index;
//保存左右孩子的数组下标
intlchild = index * 2 + 1;
intrchild = index * 2 + 2;
if(lchild < len && arr[lchild] > arr[max]){
max= lchild;
}
if(rchild < len && arr[rchild] > arr[max]){
max= rchild;
}
if(max != index){
//交换两个结点
MySwap(arr,max, index);
HeapAdjust(arr,max, len);
}
}
//堆排序
void HeapSort(int myArr[], int len){
//初始化堆
for(int i = len / 2 - 1; i >= 0; i--){
HeapAdjust(myArr,i, len);
}
//交换堆顶元素和最后一个元素
for(int i = len - 1; i >= 0; i--){
MySwap(myArr,0, i);
HeapAdjust(myArr,0, i);
}
}
8.并归排序
思路:将数组分为两段,
void Merge(int arr[],int start,int end,int mid,int*temp){
inti_start = start;
inti_end = mid;
intj_start = mid+1;
intj_end = end;
intlength = 0;
while(i_start <= i_end && j_start <= j_end){
if(arr[i_start] < arr[j_start]){
temp[length]= arr[i_start];
length++;
i_start++;
}
else{
temp[length]= arr[j_start];
j_start++;
length++;
}
}
//i这个序列
while(i_start <= i_end){
temp[length]= arr[i_start];
i_start++;
length++;
}
//j序列
while(j_start <= j_end){
temp[length]= arr[j_start];
length++;
j_start++;
}
//辅助空间数据覆盖原空间
for(int i = 0; i < length; i++){
arr[start+ i] = temp[i];
}
}
void MergeSort(int arr[],int start,intend,int *temp){
if(start>=end){
return;
}
intmid = (start + end) / 2;
MergeSort(arr,start,mid,temp);
MergeSort(arr,mid+1, end, temp);
Merge(arr,start,end,mid,temp);
//13 3 4 5 5 6 6 7 7 8 8 8 9 9 9 10 23 23 42 81 87 90 97
}