C语言算法基础

1、时间复杂度：一个算法的花费时间的长短和算法中语句执行次数成正比，时间频度（执行次数）记作T(n)，n是问题规模，时间复杂度是指算法执行的计算工作量。设T(n)和f(n)是同一量级，T(n)=O(f(n))，称O(f(n))为时间复杂度。若时间频度为常数，时间复杂度为O(1)，时间频度不同，时间复杂度也可能相同。如果算法的执行时间不随问题规模n的变大而变长，则时间复杂度永远是常数，只是可能是一个比较大的常数。对于步进循环语句，只计算循环体内的语句的执行次数。

2、空间复杂度：是指算法在计算机内执行所需的存储空间的度量。记作S(n)=O(f(n))。

3、冒泡排序：重复走访一个数列，一次比较两个元素，如果顺序错误就把它们交换过来。最后，大的元素会慢慢浮到数列的顶端。冒泡排序的最好情况下的时间复杂度是O(n)，最差情况下的时间复杂度和平均时间复杂度是O(n2)。冒泡排序是稳定的算法，即相同元素不会调换位置。

#include<stdio.h> //冒泡排序按从小到大的顺序排
void bubble_sort(int x[],int n); //声明冒泡排序函数
int main()
{
int k,size=8;
int a[]={34,5,2,5,64,8,44,5};
bubble_sort(a,size);
for(k=0;k<size;k++)
{
printf("%d  ",a[k]);
}
printf("\n");
getchar();
}
void bubble_sort(int x[],int n)
{
int i,j;
for(i=0;i<n-1;i++)  //定义计数器
{
for(j=0;j<n-1-i;j++)
{
int temp;
if(x[j]>x[j+1])  //交换数组元素的值
{
temp=x[j];
x[j]=x[j+1];
x[j+1]=temp;
}
}
}
}

4、选择排序算法：此算法的基本实现是寻找最小的元素放在第一位，再寻找次小的元素放于第二位，一次类推，直到从小到大排序完成为止。每一次的寻找都要让某个位置上的元素和其它所有的元素比较大小。时间复杂度是O(n2)。

#include<stdio.h> //选择排序
void select_sort(int *a,int n); //声明选择排序函数
int main()
{
int x[]={3,56,4,9,34,2,64};
int *p=x,k;
select_sort(p,7);
for(k=0;k<7;k++)
{
printf("%d ",x[k]);
}
getch();
}
void select_sort(int *a,int n)
{
register int min,i,j;
for(i=0;i<n-1;i++)
{
min=i; //找最小值
for(j=i+1;j<n-1;j++)
{
if(a[min]>a[j])
{
min=j;
}
}
if(min!=i)
{
int temp;
temp=a[i];
a[i]=a[min];
a[min]=temp;
}
}
}

5、插入排序法：在已有的有序数列中插入一个无序数列，将无序序列的元素依次和有序数列的最后一个元素开始的所有元素比较，如果小于等于有序序列的某个元素，则加入到这个元素的前面，如此循环直到全部完成插入。时间复杂度是O(n2)，空间复杂度O(1)。

#include<stdio.h>  //插入排序(从小到大排)，已经排好序的数列插入未排好序的数列，定义两个数列，后者插入前者
void Insert_sort(int a[],int b[],int m,int n);//声明两个数组，将后者插入前者之中，n是后者的元素个数
int main()
{
int x[10]={1,3,6,7,23,45,78};
int y[3]={5,2,10};
int k;
Insert_sort(x,y,7,3);
for(k=0;k<10;k++)
{
printf("%d ",x[k]);
}
getch();
}
void Insert_sort(int a[],int b[],int m,int n)
{
int i,j;  //i,j分别是插入元素的计数器和被插入元素的计数器
for(i=0;i<n;i++)
{
for(j=m+i;j>0&&a[j-1]>b[i];j--)
{
a[j]=a[j-1];
}
a[j-1]=b[i];
}
}

6、归并排序：将两个有序数列合并起来排序，时间复杂度是O(nlogn)，空间复杂度是O(n)。

#include<stdio.h> //合并排序从小到大排序 ,两个数组都是排好序的
int main()
{
void merge_sort(int a[],int b[],int c[],int m,int n); //m,n为数组元素的个数
int x[7]={1,3,5,6,9,32,65};
int y[5]={4,7,43,56,76};
int z[12];
merge_sort(x,y,z,7,5);
int p;
for(p=0;p<12;p++)
{
printf("%d ",z[p]);
}
getch();
}
void merge_sort(int a[],int b[],int c[],int m,int n)
{
int i=0,j=0,k=0;
while(i<m && j<n)
{
if(a[i]<b[j])
{
c[k]=a[i];
i++;
}
else
{
c[k]=b[j];
j++;
}
k++;
}
while(i<m)
{
c[k]=a[i];
i++;
k++;
}
while(j<n)
{
c[k]=b[j];
j++;
k++;
}
}

7、线性查找算法：时间复杂度为O(n)。

#include <stdio.h> //线性查找算法
int main(int argc, char *argv[])
{
int find(int a[],int key,int n);
int x[8]={12,4,5,6,3,23,53,90};
char str1[]="Don't exit the number!";
char str2[]="Congratulations!";
int y=find(x,23,8);
if(y==-1)
{
printf("%s",str1);
}
else
{
printf("%s",str2);
}
getch();
}
int find(int a[],int key,int n)
{
int i;
for(i=0;i<n;i++)
{
if(key==a[i])
{
return i;
}
}
if(i==n)
{
return -1;
}
}

8、二分查找算法：时间复杂度为O(log n)。

#include <stdio.h> //二分查找算法 (排好序的数列)
int main(int argc, char *argv[])
{
int b_find(int a[],int key,int n);
int x[8]={1,4,5,6,13,23,53,90};
char str1[]="Don't exit the number!";
char str2[]="Congratulations!";
int y=b_find(x,2,8);
if(y==-1)
{
printf("%s",str1);
}
else
{
printf("%s",str2);
}
getch();
}
int b_find(int a[],int key,int n)
{
int p,q,m;
p=0;  //p是第一个元素的下标，q是最后一个元素的下标
q=n-1;
while(p<=q)
{
m=(p+q)/2;
if(a[m]==key)
{
return m;
}
else if(a[m]>key)
{
q=m-1;
}
else
{
p=m+1;
}
}
if(p>q)
{
return -1;
}
}