c语言的一点复习

鉴于c3上个周已经搞完了,那这个周我就复习一下c吧.

c算法题

1.

罗马数字包含以下七种字符：I， V， X， L，C，D 和 M。

字符 数值

I 1

V 5

X 10

L 50

C 100

D 500

M 1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例1

输入: “III”
输出: 3

示例 2:

输入: “IV”
输出: 4

示例 3:

输入: “IX”
输出: 9

示例 4:

输入: “LVIII”
输出: 58
解释: C = 100, L = 50, XXX = 30, III = 3.

示例 5:

输入: “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

代码实现

#include"stdio.h"
#include"string.h"
int romanToTnt(char*);
int main(int argc, char const *argv[])
{
    char s[100];
    gets(s);
    romanToInt(&s);
    return 0;
}
int romanToInt(char *s)
{
    int temp = 0;   
    for (int i = 0; i < strlen(s); i++)//遍历字符串
    {
        switch (s[i])//进行字母对照
        {
        case 'M':
            temp = temp + 1000;
            break;
        case 'D':
            temp = temp + 500;
            break; 
        case 'C'://特殊字符,搜寻其左右是否存在可以进行组合的字符
            if(s[i + 1] == 'M')
            {
                temp  = temp + 900;
                i++;
                break;
            }
            else if(s[i + 1] == 'D')
            {
                temp  = temp + 400;
                i++;
                break;
            }
            else
            {
                temp = temp + 100;
                break;
            }           
        case 'L':
            temp = temp + 50;
            break;
        case 'X'://特殊字符
            if(s[i + 1] == 'C')
            {
                temp  = temp + 90;
                i++;                
                break;
            }
            else if(s[i + 1] == 'L')
            {
                temp  = temp + 40;
                i++;
                break;
            } 
            else
            {                           
                temp = temp + 10;
                break; 
            }
        case 'V':
            temp = temp + 5;
            break; 
        case 'I'://特殊字符
            if(s[i + 1] == 'X')
            {
                temp  = temp + 9;
                i++;                
                break;
            }
            else if(s[i + 1] == 'V')
            {
                temp  = temp + 4;
                i++;
                break;
            }
            else
            {
                temp = temp + 1;
                break;                
            }     
        default:
            printf("input is error");
            break;
        }
    }
    return temp;
    
}

emmmmmm 虽然是个很暴力的方法,但是可以用

2.

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

代码实现

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int data;
    struct ListNode *next;
};//结点创建

struct ListNode *createlist();//函数声明
struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2);//函数声明

void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p)//当p==NULL就自动停下,这样写是一种很常用的方法 
     {
           printf("%d ", p->data);
           p = p->next;//链表的遍历
     }
     printf("\n");
     //上面这段还可以这样写
     /* 
     for( p=head; p!=NULL; p=p->next)       //用for()就能很简洁的写出上面的效果
	{
		printf("%d ", p->data);
	}
	*/
}

int main()
{
    struct ListNode  *list1, *list2;

    list1 = createlist();
    list2 = createlist();
    list1 = mergelists(list1, list2);
    printlist(list1);
	
    return 0;
}

struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2)
{
    if(list1==NULL&&list2==NULL)
    return NULL;//一定要防止指针为NULL,否则就会出现很严重的错误.可以使用笔者的方法也可以在整个函数体之外加一个if(*xx)这样的方法,当NULL进入循环就会出现内存错误等很奇怪的报错
    
    struct ListNode *p1,*p2,*head;
    for( p1=list1; p1->next!=NULL; p1=p1->next);//寻找链表尾节点,注意,这一句后面是分号
    p1->next=list2;//尾节点连接到list2的头指针
    p1=list1;
    /*以下方法将链表的数据存入数组,排序号再赋值给链表*/
    int n,a[100];
    for( n=0; p1!=NULL; n++,p1=p1->next)
    {
        a[n]=p1->data;//将链表数据存入数组
    }
    int i,j,temp;
    for( i=0; i<n; i++)//啊,冒个泡
    {
        for( j=0; j<n-i-1; j++)
        {
            if(a[j+1]<a[j])
            {
                temp=a[j+1];
                a[j+1]=a[j];
                a[j]=temp;
            }
        }
    }
    p1=(struct ListNode*)malloc(sizeof(struct ListNode));
    head=p1;
    for( i=0; i<n; i++)//就是创建链表写入数据,咱就不解释了
    {
        p1->data=a[i];
        if(i==n-1)//尾部的处理
        {
            p1->next=NULL;
            break;
        }
        p2=(struct ListNode*)malloc(sizeof(struct ListNode));
        p1->next=p2;
        p1=p2;
    }
    return head;
}