小算法收集

//字符串拷贝
char* strcpy(char* dest, const char* src)
{
 assert((dest!=NULL) && (src!=NULL));
 char* address = dest;
 while ((*dest++=*src++) != '\0');
 return address;
}

//字符串比较
int strcmp(const char* str1, const char* str2)
{
 assert( (str1!=NULL) && (str2!=NULL) );
 int ret = 0;
 while ( !(ret = *(unsigned char*)str1 - *(unsigned char*)str2) && (*str2 != '\0'))
 {
  str1++;
  str2++;
 }
 if (ret > 0)
  ret = 1;
 else if (ret < 0)
  ret = -1;
 return ret;
}

//单链表反序
link* inverse(link* L){  //递归
    if(!L)||(!L->next){  
       return L;    
     }                                        
    link h = inverse(L->next);
    L->next->next=L;                
    return h;
}
void reverse(List *head)
{
  List *p,*q;
  p = head;
  head = NULL;
  while(p)
  {
    q = p;
    p = p->next;
    q->next = head;
    head = temp;
  }
}
struct IntNode* res(struct IntNode* h)
{
 IntNode *p,*pre,*q;
 pre=p=q=h;
 while(p!=NULL)
 {
  pre=p;p=p->Next;
  if(pre==h)
   pre->Next=NULL;
  else
  {
   pre->Next=q;
   q=pre;
  }
 }
 h=pre;
 return h;
}

//字符转数字
int conver(char *str)
{
 int k = 0;
 while (*s>'0' && *s<'9')
 {
  k = 10*k;
  k += (*s++) - '0';
 }
}

//字符串转数字
int myAtoi(const char* s){
 int result = 0;
 int flag = 1;
 int i = 0;

 while(isspace(s[i]))
  i++;
 if(s[i] == '-'){
  flag = -1;
  i++;
 }
 if(s[i] == '+')
  i++;
 while(s[i] != '\0'){
  if((s[i] > '9') || (s[i] < '0'))
   break;
  int j = s[i] - '0';
  result = 10 * result + j;
  i++;
 }
 result = result * flag;
 return result;
}

//'\t'转四个'.'
void TabToSpace(char *str,int len)
{
 int i=0,j;
 while(str[i]!='\0')
 {
  if(str[i]=='\t')
  {
   for(j=len+3;j-3>i;j--)
   {
    str[j] = str[j-3];
   }
   str[i++] = '.';
   str[i++] = '.';
   str[i++] = '.';
   str[i++] = '.';
   len = len +3;//这儿不要忘了哦，这样移动后实际上你的字符串的长度已经增加了
  }
  else i++;
 }
}

//内存拷贝
void *memcpy(void *to, const void *from, size_t size)
{
 assert((to!=NULL) && (from!=NULL));

 byte *pTo = (byte*)to;
 byte *pFrom = (byte*)from;

 while (size-- > 0)
 {
  *pTo++ = *pFrom++;
 }
 return to;
}

//有覆盖的内存拷贝
void* memcpy( void *dst, const void *src, unsigned int len )
{
    register char *d;
    register char *s;
    if (len == 0)
        return dst;
    if ( dst > src )   //考虑覆盖情况
    {
        d = (char *)dst + len - 1;
        s = (char *)src + len - 1;
        while ( len >= 4 )   //循环展开，提高执行效率
        {
            *d-- = *s--;
            *d-- = *s--;
            *d-- = *s--;
            *d-- = *s--;
            len -= 4;
        }
        while ( len-- > 0)
        {
            *d-- = *s--;
        }
    }
    else if ( dst < src )
    {
        d = (char *)dst;
        s = (char *)src;
        while ( len >= 4 )
        {
            *d++ = *s++;
            *d++ = *s++;
            *d++ = *s++;
            *d++ = *s++;
            len -= 4;
        }
        while ( len-- > 0)
        {
            *d++ = *s++;
        }
    }
    return dst;
}

//删除节点，双向循环链表
list* earse(list* node)
{
 if (node == rear)
  return node->next;
 list* next = node->nest;
 next->prev = node->prev;
 node->prev->next = next;
 delete node;
 return next;
}

//删除节点，单向循环链表
list* earse(list* node)
{
 if (node == rear)
  return node->next;
 list* p = rear;
 while (p->next != node)
  p = p->next;
 p->next = node->next;
 delete node;
 return p->next;
}

//字符串连接
char * strcat (char * dst, const char * src )
{
        char * cp = dst;
        while( *cp )
                cp++;                   /* find end of dst */
        while( *cp++ = *src++ ) ;       /* Copy src to end of dst */
        return( dst );                  /* return dst */
}

//字符串在内存的转移
vord *memmove(void *dest,const void *src,size_t count)
{
    void *ret=dest;
    if(dest<=src||dest>=src+count)
    {
        while(count--)
            *dest++=*src++
    }
    else
    {
        dest+=count-1;
        src+=count-1;
        while(count--)
            *dest--=*src--
    }
    return ret;
}

