算法学习

几种排序算法的稳定性总结：
插入排序、shell排序第不稳定排序。
堆排序是稳定排序。

排序方法：

1. 直接插入 平均O(n2)
2. shell排序 O(n1.3)

选择排序：

1. 直接选择 O(n2)
2. 堆排序O(nlog2n)

交换排序：

1. 冒泡排序 O(n2)
2. 快速排序 O(nlog2n)

归并排序：O(nlog2n)
基数排序（也就是桶排序）

选择排序：

插入排序：

 for(i=1;i<n;i++)  {    int temp=a[i];    int j=i-1;    while(temp<a[j]&&j>=0) //注意思想是如何使用的，想法解题思路很重要    {           a[j+1]=a[j];        j--;    }    a[j+1]=temp;  }

shell排序，是一种增量排序，选取等间隔的数据进行排序，N是序列的长度，第一次选取N/2，以后每次取1/2，最后一直到1，因为一个数的时候就是有序数列，然后采用插入排序

void shellsort(int a[],int n){   //shell排序  int increment,i,j;for(increment=N/2;increment>0;increment/=2){ for(i=0;i<N-increment;i++){   int tmp=a[i+increment];   while(j=i;j>=0&&a[j]>tmp;j-=increment){     a[j+increment]=a[j];   }   a[j+increment]=tmp; }}}

附带其他的算法题：
下面的题要学会：利用下标来记录数组中的位置上的元素，学会审题，

int judge(int a[], int n){  int i,head=0,rear=0,headvalue=0,rearvalue=0,flag=0,is=0;  for(i=0;i<n-1;i++)//循环体中写的是循环到一定时候需要做的事情，  {    is=0;    if((head==rear)&&(a[i]>a[i+1]))     {      headvalue=i;      head++;//head=1,head标记有几次是逆序的    }    if((head>rear)&&(a[i]<a[i+1]))    {      rearvalue=i+1;      rear++;      is=1;    }    if((is==1))      if(a[headvalue]>a[rearvalue])        return 0;  }       if(head==1)           return 1;    else      return 0;}

递归算法：一定要找一个出口，要找一定的规律，递归函数的函数体是每次循环都是一样的

#include<stdio.h>int num(int m){  if(m==1){    return 0;       }  if(m==2){   return 1;  }  if(m==3){   return 2;  }  return num(m-2)+num(m-1);}int main(){  int a;  int n;  scanf("%d",&n);  for(int i=0;i<n;i++){      scanf("%d",&a);      printf("%d\n",num(a));  }}

fibonacci数列也可以使用一维数组：比递归耗费的资源更少

a[0]=1;a[1]=1;for(i=2;i<n;i++){ a[i]=a[i-1]+a[i-2];}

汉诺塔问题：

#include<stdio.h>void hanoi(int n,char A ,char B,char C){    if(n==1)        printf("%c--->%c\n",A,C);    else    {        hanoi(n-1,A,C,B);        printf("%c--->%c\n",A,C);        hanoi(n-1,B,A,C);    }}int main(){  int n;  scanf("%d",&n);  hanoi(n,'A','B','C');  return 0;}

C语言中也可以动态申请数组大小 int a=(int )mallco(n*sizeof(int));
注意内存的分配，静态存储和动态存储，static关键字的使用含义，局部变量和全局变量
地址和指针：&和都只是一种运算符，指针运算符，&取址运算符，两者的优先级一样，&*x,优先级相同时自右向左方式结合。
链表是一种动态存储结构，只有需要的时候才分配，动态创建和动态删除

归并排序 思想分治：分割数组直到数组为1个元素，然后合并，采用递归

#include<stdio.h>#include<string.h>#include<stdlib.h>void mergearray(int a[],int first,int mid,int last,int tmp[]){  int i=first,j=mid+1;  int m=mid,n=last;  int k=0;  while(i<=m&&j<=n){      if(a[i]>a[j]){         tmp[k++]=a[j++];      }      else{         tmp[k++]=a[i++];      }  }  while(i<=m)      tmp[k++]=a[i++];  while(j<=n)      tmp[k++]=a[j++];  for(i=0;i<k;i++)      a[first+i]=tmp[i];}void mergesort(int a[],int first,int last,int tmp[]){    if(first<last){  //此时隐含着first==last,即最后只有1位数时候的情况，此时递归结束      int mid=(first+last)/2;      mergesort(a,first,mid,tmp);      mergesort(a,mid+1,last,tmp);      mergearray(a,first,mid,last,tmp);    }}int main(){  int a[10000],n;  scanf("%d",&n);  for(int j=0;j<n;j++){    scanf("%d",&a[j]);  }  int *p=(int *)malloc(n*sizeof(int));  if(p)      mergesort(a,0,n-1,p);  for(int i=0;i<n;i++)      printf("%d ",a[i]);  return 0;}

快排：

#include<stdio.h>#include<stdlib.h>#include<string.h>void qsort(int a[],int left,int right){    int i=left;    int j=right;    int tmp=a[left];  if(i<j){    while(i<j){        while(tmp<=a[j]&&j>i){ //写的时候要把所有的情况考虑到，我当时没有考虑到相等的情况           j--;        }        a[i]=a[j];        while(tmp>=a[i]&&i<j){          i++;        }        a[j]=a[i];    }    a[j]=tmp;    qsort(a,left,j-1); //分治    qsort(a,j+1,right);  }}int main(){   int n,a[1000];   scanf("%d",&n);   for(int i=0;i<n;i++){    scanf("%d",&a[i]);   }   qsort(a,0,n-1);   for(int j=0;j<n;j++){    printf("%d ",a[j]);   }   return 0;}