C语言（数据结构，DEVFORGE学编程社区）

1、行程编码压缩算法

#include<stdio.h>
#include <string.h>
#define N 100

int main()
{    
    char s[N] = "", t[N] = "", ch;
    gets(s);
    
    int count = 0, index = 0;
    for(int i=0; s[i]; ++i)
    {    
        if(!count)
            ch = s[i];
        count++;
        if(ch!=s[i+1] || count==9){
            t[index++] = count+'0';
            t[index++] = ch;            
            count=0;            
        }
    }
    printf("%s",t); 
    return 0;
}

2、创建与遍历职工链表

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define N 100

typedef struct node EMPLOYEE,*LIST;
struct node{ 
    int num;
    LIST next;
};

void Insert(LIST head,int num)
{    
    LIST p = head, s;
    s = (LIST)malloc( sizeof(EMPLOYEE) );
    s->num = num; //给p赋值
    
    while(p->next != NULL && s->num >= p->next->num)
        p = p->next;
    //连接 
    s->next = p->next; //若s最大, p->next=NULL
    p->next = s;  
}

LIST Create()
{
    //创建头结点
    LIST head = (LIST)malloc(sizeof (EMPLOYEE));
    head->next = NULL;
    
    int n,num;
    scanf("%d",&n);
    //插入n个职工号
    while(n--)
    {
        scanf("%d",&num);
        Insert(head,num);
    }
    return head;
}

void Print(LIST head)
{    
    LIST p = head;
    while(p->next != NULL)
    {
        p = p->next;
        printf("%d ",p->num);
    }   
}

int main()
{    
    LIST head = Create();
    Print(head);    
    return 0;
}

3、毕业设计论文打印

#include <stdio.h>
#include <string.h>
#define N 100

int main()
{    
    int arr[N] = {0}, n, index, count=0;
    scanf("%d%d",&n,&index);
    
    for(int i=0; i<n; ++i)
        scanf("%d",&arr[i]);
    
    for(int j=0; j<n; ++j){
        if(arr[j]>arr[index])
            count++;    
    }
    printf("%d",++count);
    return 0;
}

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define N 100

typedef struct QNode *Queue;
typedef int Position,ElementType;
struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
/* 循环链表队列 */
Queue CreateQueue( int MaxSize )
{
    /* 1.创建一个队列Q */
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    /* 2.队列数据赋初值 */
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;/* 队列指针 */
    Q->MaxSize = MaxSize;/* 队列最大容量 */
    /* 3.返回空队列 */
    return Q;
}

int main()
{    
    int n, index, count=0;
    scanf("%d%d",&n,&index);
    /* 
    n个元素，最少需要n+1个空间
    Q->Front 指针占据一个空间
    Q->Front == Q->Rear 队列空
    Q->Front == (Q->Rear+1)%Q->MaxSize 队列满
    */
    Queue Q = CreateQueue(n+1);
    index++;/* 因为开始下标0给指针占了，所以index所在的位置+1 */
    
    for(int i=0; i<n; ++i){        
        Q->Rear = (Q->Rear+1)%Q->MaxSize;/* 尾指针后移 */
        scanf("%d",&Q->Data[Q->Rear]);/* 尾指针指向的位置输入元素 */
    }
    
    for(int j=0; j<n; ++j)//遍历
    {    
        if(Q->Data[(Q->Front+1)%Q->MaxSize]<=Q->Data[index])
        {
            Q->Rear = (Q->Rear+1)%Q->MaxSize;            
            Q->Data[Q->Rear] = Q->Data[(Q->Front+1)%Q->MaxSize]; //入队尾
            if(Q->Data[index]==Q->Data[(Q->Front+1)%Q->MaxSize]){
                index = Q->Rear;/*指定的打印位置到了队尾*/
            }        
        }
        else{
            count++; /*指定的打印元素优先级高的++*/
        }    
        Q->Front =(Q->Front+1)%Q->MaxSize;//出队
    }
    
    printf("%d", ++count);//本身打印1小时
    return 0;
}

