排序算法和查找算法

整理了一下关于排序和查找的算法,还不全，以后有用到再补充：

//插入排序--直接插入排序法
//个人理解：分为有序和无序两段，有序段从1开始，每次取无序段的第一个数，
//在有序段中通过比较找到插入位置（有序段也在比较同时进行移动），插入，
//每次有序段增加1，无序段减少1
void InsertSort(int A[],int n)
{
int x;
int i,j;
for(i=1;i<n;i++)//i表示插入次数，共进行n-1次插入
{
x=A[i];//暂存待插入有序表中的元素A[i]的值
for(j=i-1;j>=0;j--)
{
if(x<A[j])
A[j+1]=A[j];//进行顺序比较和移动
else
break;//查询到j+1位置时离开j循环
}
A[j+1]=x;//把原A[i]的值插入到下标为j+1的位置
}

}

//插入排序--希尔排序法
//个人理解：直接插入排序的改进版，把序列分成d段，0、d、2d...一组，1、1+d、1+2d...一组...
//d、2d-1、3d-1...分别在各组内进行直接插入排序，然后d/=2，重复，直到d<1
void ShellSort(int A[],int n)
{
int x;
int i,j,d;
for(d=n/2;d>=1;d/=2)
{
for(i=d;i<n;i++)//按不同的分量进行排序
{
x=A[i];//将A[i]元素直接插入到对应分组的有序表中
for(j=i-d;j>=0;j-=d)
{
if(x<A[j])//在组内向前顺序进行比较和移动
A[j+d]=A[j];
else
break;//查找到合适的位置就退出循环
}
A[j+d]=x;//将A[i]的值放入到合适位置
}
}
}


//选择排序--直接选择排序
//个人理解：依次进行n、n-1、n-2……1次的n-1轮比较，每轮以第1个为基准进行比较，交换最小
//值的标号，一轮比较结束后，若最小值不是第1个，交换。
void SelectSort(int A[],int n)
{
int x;
int i,j,k;
for(i=1;i<n;i++)//i表示计数，共进行n-1次选择和交换
{
k=i-1;//用k保存当前最小排序码元素的下标，初值为i-1
for(j=i;j<n;j++)
{//从当前排序区间中顺序查找出具有最小排序码的元素A[k]
if(A[j]<A[k])
k=j;
}
if(k != i-1)
{//把A[k]对调到该排序区间的第1个位置，即i-1位置
x=A[i-1];
A[i-1]=A[k];
A[k]=x;
}
}
}


//交换排序--气泡排序
//个人理解：通过n-1趟的比较实现，每一趟都是将相邻的元素进行比较，将本趟中
//最小（或最大）数逐位前移。
void BubbleSort(int A[],int n)
{
int x;
int i,j,flag;
for(i=1;i<n;i++)//i表示趟数，最多进行n-1趟
{
flag=0;//flag表示每一趟是否有交换
for(j=n-1;j>=i;j--)//进行第i趟排序
{
if(A[j]<A[j-1])
{
x=A[j-1];
A[j-1]=A[j];
A[j]=x;
flag=1;//置1表示有交换
}
}
if(flag == 0)//进行一趟后若无交换则排序完成应返回
return;
}
}


//交换排序--快速排序
//个人理解：选择基准元素（一般取第1个元素），从两端向中间，将从前往后遍历的大于基准元
//素的元素和从后往前遍历的小于基准元素的元素互换，最后边界处插入基准元素，前后区间再分
//别重复直到当其中区间为空或只包含一个元素。用递归算法。
void QuickSort(int A[],int s,int t)
{
int i=s+1,j=t;//给i和j赋初值
int x=A[s];//把基准元素的值暂存x中
while(i<=j)
{
while(A[i]<=x && i<=j)
i++;//从前向后顺序比较
while(A[j]>=x && j>=i)
j--;//从后向前顺序比较
if(i<j)
{//当条件成立时交换A[i]和A[j]的值
int temp=A[i];
A[i]=A[j];
A[j]=temp;
i++;
j--;
}
}
//交换A[s]和A[j]的值，得到前后两个子区间A[s]~A[j-1]和A[j+1]~A[t]
if(s != j)
{
A[s]=A[j];
A[j]=x;
}
//在当前左区间内超过一个元素的情况下递归处理左区间
if(s<j-1)
QuickSort(A,s,j-1);
//在当前右区间内超过一个元素的情况下递归处理右区间
if(j+1<t)
QuickSort(A,j+1,t);
}


//顺序查找
int Seqsch(int A[],int n,int k)
{
int i;
for(i=0;i<n;i++)
{
if(A[i] == k)
break;
}
if(i<n)
return i;
else
return -1;
}


//二分查找(递归)
int Binsch(int A[],int low,int high,int k)
{
if(low<=high)
{
int mid=(low+high)/2;
if(k == A[mid])
return mid;
else if(k<A[mid])
return Binsch(A,low,mid-1,k);
else
return Binsch(A,mid+1,high,k);
}
else
return -1;
}


//二分查找（非递归）
int Binsch(int A[],int n,int k)
{
int low=0,high=n-1;
while(low<=high)
{
int mid=(low+high)/2;
if(k == A[mid])
return mid;
else if(k<A[mid])
high=mid-1;
else
low=mid+1;
}
return -1;
}