排序算法

最新推荐文章于 2024-09-12 15:56:42 发布

原创最新推荐文章于 2024-09-12 15:56:42 发布 · 475 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #iterator #merge #c

算法专区专栏收录该内容

20 篇文章

订阅专栏

本文详细介绍并实现了多种排序算法，包括冒泡排序、插入排序、选择排序、希尔排序、归并排序及快速排序等。每种算法都附带了详细的解释与代码实现。

#include<stdio.h>
#include<malloc.h>
#define SIZE 10
void printArray(int A[SIZE]);
void PopSort( int A[SIZE]);
void InsertSort( int A[SIZE] );
void ChooseSort( int A[SIZE] );
void ShellSort( int A[SIZE] );
void ShellSortPro(int A[SIZE],int add);
void Insertsort3(int A[], int n);
void MergeSort(int A[SIZE],int b,int e);
void Merge(int A[SIZE], int b,int m,int e);

void QuickSort(int A[SIZE],int left,int right);

void main()
{
int A[10] = {0,1,6,3,9,5,6,7,8,4};
int i = 1,j=1;
ChooseSort(A);
PopSort(A);
InsertSort(A);
ShellSort(A);
MergeSort(A,0,9);
printArray(A);

}
/************************************************************打印数组信息****************************************************/
void printArray(int A[SIZE])
{
int counter;//计数器
for( counter = 0; counter < SIZE ; counter++ )
{
printf("%d ",A[counter]);
}
printf("\n");
}

/****************************************冒泡排序算法*******************************************/
void PopSort( int A[SIZE])
{
int ControlTimes=0;//控制外层循环次数
int Current=0;//当前数字序号
int flag = 0; //当一次没有任何交换也可让循环停止

    for(ControlTimes = 0; ControlTimes < SIZE-1; ControlTimes++)
{
  for(Current = 0; Current < SIZE- ControlTimes -1;Current++)
  {
   if(A[Current]>A[Current+1])
   {
    A[Current]^=A[Current+1];
    A[Current+1]^=A[Current];
                A[Current]^=A[Current+1];
    flag += 1;
   }
  }
  if(flag==0)
   break;
  else
   flag = 0;
}
}

/*******************************************************插入排序算法***************************************************/

//插入排序思想:第2到n个元素分别作为key值,每个值作为key值之前，它前面的元素是有序的，只需要将key值插入到合适位置
void InsertSort( int A[SIZE] )
{

int count = 0;//当前已经循环到的关键字序号
    int key = 0;//存当前关键字
int compare = 0;//之前元素的迭代比较

for( count = 1; count < SIZE ; count ++ )
{

  key = A[count];
  compare = count-1;
  while(compare>=0)
  {
   if(key < compare)
   {
    A[compare]^=A[compare+1];
    A[compare+1]^=A[compare];
    A[compare]^=A[compare+1];
    compare--;
   }else
    break;
  }

  A[compare+1] = key;

}

}

/******************************************************选择排序算法(不稳定)******************************************************/

//选择排序思想:每次选出最小元素按顺序与当前未排序的第一个元素交换。

void ChooseSort( int A[SIZE] )
{
int min = 0; //最小值的序号
int sorted = 0;//控制循环
int iterator = 0;//遍历当前位之后的元素

for( sorted = 0; sorted < SIZE-1 ; sorted++ )
{
  min = sorted ;
  iterator = sorted;
  while(iterator < SIZE )
  {
   if(A[min]>A[iterator])
   {
    min = iterator;
   }
   iterator++;

  }
  if(min != sorted )
  {
   A[min] = A[min] + A[sorted];
   A[sorted] = A[min] - A[sorted];
   A[min] = A[min] - A[sorted];

  }

}

}

/**********************************************希尔排序算法********************************************************************/

//算法思想:据逆序数原理(排序后的逆序数为0),希尔排序是简单插入排序的变形,设有增量，每一组的相应位置进行插入排序

// 希尔排序的增量:增量大小可自定,但最后增量必须减小为1.两个比较好的建议:增量减少为原来2/3较好，增量不为倍数.d=d/3+1;

void ShellSort( int A[SIZE] )
{
int dataAdd[] = {4,2,1};
int i = 0;
for( i = 0; i < 3; i++ )
ShellSortPro(A,dataAdd[i]);

}

void ShellSortPro(int A[SIZE],int add)
{
int key = 0;//关键字
int iterator;//遍历后面元素
int count = 0; //控制循环
    int innerCount = 0;//内部处理排序
for(count=0;count < add; count++)
{
  for(innerCount = count ; innerCount < SIZE;innerCount+=add )
  {
   key = A[innerCount];
   iterator = innerCount - add;
   while(iterator>=0)
   {
    if(key < A[iterator])
    {
     A[iterator] = A[iterator] + A[iterator+add];
     A[iterator+add] = A[iterator] - A[iterator+add];
     A[iterator] = A[iterator] - A[iterator+add];
     iterator -= add;
    }else
     break;
   }
   A[iterator+add] = key;
  }
}

}

/**************************************归并排序算法****************************************************************************/

归并排序思想:将序列分为两份，每份同样递归下去，之后对每份排好序的数进行合并

void MergeSort(int A[10], int p,int r)
{

int q=(p+r)/2;
if(p<r)
{

  MergeSort(A,p,q);
  MergeSort(A,q+1,r);
}

Merge(A,p,q,r);
}

void Merge(int A[10],int p,int q, int r)
{
int i= 0;
int count = p;
int count1 = 0;
int count2 = 0;

int Size1 = q-p+1;
int Size2 = r - q ;
int B[50];
int C[50];

for(i=0; i < Size1; i++)
{
  B[i] = A[i+p];
}
for( i = 0; i < Size2;i++)
{

  C[i] = A[i+q+1];
}

while(count1 < Size1 && count2<Size2)
{
  if(B[count1]<C[count2])
  {
   A[count] = B[count1];
   count++;
   count1++;
  }
  else
  {
   A[count] = C[count2];
   count++;
   count2++;
  }
}

while(count1 < Size1)

{
  A[count] = B[count1];
  count++;
  count1++;
}

while(count2 < Size2)
{
  A[count] = C[count2];
  count++;
  count2++;
}

}