4、火车站

#include <stdio.h>
#include <stdbool.h>
#include <malloc.h>
#define ERROR -1
#define N 100

typedef int ElementType;
typedef int Position;
struct SNode {
    ElementType *Data; /* 存储元素的数组 */
    Position Top;      /* 栈顶指针 */
    int MaxSize;       /* 堆栈最大容量 */
};
typedef struct SNode *Stack;/* 栈指针 */

 /* 创建空栈 */
Stack CreateStack( int MaxSize )
{
    Stack S = (Stack)malloc(sizeof(struct SNode));
    S->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    S->Top = -1;
    S->MaxSize = MaxSize;
    return S;
}

/* 栈满 */
bool IsFull( Stack S )
{
    return (S->Top == S->MaxSize-1);
}

 /* 入栈 */
bool Push( Stack S, ElementType X )
{
    if ( IsFull(S) ) {
        //printf("堆栈满");
        return false;
    }
    else {
        S->Data[++(S->Top)] = X;
        return true;
    }
}

 /* 栈空 */
bool IsEmpty( Stack S )
{
    return (S->Top == -1);
}

 /* 出栈 */
ElementType Pop( Stack S )
{
    if ( IsEmpty(S) ) {
        //printf("堆栈空");
        return ERROR; /* ERROR是ElementType的特殊值，标志错误 */
    }
    else 
        return ( S->Data[(S->Top)--] );
}

int main()
{   
    int n,a;
    int arr[N] = {0}, i, index=0;
    /* 1.A方向驶来的火车车厢n节 */
    scanf("%d",&n);
    /* 2.车站至少可以停放n节车厢(任意多) */
    Stack s = CreateStack(n);
    /* 3.出站顺序( 数组arr存放 ) */
    while(scanf("%d",&a) && a)
        arr[index++] = a;
    /* 4.A方向驶来的火车车厢顺序从1开始(in=1) */
    int in = 1;
    /* 5.依次出站 */
    for(i=0; i<index; ++i)
    {   /*如果出站顺序号与车站车厢顺序号不一致
        且A方向还有车厢,依次进站*/
        while(arr[i]!=s->Data[s->Top] && in<=n && Push(s,in))    
            in++;
        /* A方向没有车厢 
        且出站顺序号与车站车厢顺序号不一致
        编排顺序不可能, 输出No, 退出*/
        if(in>n && arr[i]!=s->Data[s->Top]) 
        {
            printf("No"); 
            break;
        }
        /* 车站有车厢, 出站 */
        if(!IsEmpty(s)) 
            Pop(s);
    }
    /* 6.上面的循环非break中断, 编排顺序正确, 输出Yes */
    if(i==index) 
        printf("Yes");    
    return 0;
}

5、大数减法

