数据结构与算法

1.1 算法设计步骤

a.输入输出，由此确定算法的参数和返回值。

b.使用断言，检查输入参数的合法性，防止非法输入。

c.考虑边界，全面考虑可能出现的所有情况。

d.出错处理，goto error方式。

1.2 字符串

char* strstr(char* s1,char* s2){
  char *p=s1,*r=s2;
  while(*p!=''){
    while(*p++==*r++);
    if(*r=='')
      return p;
    else{
      r=s2;
      p=s1++;
    }
  }
  return NULL;
}

char* strcpy(char *strDst,char *strSrc){
  if(strDst==strSrc)
    return strDst;
  char *pDst=strDst;
  char *pSrc=strSrc;
  while((*pDst++=*pSrc++)!='');
  *pDst='';
  return pDst;
}

char* deletechar(char *str,char chr[],int n){
  char tmp[256]={0};
  for(int i=0;i<n;i++)
    tmp[chr[i]]=1;
  int iDst=0,iSrc=0;
  while(str[iSrc++]!=''){
    if(!tmp[str[iSrc]])
      str[iDst++]=str[iSrc];
  }
}

int wordnum(char *str){
  int num=0;
  char *pchar=str;
  while(*pchar!=''){
    while(*pchar!=' ' && *pchar++!='');
    num++;
    pchar++;
  }
}

void reverse(char *str){
  int n=strlen(str);
  char c;
  for(int i=0;i<n/2;i++){
    c=str[i];
    str[i]=str[n-i];
    str[n-i]=c;
  }
}

void memcpy(char *strDst,char *strSrc,int size){
  char *pSrc=(char*)strSrc+size-1;
  char *pDst=(char*)strDst+size-1;
  while(size--)
    *pDst--=*pSrc--;
}

void sortstring(char *str,int n){
  char *tmp=NULL;
  for(int i=0;i<n-1;i++){
    for(int j=n-1;j>i;j--){
      if(strcmp(str[j],str[j-1])<0){
        tmp=str[j];
        str[j]=str[j-1];
        str[j-1]=tmp;
      }
    }
  }
}

1.3 链表

typedef struct _node{
  int data;
  struct _node *next;
}node,*list;

void reverselist(node **head){
  node *p,*q,*r;
  p=*head;
  q=p->next;
  while(!q=NULL){
    r=q->next;
    q->next=p;
    p=q;
    q=r;
  }
  (*head)->next=NULL;
  *head=p;
}

void sortlist(node *head){
  node *p,*q,*s;
  int t;
  p=head;
  while(p){
    s=p;
    q=p->next;
    while(q){
      if(q->value < s->value)
        s=q;
      q=q->next;
    }
    if(s!=p){
      t=s->value;
      s->value=p->value;
      p->value=t;
    }
    p=p->next;
  }
}

1.4 树

typedef struct _tree{
  int data;
  struct _tree *left;
  struct _tree *right;
}tree,*ptree;

void preorder(tree *t){
  if(t){
    printf("%d",t->data);
    preorder(t->left);
    preorder(t->right);
  }
}

void inorder(tree *t){
  if(t){
    inorder(t->left);
    printf("%d",t->data);
    inorder(t->right);
  }
}