//冒泡排序
void buble(int *a,int n)
{
    for(int i=1; i<n ;i++)    {
        for(int j=n-1; j>=i; j--)       
 {
            if(a[j] < a[j-1])          
  {
                int temp=a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }
}

//双向冒泡
void BubbleSort (int n,Datatype a[])
{
 Datatype temp;
 int flag=1;
 int left,right;
 int Right=n-1;
 int i;
 for(left=0,right=n-1;left<right && flag==1;left++,right--)
 {
  flag=0;
  for(i=left;i<right;i++)
  {
   if(a[i]>a[i+1])  //小的往上浮
   {
    temp=a[i];
    a[i]=a[i+1];
    a[i+1]=temp;
    flag=1;
   }    
   if(a[Right-i]<a[Right-i-1])   //大的往下沉
   {
    temp=a[Right-i-1];
    a[Right-i-1]=a[Right-i];
    a[Right-i]=temp;
    flag=1;
   }   
  }
 }
}

//插入排序：
void insertsort(int* a,int n)
{
    int key;
    for(int j=1;j<n;j++)    {
        key = a[j];
        for(int i=j-1;i>=0&&a[i]>key;i--)
        {
            a[i+1] = a[i];
        }
        a[i+1] = key;
    }
}
void InsertSort(int* pData,int Count)
{
    int iTemp;
    int iPos;
    for(int i=1;i<Count;i++)
    {
        iTemp = pData[i];
        iPos = i-1;
        while((iPos>=0) && (iTemp<pData[iPos]))
        {
            pData[iPos+1] = pData[iPos];
            iPos--;
        }
        pData[iPos+1] = iTemp;
    }
}

//交换排序
void ExchangeSort(int* pData,int Count)
{
    int iTemp;
    for(int i=0;i<Count-1;i++)
    {
        for(int j=i+1;j<Count;j++)
        {
            if(pData[j]<pData[i])
            {
                iTemp = pData[i];
                pData[i] = pData[j];
                pData[j] = iTemp;
            }
        }
    }
}

//选择排序
void SelectSort(int* pData,int Count)
{
    int iTemp;
    int iPos;
    for(int i=0;i<Count-1;i++)
    {
        iTemp = pData[i];
        iPos = i;
        for(int j=i+1;j<Count;j++)
        {
            if(pData[j]<iTemp)
            {
                iTemp = pData[j];
                iPos = j;
            }
        }
        pData[iPos] = pData[i];
        pData[i] = iTemp;
    }
}

//快排
void quickSort(int *a, int left, int right)
{
 if(left<right)
 {
  int i = Partition(a,left,right);
  quickSort(a,left,i-1);
  quickSort(a,i+1,right);
 }
}
int Partiton(int *a, int low, int high)
{
 int k = low;
 for(int i=low+1; i<=high; i++)
 {
  if(a[i]<a[k] && ++k!=i)
   swap(a[k],a[i]);
 }
 swap(a[low],a[k]);
 return k;
}

//希尔排序
void ShellSort(int* pData,int Count)
{
    int step[4];
    step[0] = 9;
    step[1] = 5;
    step[2] = 3;
    step[3] = 1;

    int iTemp;
    int k,s,w;
    for(int i=0;i<4;i++)
    {
        k = step[i];
        s = -k;
        for(int j=k;j<Count;j++)
        {
            iTemp = pData[j];
            w = j-k;//求上step个元素的下标
            if(s ==0)
            {
                s = -k;
                s++;
                pData[s] = iTemp;
            }
            while((iTemp<pData[w]) && (w>=0) && (w<=Count))
            {
                pData[w+k] = pData[w];
                w = w-k;
            }
            pData[w+k] = iTemp;
        }
    }
}

//计算文件有多少行
int getLineCount()
{
 ifstream ifs;
 ifs.open("somes.txt",ios::in);
 int count = 1;

 char ch;
 while (ifs.get(ch))
 {
  if ( ch == '\n')
   ++count;
 }
 ifs.close();
 return count;
}

//计算n阶乘有多少0
int Lower(int num)
{
 int powoffive = 1;
 while ( pow(5,powoffive) <= num)
  ++powoffive;
 return powoffive;
}
int GetCount(int num)
{
 int lowernear = Lower(num);
 int count = 0;
 while (lowernear>0)
 {
  count += num/pow(5,lowernear);
  --lowernear;
 }
 return count;
}

//十进制转化为二进制
const int TWO=2;
string ToBin(unsigned int n)
{
 if (n==0) return "0";
 string binf="";
 while (num>0)
 {
  binf.insert(binf.begin(),n%TWO+'0');
  num /= TWO;
 }
}

//一个数组的最大子列和
int MaxSub (int *a, int n)
{
 int sum = 0;
 while (n>=0)
 {
  if (a[n]>0)
  {
   sum += a[n];
  }
  else if (a[n]<0)
  {
   if (sum == 0)
    sum = a[n];
  }
  --n;
 }
 return sum;
}
int max_sub(int a[], int size)
{
       int i,max=0,temp_sum=0;
       for(i=0;i<size;i++)
       {
            temp_sum+=a[i];
            if(temp_sum>max)
                 max=temp_sum;
            else if(temp_sum<0)
                 temp_sum=0;
       }
       return max;
}

//判断一个unsigned char 字符有几位是1
int bitCount(unsigned char c)
{
 unsigned char comp = 1;
 int bits = sizeof(c)*8;
 int tmp = 0;
 int count = 0;
 
 while( 0!=(bits--) )
 {
  tmp = comp&c;
  if( 0!=tmp )
   count++;
  comp = comp<<1;
 }
 return count;
}

//不用变量计算字符串长度
int myStrlen(const char *str)
{
 if( *str != 0 )
 {
  if( *(str+1) != 0 )
  {
   return ( 1 + myStrlen(str+1) );
  }
  else
  {
   return 1;
  }
 }
 else
 {
  return 0;
 }
}

//字符串比较
int strcmp(char *source, char *dest)
{   
 while ( (*source != '\0') && (*source == *dest))   
 { source++; dest++;    }   
 return ( (*source) - (*dest) ) ? -1 : 0;
}

//背包问题
int knap(int s, int n)
{  
 if (s==0)  
  return 1;  
 if ( (s<0) || ((s>0)&&(n<1)) )  
  return 0;  

 if (knap(s-w[n],n-1)){  
  printf("%4d",w[n]);  
  return 1;  
 }  
 else  
  return knap(s,n-1) ;  
}  

//判断回文
int fun(char *p)
{
 int len = strlen(p) - 1;
 char *q = p + len;
 if (!p)
  return -1;
 while (p < q)
 {
  if ((*p++) != (*q--))
   return 0;
 }
 return 1;
}

//输入年月日时分秒，输出该年月日时分秒的下一秒
void NextMinute(int *nYear,int *nMonth,int *nDate,int *nHour,int *nMinute,int *nSecond)
 {
  int nDays;

  (*nSecond)++; // 秒加1
  if(*nSecond>=60) // 秒满60，做出特殊处理，下面时，日，月等类同
  {   
   *nSecond=0;   

   (*nMinute)++;   
  if(*nMinute>=60)   
  {     
   *nMinute=0; 
   
   (*nHour)++;      
   if(*nHour>=24)     
   {       
    *nHour=0;       

    (*nDate)++;       
    switch(*nMonth)       
    {         
    case 1:         
    case 3:         
    case 5:         
    case 7:         
    case 8:         
    case 10:         
    case 12:           
     nDays=31;          break;         
    case 2:// 判断闰年           
     if(*nYear%400==0 || *nYear%100!=0&&*nYear%4==0)           
     {            nDays=29;            }          
     else           
     {            nDays=28;            }        
     break;         
    default:           
     nDays=30;          break;       
    }       
    if(*nDate>nDays)       
    {         
     *nDate=1;         
     (*nMonth)++;         
     if(*nMonth>12)         
     {         
      *nMonth=1;         
      (*nYear)++;        
     }       
    }     
   }   
  }
 }
}

//两数组中存在相同数据
bool findSameVal(int a[], int size1, int b[], int size2)
{
       int i=0,j=0;
       while(i<size1 && j<size2)
       {
            if(a[i]==b[j])
                   return true;
            if(a[i]>b[j])
                 j++;
            if(a[i]<b[j])
                 i++;
       }
       return false;
}

//字符串反转
char* strrev(const char* str)
{
       char* tmp = new char[strlen(str) + 1];
       strcpy(tmp,str);

       char* ret = tmp;
       char* p = tmp + strlen(str) - 1;

       while (p > tmp)
       {
              *p = *p + *tmp;
              *tmp = *p - *tmp;
              *p = *p - *tmp;
               --p;
              ++tmp;
       }
       return ret;
}

//约瑟夫算法
typedef struct Person
{
    int num;
    struct Person *next;
}person;
void Func(int m, int n)
{
    person *circle = (person *)malloc(n * sizeof(person));    assert(circle != NULL);
   
    for (int i = 0; i < n; i++)
    {
        circle[i].num = i+1;
        circle[i].next = &circle[i+1];
    }
    circle[n-1].next = &circle[0];
   
    person *start = &circle[0];
    person *preP = &circle[n-1];

    while(preP != start)
    {
        for (int j = 0; j < m-1; j++)
        {
            preP = start;
            start = start->next;
        }
        printf("Num. %u out.\n", start->num);
        start = start->next;
        preP->next = start;
    }
   
    printf("The winner is %d !\n", start->num);
    free(circle);
}