#include<stdio.h>  
#include<string.h>  
int x[100]={0},y[100]={0},z[105]={0};//将数组元素全部初始化为0  
void sub(int x[],int y[],int len)  
{  
    int i,j;  
    for(i=0;i<len;i++)  
    {  
        if(x[i]>=y[i])//如果x[i]>=y[i]，不用向前一位借1，可直接减   
            z[i]=x[i]-y[i];  
        else  //如果x[i]<y[i]，向前一位借1，同时前一位应减1   
        {  
            z[i]=x[i]+10-y[i];  
            x[i+1]=x[i+1]-1;  
        }      
    }  
    for(i=len-1;i>0;i--)//删除前缀0   
    {  
        if(z[i]==0)  
            len--;  
        else  
            break;   
    }  
    for(i=len-1;i>=0;i--)  //倒序输出数组   
        printf("%d",z[i]);  
    printf("
");  
}  
int main()  
{  
    char a[100],b[100];//通过字符串对大数进行输入并储存   
    int len1,len2;  
    scanf("%s %s",a,b); 
     
    int i,j=0,k=0;  
    len1=strlen(a);  
    len2=strlen(b);  
    /*将两个字符串中的字符转化为数字，并倒序储存到数组中，
    即字符串为123456，则数组为654321*/   
    for(i=len1-1,j=0;i>=0;i--)
        x[j++]=a[i]-'0';  
    for(i=len2-1,k=0;i>=0;i--)  
        y[k++]=b[i]-'0';  
    //若减数长度 > 被减数，正常减 
    if(len1>len2)    
        sub(x,y,len1);  
    else if(len1<len2) //若减数长度 < 被减数，被减数 减 减数  
    {  
        printf("-");  
        sub(y,x,len2);  
    }   
    else  //若减数长度 == 被减数，判断两个数的大小   
    {  
        for(i=len1-1;i>=0;i--)//判断每一位两个数的大小  
        {  
            if(x[i]==y[i])  
                continue;  
            if(x[i]>y[i])//即减数大   
            {  
                sub(x,y,len1);  
                break;  
            }      
            if(x[i]<y[i])//即被减数大   
            {  
                printf("-");  
                sub(y,x,len1);  
                break;   
            }      
        }  
    }        
    return 0;   
}

6、精确乘幂

#include <stdio.h>
#include <string.h>
#define N 200
int main()
{    
    char numStr[10];/* 定义数字字符串 */
    /* 定义字符串长度幂int数组及下标int数字小数点后位数 */
    int i,j,len,n,numArray[N],index,numInt,digit;
    memset(numArray, 0, sizeof(numArray));
    numInt = index = digit = 0;
    
    /* 1.输入数字字符串幂次 */
    scanf("%s %d",numStr,&n);    
    len = strlen(numStr);
    
    int flag = 1, zero = 0;//判断最后的无效'0',定义标记
    /* 2.字符串倒序转int数组num */
    for(i = len-1;i >= 0;i--)
    {  
        if(numStr[i] == '0' && flag)
        {
            zero++;//无效的'0'
            continue;
        }
        else
        {
            flag = 0;
            if(numStr[i] == '.')
            {                
                digit = len-zero-i-1;//有效的小数点后位数
                continue;//去掉小数点
            }
        }
        numArray[index++] = numStr[i] - '0';
    }

    /* 3.int数组转int */
    for(i = index-1;i >= 0;i--)
        numInt = numInt*10 + numArray[i];
    
    /* 4.求幂 */
    for(i = 1; i < n; i++)//幂次(本身一次)
    {
        int carry = 0;    
        for(j = 0; j < N; j++)//int数字与int数组数字相乘
        {
            int tmp = numInt*numArray[j] + carry;
            numArray[j] = tmp%10;
            carry = tmp/10;
        }
    }
    
    /* 5.去掉数组中无效的'0'(小数位控制) */
    for(i = N-1; numArray[i]==0 && i>n*digit; i--); 
    
    /* 6.打印结果 */
    for(j = i; j >= 0; j--)
    {
        if(j == n*digit-1)//小数位之前打印小数点, 无小数位-1
            printf(".");
        printf("%d",numArray[j]);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *strrev(char* p)  
{  
    char *p1=p;      
    char *p2=p;  
    char ch;  
    while(*p1++);  
    p1--;    
    p1--;    
   
    while(p2 < p1)  
    {  
        ch = *p2;  
        *p2++ = *p1;   
        *p1-- = ch;   
    }  
  
    return(p);  
}  

//change the string to the big-int and save them in array
//返回值：小数点的位数
//src: the String
//number: the array
//length: string's length
int string2int(char * src, int * number, int length);

int string2int(char * src, int * number, int length)
{
    int flag=0;
    //define the buffer to store the data
    char * str = (char *)malloc(sizeof(char)*(length+1));
    memset(str, '', length+1);
    memcpy(str, src, length);
    /*  puts(str);*/
    strrev(str);
    /*  puts(str);*/
    //transfer string to int
    //int temp = *number; //原有的数据不为零时，也需要考虑
    int i, j;
    for (i=0, j=0; i<length; i++)
    {
        //temp *= 10;
        //原有数据为字符'A'，顾需要减去'0'
        if (str[i]!='.')
        {
            number[j++] += (int)(str[i] - '0');
        }
        else
        {
            flag = j;
        }

    }
    //return the transfer number
    //*number = temp;
    //clear the dynamic memory
    free(str);
    str = NULL;
    return flag;
}

//大数相乘
//乘数：numsA，numsB
//长度：lenA， lenB
int BigNumberMultiplication(int * numsA, int lenA, int * numsB, int lenB, int *
                            results);
int BigNumberMultiplication(int * numsA, int lenA, int * numsB, int lenB, int * results)
{
    int i, j;
    //multi procedure
    for (i=0; i<lenB; i++)
    {
        for (j=0; j<lenA; j++)
        {
            //the i,j place number multi, and the result is on the i+j place
            results[i+j] += numsA[j] * numsB[i];
        }
    }
    //process the result
    for (i=0; (i<lenA+lenB); i++)
    {
        if (results[i]>=10)  //the low place to the high place, if the low number is >=10       
        {
            results[i+1] += results[i] /10;
            results[i] %= 10;
        }
    }
    //calcute lenA
    for (i=lenA+lenB-1; i>=0; i--)
    {
        if (results[i] != 0)
        {
            break;
        }
    }
    return i+1;
}

int main()
{
    char str[7] = {''};
    int numsB[5] = {0};
    int n;
    scanf("%s %d", str, &n);
    int length = strlen(str);
    //获取小数点的位数
    int PointPlace = string2int(str, numsB, length);
    if (PointPlace!=0) // reduce the . nums
    {
        length--;
    }

    int * pNumsA = (int *)malloc(length*n*sizeof(int));
    int * pResults = (int *)malloc(length*n*sizeof(int));
    memset(pNumsA, 0, length*n*sizeof(int));
    memset(pResults, 0, length*n*sizeof(int));
    memcpy(pNumsA, numsB, length*sizeof(int));
    // int i;
    // for (i=0; i<length; i++)
    // {
    //      printf("%d", pNumsA[i]);
    // }
    // printf("-%d
", PointPlace);
    int lenA = length;
    /*printf("%d", lenA);*/
    int i, j;
    int bIsBegin = 0;
    char * pString = (char *)malloc(sizeof(char)*length*n+2);
    memset(pString, '', sizeof(char)*length*n+2);
    if (n==1)
    {
        printf("%s", str);
    }
    else
    {
        //求幂
        for (i=1; i<n; i++)
        {
            lenA = BigNumberMultiplication(pNumsA, lenA, numsB, length,
                                           pResults);
            memcpy(pNumsA, pResults, lenA*sizeof(int));
            memset(pResults, 0, lenA*sizeof(int));
            //printf("LenA---%d
", lenA);
        }

        //将结果由数组转化为字符串并添加小数点
        i=0;
        j = 0;
        while (i<length*n)
        {
            if (pNumsA[i]==0)
            {
                if (1==bIsBegin)
                {
                    if ( i==(PointPlace*n) )
                    {
                        if (i!=0)
                            pString[j++] = '.';
                    }
                    pString[j++] = pNumsA[i++] + '0';
                }
                else
                    i++;

            }
            else
            {
                bIsBegin = 1; ////begin from the first non-zero value

                if ( i==(PointPlace*n) )
                {
                    if (i!=0)
                    {
                        pString[j++] = '.';
                    }

                }

                pString[j++] = pNumsA[i++] + '0';
            }
        }

        free(pNumsA);
        free(pResults);
        //反转字符串：之前的字符串一直是倒叙的
        strrev(pString);

        //输出结果：主要是处理小数点前0的个数
        if (PointPlace==0)
        {
            for (i=0; i<length*n; i++)
            {
                if (pString[i]!='0')
                    break;
            }
            printf("%s", &pString[i]);
        }
        else
        {
            for (i=0; i<length*n; i++)
            {
                if (pString[i]!='0')
                {
                    if (pString[i]=='.')
                    {
                        i--;
                        break;
                    }
                    else
                    {
                        break;
                    }

                }

            }
            printf("%s", &pString[i]);
        }
    }

    free(pString);

    return 0;
}

7、大数除法

#include<stdio.h>
#include<string.h>
 
char a[100],b[100];//用两个字符串用来输入两个大数
 
int x[100],y[100],z[100],m[100];//被除数  除数  商  余数
 
int digit;  //大数的位数
 
void sub(int x[],int y[],int len1,int len2)//大数减法
{
    int i;
    for(i=0;i<len1;i++)
    {
        if(x[i]<y[i])
        {
            x[i]=x[i]+10-y[i];
            x[i+1]--;
        }
        else
            x[i]=x[i]-y[i];
    }
    for(i=len1-1;i>=0;i--)//判断减法结束之后，被除数的位数
    {
        if(x[i])
        {
            digit=i+1;
            break;
        }
    }
}
int judge(int x[],int y[],int len1,int len2)
{
    int i;
    if(len1<len2)
        return -1;
    if(len1==len2)//若两个数位数相等
    {
        for(i=len1-1;i>=0;i--)
        {
            if(x[i]==y[i])//对应位的数相等
                continue;
            if(x[i]>y[i])//被除数 大于 除数，返回值为1
                return 1;
            if(x[i]<y[i])//被除数 小于 除数，返回值为-1
                return -1;
        }
        return 0;//被除数 等于 除数，返回值为0
    }
}
int main()
{
    int i,j=0,k=0,temp;
    int len1,len2,len;//len两个大数位数的差值
 
    scanf("%s %s",a,b);
    //while(~scanf("%s %s",a,b))
    {
        len1=strlen(a);//被除数位数
        len2=strlen(b);//除数位数
 
        for(i=len1-1,j=0;i>=0;i--)//将字符串中各个元素倒序储存在数组中
        {
            x[j++]=a[i]-'0';
        }
        for(i=len2-1,k=0;i>=0;i--)
        {
            y[k++]=b[i]-'0';
        }
 
        if(len1<len2)//当被除数位数 小于 除数位数时
        {
            printf("商是：0
");
            printf("余数是：");
            puts(a);
        }
        else //当被除数位数 大于或者等于 除数位数时
        {
            len=len1-len2;//两个大数位数的差值
            for(i=len1-1;i>=0;i--)//将除数后补零，使得两个大数位数相同。
            {
 
                if(i>=len)
                    y[i]=y[i-len];
                else
                    y[i]=0;
                
            }
            len2=len1;//将两个大数数位相同
 
            digit=len1; //将原被除数位数赋值给digit
 
            for(j=0;j<=len;j++)
            {
                z[len-j]=0;
 
                while(((temp=judge(x,y,len1,len2))>=0)&&digit>=k)//判断两个数的大小以及被除数位数与除数原位数的关系
                {
                    sub(x,y,len1,len2); //大数减法函数
 
                    z[len-j]++;//储存商的每一位
 
                    len1=digit;//重新修改被除数的长度
 
                    if(len1<len2&&y[len2-1]==0)
                        len2=len1;  //将len1长度赋给len2;
                }
 
                if(temp<0)//若被除数 小于 除数，除数减小一位。
                {
                    for(i=1;i<len2;i++)
                        y[i-1]=y[i];
                    y[i-1]=0;
                    if(len1<len2)
                        len2--;
                }
            }
 
            //printf("商是：");
            for(i=len;i>0;i--)//去掉前缀0
            {
                if(z[i])
                    break;
            }
            for(;i>=0;i--)
                printf("%d",z[i]);
            printf("
");
 
            /* printf("余数是：");
            for(i=len1;i>0;i--)
            {
                if(x[i])
                    break;
            }
            for(;i>=0;i--)
                printf("%d",x[i]);
            printf("
"); */
        }
    }
    return 0;
}

8、插入链表结点

#include <stdio.h> 
#include <stdlib.h>
#include <string.h>
/* node */
typedef struct staff *STAFF;
struct staff
{
    char  num[6];      //职工工号
    STAFF next;
};
/* makenode */
STAFF makenode()
{
    STAFF p = (STAFF)malloc(sizeof(struct staff));
    scanf("%s",p->num);
    p->next = NULL;
    return p;
}
/* create */
STAFF create(int m) 
{
    STAFF head,p;
    head = p = makenode();
    while(--m)
    {        
        p->next = makenode();//尾插    
        p = p->next;    
    }
    return head;
}
/* print */
void list(STAFF p)
{
    while(p){
        printf("%s ",p->num);
        p= p->next;
    }    
    printf("
");
}
/* insert */
STAFF insert(STAFF head,STAFF s)
{
    STAFF p = head;    
    while(p->next!=NULL&&strcmp(p->next->num,s->num)<0){
        p=p->next;
    } 
    s->next=p->next;
    p->next=s;      
    return head;
}
int main()
{
    int n;
    char num[6];
    scanf("%d",&n);
    STAFF head = create(n);
    STAFF s = makenode();
    head = insert(head,s);   
    list(head); //打印链表
    return 0;
}

9、大数乘法

#include <stdio.h>
#include <string.h>
#define MAX 300

unsigned an1[MAX+5] = {0};
unsigned an2[MAX+5] = {0};
unsigned a[2*MAX+10] = {0};
char aa[MAX+10] = "";
char b[MAX+10] = "";
int main()
{
    gets(aa);//读入一个字符串 
    gets(b);
    int i,j;
    int len_a = strlen(aa);
    for(j=0,i=len_a-1;i>=0;i--)
        an1[j++]=aa[i]-'0';//转换为10进制数字     
    int len_b=strlen(b);    
    for(j=0,i=len_b-1;i>=0;i--)
        an2[j++]=b[i]-'0';
    
    for(i=0;i<len_b;i++){//这一步可以进行优化 但是很复杂 O（logn（1.59）） 
        for(j=0;j<len_a;j++)
            a[i+j]+=an2[i]*an1[j];//每一位都进行相加 m*n的复杂度 
    }    
    for(i=0;i<2*MAX;i++){
        if(a[i]>=10){
            a[i+1]+=a[i]/10;//由于进位还没有考虑进去 这样就有些数字大于10的 
            a[i]%=10;//我们要进位 
        }
    }
    bool b=false;
    for(i=MAX*2;i>=0;i--)//下面就是输出了 一定要注意个位数字的下表更大 所以是从第一个非0数字开始的 
        if(b)    
            printf("%d",a[i]);
        else if(a[i]){
            printf("%d",a[i]);
            b=true;
        }
    if(!b)//这一步太重要了 一定不要忘记 如果有一个数字是0的话 这个我就忘记了 一直wrong answer 几乎快崩溃了 
        printf("0");
    return 0;
}

10、Symmetric Sort

#include<stdio.h>  
#include<string.h>  
#include<algorithm>  
using namespace std;  
struct ch{  
    int len; 
    char str[30];  
}s[1000];  
bool cmp(struct ch a,struct ch b){  
    return a.len<b.len;  
}  
int main()
{  
    int i,j,n;  
    scanf("%d",&n); 
    for(i=0;i<n;i++){  
        scanf("%s",s[i].str);//这里s[i]前边加不加&符号都行   
        s[i].len=strlen(s[i].str);  
    }  
    /* 这里还有一个stable_sort，用法和sort是一样的，
    区别是stable_sort是稳定排序，对于相等的值次序不变   */
    sort(s,s+n,cmp); 
    for(i=0;i<n;i+=2)  
         printf("%s ",s[i].str);  
    if(i==n+1) j=n-2;//因为i变到n+1的时候，可以自己调试一下   
    else j=n-1;  
    for(;j>=0;j-=2)  
        printf("%s ",s[j].str);  
    printf("
");
    return 0;  
}