void postorder(tree *t){
  if(t){
    postorder(t->left);
    postorder(t->right);
    printf("%d',t->data);
  }
}

void broadorder(tree *t){
  Queue q;
  tree *pt=NULL;
  Enque(q,t);
  while(!IsQueEmpty(q)){
    pt=Deque(q);
    printf("%d",pt->data);
    if(pt->left!=NULL)
      Enque(q,pt->left);
    if(pt->right!=NULL)
      Enque(q,pt->right);
  }
}

二叉排序树：

void insert(tree *b,tree *s){
  if(b==NULL)
    b=s;
  else if(s->data==b->data)
    break;
  else if(s->data<b->data)
    insert(b->left,s);
  else if(s->data>b->data)
    insert(b->right,s);
}

void create(tree *b){
  int x;
  tree *s;
  do{
    scanf("%d",&x);
    s=(node*)malloc(sizeof(node));
    s->data=x;
    s->left=NULL;
    s->right=NULL;
    insert(b,s);
  }while(x!=-1);
}

1.5 数

int gys(int i,int j){
  if(i%j==0)
    return j;
  else
    return gys(j,i%j);
}
int atoi(char *s){
  int i,n,sign;
  for(i=0;s[i]==' ';i++);
  sign=(s[i]=='-')?-1:1;
  if(s[i]=='+' || s[i]=='-')
    i++;
  for(n=0;'0'<=s[i]<='9';i++)
    n=10*n+(s[i]-'0');
  return sign*n;
}

1.6 数组

void findminmax(int a[],int n){
  int i,tmp,min,max;
  for(i=0;i<n-2;i+=2){
    if(a[i]<a[i+1]){
      tmp=a[i];
      a[i]=a[i+1];
      a[i+1]=tmp;
    }
  }
  max=a[0];
  min=a[1];
  for(i=0;i<n-2;i+=2){
    if(min>a[i])
      min=a[i];
  }
  for(i=1;i<n-2;i+=2){
    if(max<a[i])
      min=a[i];
  }
  printf("min:%d,max:%d
",min,max);
}

   1:  void findrepeated(int a[],int n){

   2:    int tmp[MAX]={0};

   3:    for(int i=0;i<n;i++)

   4:      tmp[a[i]]++;

   5:    for(i=0;i<MAX;i++)

   6:      if(tmp[i]>1)

   7:        printf("%d",i);

   8:  }

1.7 排序

void insertsortint a[],int n){
  int i,j,tmp;
  for(i=0;i<n;i++){
    tmp=a[i];
    j=i-1;
    while(tmp<a[j]){
      a[j+1]=a[j];
      j--;
    }
    a[j+1]=tmp;
  }
}

void shellsort(int a[],int n){
  int i,j,gap,tmp;
  gap=n/2;
  while(gap>0){
    for(i=gap+1;i<=n;i++){
      j=i-gap;
      while(j>=0){
        if(a[j]>a[j+gap]){
          tmp=a[j];
          a[j]=a[j+gap];
          a[j+gap]=tmp;
        }else
          j=0;
      }
    }
    gap/=2;
  }
}

   1:  void selectsort(int a[],int n){

   2:    int i,j,k,tmp;

   3:    for(i=0;i<n-1;i++){

   4:      k=i;

   5:      for(j=i+1;j<n;j++){

   6:        if(a[j]<a[k])

   7:          k=j;

   8:      }

   9:      if(k!=i){

  10:        tmp=a[i];

  11:        a[i]=a[k];

  12:        a[k]=tmp;

  13:      }

  14:    }

  15:  }

void bubblesort(int a[],int n){
  int i,j,tmp;
  for(i=0;i<n-1;i++){
    for(j=n;j>i;j--){
      if(a[j]<a[j-1]){
        tmp=a[j];
        a[j]=a[j-1];
        a[j-1]=tmp;
      }
    }
  }
}

void sift(int d[], int ind, int len)
{
    //#置i为要筛选的节点#%
    int i = ind;
    //#c中保存i节点的左孩子#%
    int c = i * 2 + 1; //#+1的目的就是为了解决节点从0开始而他的左孩子一直为0的问题#%
    while(c < len)//#未筛选到叶子节点#%
    {
        //#如果要筛选的节点既有左孩子又有右孩子并且左孩子值小于右孩子#%
        //#从二者中选出较大的并记录#%
        if(c + 1 < len && d[c] < d[c + 1])
            c++;
        //#如果要筛选的节点中的值大于左右孩子的较大者则退出#%
        if(d[i] > d[c]) break;
        else
        {
            //#交换#%
            int t = d[c];
            d[c] = d[i];
            d[i] = t;
            //#重置要筛选的节点和要筛选的左孩子#%
            i = c;
            c = 2 * i + 1;
        }
    }
    return;
}
void heap_sort(int d[], int n)
{
    //#初始化建堆, i从最后一个非叶子节点开始#%
    for(int i = (n - 2) / 2; i >= 0; i--)
        sift(d, i, n);
    for(int j = 0; j < n; j++)
    {
                //#交换#%
        int t = d[0];
        d[0] = d[n - j - 1];
        d[n - j - 1] = t;
        //#筛选编号为0 #%
        sift(d, 0, n - j - 1);
    }
}

   1:  //将有二个有序数列a[first...mid]和a[mid...last]合并。

   2:  void mergearray(int a[], int first, int mid, int last, int temp[])

   3:  {

   4:      int i = first, j = mid + 1;

   5:      int m = mid,   n = last;

   6:      int k = 0;

   7:      

   8:      while (i <= m && j <= n)

   9:      {

  10:          if (a[i] <= a[j])

  11:              temp[k++] = a[i++];

  12:          else

  13:              temp[k++] = a[j++];

  14:      }

  15:      

  16:      while (i <= m)

  17:          temp[k++] = a[i++];

  18:      

  19:      while (j <= n)

  20:          temp[k++] = a[j++];

  21:      

  22:      for (i = 0; i < k; i++)

  23:          a[first + i] = temp[i];

  24:  }

  25:  void mergesort(int a[], int first, int last, int temp[])

  26:  {

  27:      if (first < last)

  28:      {

  29:          int mid = (first + last) / 2;

  30:          mergesort(a, first, mid, temp);    //左边有序

  31:          mergesort(a, mid + 1, last, temp); //右边有序

  32:          mergearray(a, first, mid, last, temp); //再将二个有序数列合并

  33:      }

  34:  }

1.8 查找

int binsearch(int a[],int n,int k){
  int low,high,mid ,find,i;
  find=0;
  low=1;
  high=n;
  while(low<=high && !find){
    mid=(low+high)/2;
    if(a[mid]<k)
      low=mid+1;
    else if(a[mid]>k)
      high=mid-1;
    else{
      i=mid;
      find=1;
    }
  }
  if(!find)
    i=0;
  retun i;
}

tree* search(tree *b,int x){
  if(b==NULL)
    return NULL;
  else if(b->data==x)
    return b;
  else if(x<b->data)
    return search(b->left);
  else
    return search(b->right);
}

char getFirstNonRepeated(char *str){
  int hash[256]={0};
  int i;
  char *pstr=str;
  while(*pstr!=''){
    hash[*pstr]++;
    pstr++;
  }
  while(*pstr!=''){
    if(hash[*pstr]==1)
      return *pstr;
    pstr++;
  }
  return NULL;
}