算法学习

几种排序算法的稳定性总结：
插入排序、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;
}