困难——循环控制结构~简单指针变量(动态数据结构就是链表题!!!)

循环控制结构 5道题

披着羊皮的求第几天, 涉及闰年, 做腻了.

// 送分, 我就不客气笑纳了, 3分钟写完.
#include<stdio.h>
#include<ctype.h>
int alpha[30];
int main()
{
	int i;
	char str[100];
	gets(str);
	for (i = 0; str[i]; i ++)
	{
		if (isalpha(str[i]))
		{
			alpha[str[i] - 'a'] ++;
		}
	}
	for (i = 0; i < 26; i ++)
	{
		if (alpha[i]) printf("%c=%d\n", (char)(i+'a'), alpha[i]);
	}
	
	return 0;
 } 

太长了, 不想做

// EOF不算在chars中, '\n'是算在chars中的.
#include<stdio.h>

int main()
{
	int chars = 0, lines = 0;
	char ch;
	while((ch = getchar()) != EOF)
	{
		if (ch == '\n') lines ++;
		chars++;
	}
	printf("chars=%d, lines=%d\n", chars, lines);
	return 0;
}

递归函数 1道题

// 参考答案!!
#include <stdio.h>
void movedisc(unsigned n, char fromneedle, char toneedle, char usingneedle); 
// 这个建模太重要了!!!  不然想不到. 移动 n层 从from 到 to 用 using. 
int i = 0;
int main()
{	    			     
    unsigned n;
    printf("Please enter the number of discs:");
    scanf("%d", &n);
    movedisc(n, 'a', 'b', 'c');
    printf("\tTotal:%d\n", i);
    return 0;
}	    			     
void movedisc(unsigned n, char fromneedle, char toneedle, char usingneedle)
{	    			     
    if (n == 1)
        printf("%2d-(%2d):%c==>%c\n", ++i, n, fromneedle, toneedle);
    else
    {	    			     
        movedisc(n - 1, fromneedle, usingneedle, toneedle);
        printf("%2d-(%2d):%c==>%c\n", ++i, n, fromneedle, toneedle);
        movedisc(n - 1, usingneedle, toneedle, fromneedle);
    }
}	

结构体 一道题

// 这题就描述得很清晰, 完成3个函数, 不错.
#include<stdio.h>

struct date_rec
{
	int day ;
    int month ;
    int year ;
} ;
struct date_rec current_date ;

void input_date(struct date_rec *current_date)
{
	printf("请输入当前日期（年 月 日）：");
	scanf("%d%d%d", &current_date->year, &current_date->month, &current_date->day);
}
int months[15] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
void increment_date(struct date_rec *current_date)
{
	struct date_rec *p = current_date;
	int year = p->year, month = p->month, day = p->day;
	
	//printf("%d %d %d\n", year, month, day);
	int leap = year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
	day ++;
	if (day > months[month] + leap)
	{
		month++;
		day = 1;
	}
	if (month > 12)
	{
		year ++;
		month = 1;
	}
	p->year = year;
	p->month = month;
	p->day = day;
}
void output_date(struct date_rec *current_date)
{
	printf("当前日期：%d年%d月%d日！", current_date->year, current_date->month, current_date->day);
}
int main()
{
	input_date(&current_date);
	increment_date(&current_date);
	output_date(&current_date);
	
	return 0;
}

动态数据结构 5道题

// 题干
typedef struct stack
{
    int data;
    struct stack *next;
} STACK;
STACK *head, *pr;
int nodeNum = 0;                            /* 堆栈节点数寄存器 */
STACK *CreateNode(int num);
STACK *PushStack(int num);
int PopStack(void);
int main()
{
    int pushNum[5] = {111, 222, 333, 444, 555}, popNum[5], i;
    for (i = 0; i < 5; i++)
    {
        PushStack(pushNum[i]);
        printf("Push %dth Data:%d\n", i + 1, pushNum[i]);
    }
    for (i = 0; i < 5; i++)
    {
        popNum[i] = PopStack();
        printf("Pop %dth Data:%d\n", 5 - i, popNum[i]);
    }
    return 0;
}
/* 函数功能：生成一个新的节点，并为该节点赋初值，返回指向新的节点的指针 */
STACK *CreateNode(int num)
{
    STACK *p;
    ......
    return p;
}
/*  函数功能：将整型变量num的值压入堆栈，返回指向链表新节点的指针 */
STACK *PushStack(int num)
{
    ......
    return pr;
}
/*  函数功能：将当前栈顶的数据弹出堆栈，返回从堆栈中弹出的数据 */
int PopStack(void)
{
    STACK *p = head;
    int result;
    ......
    return result;
}

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

typedef struct stack
{
    int data;
    struct stack *next;
} STACK;
STACK *head, *pr;
int nodeNum = 0;                            /* 堆栈节点数寄存器 */
STACK *CreateNode(int num);
STACK *PushStack(int num);
int PopStack(void);
int main()
{
    int pushNum[5] = {111, 222, 333, 444, 555}, popNum[5], i;
    for (i = 0; i < 5; i++)
    {
        head = PushStack(pushNum[i]); // 没加 head = , 还能这样坑人? 
        printf("Push %dth Data:%d\n", i + 1, pushNum[i]);
    }
    for (i = 0; i < 5; i++)
    {
        popNum[i] = PopStack();
        printf("Pop %dth Data:%d\n", 5 - i, popNum[i]);
    }
    return 0;
}
/* 函数功能：生成一个新的节点，并为该节点赋初值，返回指向新的节点的指针 */
STACK *CreateNode(int num)
{
    STACK *p;
    p = (STACK *) malloc(sizeof(STACK));
    p->data = num;
    return p;
}
/*  函数功能：将整型变量num的值压入堆栈，返回指向链表新节点的指针 */
STACK *PushStack(int num)
{
    STACK *pr = CreateNode(num);  
    if (head == NULL) head = pr;
    else
    {
    	pr->next = head; 
	}
    return pr;  // 她强制我们用 pr代表上一个结点, 非常合理;
}
/*  函数功能：将当前栈顶的数据弹出堆栈，返回从堆栈中弹出的数据 */
int PopStack(void)
{
    STACK *p = head;
    int result;
    head = head->next; 
	result = p->data;    
    return result;
}

// 我这方法好骚啊, 全用的递归来玩. 他题干没给清楚, 超长有多长, 如果数据给的严格的话, 那不能用递归, 那我觉得还是要用STACK栈来做, 栈s1+栈s2把它存储在链表s3(用头插法)中.  思路都还是很清晰的.
#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>

typedef struct stack{
	int data;
	struct stack *next;
}STACK; 
STACK *CreateStack(STACK *head)
{
	STACK *p = head;
	while(1)
	{
		char ch;
		scanf("%c", &ch);  //以后遇到scanf %c 就加空格能处理'\n', 但是我这里想要保存'\n' 
		//printf("%c\n", ch);		
		//if(ch == '\n') printf("AAAAAA\n");
		if(isdigit(ch)) 
		{
			//printf("%c\n", ch);
			STACK *pr = (STACK *) malloc(sizeof(STACK));
			pr->data = ch - '0';
			pr->next = p;
			p = pr;
		}
		else break;
	}
	return p;
}
void PrintNode(STACK *head)
{
	if (head == NULL) return;
	STACK *p = head;
	PrintNode(head->next);
	printf("%d", p->data);
}

void DeleteNode(STACK * head)
{
	if(head == NULL) return;
	STACK *p = head;
	DeleteNode(head->next);
	free(p);
}
void AddStack(STACK *head1, STACK *head2, int jinwei)
{
	if(head1 == NULL && head2 == NULL) 
	{
		if(jinwei) printf("%d", jinwei);
		//printf("Finish !!\n");
		return;
	}
	int sum = jinwei;
	if (head1)
	{
		sum += head1->data;
		head1 = head1->next;
	}
	if (head2)
	{
		sum += head2->data;
		head2 = head2->next;
	}
	AddStack(head1, head2, sum/10);
	printf("%d", sum % 10);
}
int main()
{
	// char *str1, *str2; // 我放弃了, 用栈可以搞 
	STACK *s1 = NULL, *s2 = NULL;
	s1 = CreateStack(s1);
	s2 = CreateStack(s2);
	printf("   s1=");
	PrintNode(s1);
	puts("");
	printf("   s2=");
	PrintNode(s2);
	puts("");
	
	// 我想继续用递归, 虽然没开空间, 但是递归空间消耗更大, 我只能怪这题出的不好. 
	printf("s1+s2=");
	AddStack(s1, s2, 0); // 递归好帅啊; 
	
	DeleteNode(s1);
	DeleteNode(s2); 
	return 0;
}

// 真几年没写了, 从struct从零开始写, 有机会在改进一下.
#include<stdio.h>
#include<stdlib.h>

struct node{
	int data;
	struct node * next;
};

int main() 
{
	int len = 0;
	
	printf("\n请输入链表（非数表示结束）\n");
	struct node *Head = (struct node *) malloc(sizeof(struct node)), *pre;
	pre = Head;
	while(1)
	{
		int n;
		printf("结点值：");
		if(scanf("%d", &n) == 0) break;
		struct node *temp = (struct node *) malloc(sizeof(struct node));
		temp->data = n;
		temp->next = NULL;		
		pre->next = temp;
		pre = temp;
		
		len++;
	}
	struct node *p;
	printf("\n原来表：\n");
	for (p = Head->next; p; p = p->next)
	{
		printf("%4d", p->data);
	}
	
	struct node *pp;
	p = Head->next;
	int flag = 1; 
	while(1)
	{
		pp = p->next;
		if(flag) // 恰好避免一堆烦人的讨论 
		{
			p->next = NULL;
			flag = 0;
		}
		else
		{
			p->next = Head->next;
			Head->next = p;
			if (pp == NULL) break;			
		}
		p = pp;
	}
	printf("\n\n反转表：\n");
	for (p = Head->next; p; p = p->next)
	{
		printf("%4d", p->data);
	}
	// 忘了怎么逆序了 
	/* 
	
	printf("\n\n反转表：\n");
	int a[100], i;
	for (i = 0, p = Head->next; p; p = p->next, i ++)
	{
		a[i] = p->data;
		// printf("%4d", p->data);
	}
	
	for (i = 0; i < len; i ++)
	{
		printf("%4d", a[len - 1 - i]);
	}
	*/ 
	 
	
	return 0;
}

// 按照模板修改的
#include<stdio.h>
#include<stdlib.h>

struct link{
	int data;
	struct link *next;
};

void DisplayNode(struct link *head)
{
	struct link *p = head;
	int j = 1;
	while(p != NULL)
	{
		// printf("%5d%10d\n", j, p->data);
		printf("The value is ==>%d\n", p->data);
		p = p->next;
		j++;
	}
}
void DeleteMemory(struct link *head)
{
	struct link *p = head, *pr = NULL;
	while(p != NULL)
	{
		pr = p;
		p = p->next;
		free(pr);
	}
}
struct link *AppendNode(struct link *head) // 返回指针,  
{
	struct link *p = NULL, *pr = head;
	int data;
	p = (struct link *) malloc(sizeof(struct link));
	if (p == NULL)
	{
		printf("No enough memory to allocate!\n");
		exit(0);
	}
	if (head == NULL)  // 若原链表为空表 
	{
		head = p;  // 将新建节点置为头节点. 
	}
	else  // 若原链表为非空, 则将新建节点添加到表尾 
	{
		while(pr->next != NULL)
		{
			pr = pr->next;	// 然pr指向下一个结点 
		}	
		pr->next = p;  // 然末节点的指针域指向新建节点 
	} 
	//printf("Input node data:") ;
	scanf("%d", &data);
	p->data = data;
	p->next = NULL;  // 将新建节点置为表尾 
	return head;
}
void reverseprint(struct link *head)
{
	if(head == NULL) return;
	reverseprint(head->next);
	printf("The value is ==>%d\n", head->data);
}

int main(void)
{
	
	return 0;
}

// 这题不给过, 估计它怕学生提交的代码没有free, 所以就不判断这道题, 哈哈.
// 我还特意写了个递归的free很是方便, DeleteMemory
#include<stdio.h>
#include<stdlib.h>

struct link{
	int data;
	struct link * next;
};
struct link * AppendNode(struct link * head)
{
	struct link *p = NULL, *pr = head;
	p = (struct link *) malloc(sizeof(struct link));
	if(head == NULL)
	{
		head = p;
	}
	else
	{
		while(pr->next != NULL) // bug!!!  
		{
			pr = pr->next;
		}
		pr->next = p;
	}
	// 最后才对p赋值!!!
	int data;
	scanf("%d", &data);
	p->data = data;
	p->next = NULL;
	return head; 
}
void PrintNode(struct link *head)
{
	struct link *p = head;
	while(p != NULL)
	{
		printf("%4d", p->data);
		p = p->next;
	}
}
struct link *DeleteNode(struct link *head, int x)
{
	struct link *p = head, *pr = head; // 先让 p就位!!!! p就是要删除的结点, pr是p的前驱结点. 
	while(p != NULL && p->data != x)  // 这思路可以啊, 找到待删除结点, 后续再做删除处理. 
	{
		pr = p;
		p = p->next; 
	}
	if (p->data == x)
	{
		if (p == head)
		{
			head = p->next;
		}
		else
		{
			pr->next = p->next;	
		} 
		free(p);
	}
	else // 妙啊 
	{
		printf("This Node has not been found! \n");
	}
	return head; 
}

void DeleteMemory(struct link *head)
{
	if(head == NULL) return;
	struct link *p = head;
	DeleteMemory(head->next);
	free(p);
}
int main() 
{
	int i, j, n, x;
	struct link *head;
	printf("输入数组6个元素的值。\n");
	for (i = 0; i < 6; i ++) 
	{
		head = AppendNode(head);
	}
	
	printf("输入要删除的数据x: ");
	scanf("%d", &x);
	printf("\n此链表各个结点的数据域为：\n");
	PrintNode(head);
	head = DeleteNode(head, x);
	printf("\n删除后链表各个结点的数据域为：\n");
	PrintNode(head);
	
	DeleteMemory(head);
			
	return 0;
}

困难——一维数组 3道题

//  这题有难度啊!!! 卧槽!!! 考这个直接寄. 大家基本都要寄. 除非遇到过原题, 不然临场想不出来的.
#define NUM 10
#include <stdio.h>
int i[NUM];
main()
{ int sum, n,total,k,flag,count=0;
  printf("Please enter requried terms (<=10):");
  scanf("%d",&n);
  printf("                             their sum:");
  scanf("%d",&total);
  sum=0;
  k=n;
  i[n]=1;
  printf("There are following possible series:\n");
  while(1)
  {	   	    		 
    if(sum+i[k]<total)
        if(k<=1)
        {i[1]=total-sum;flag=1;}
        else
        {sum+=i[k--];
         i[k]=i[k+1];
         continue;
         }
    else if(sum+i[k]>total||k!=1)
        {sum-=i[++k];
        flag=0;
        }
        else
        flag=1;
    if(flag)
    {	   	    		 
        printf("[%d]:",++count);
        for(flag=1;flag<=n;++flag)
            printf("%d",i[flag]);
        printf("\n");
    }
    if(++k>n)
        break;
    sum-=i[k];
    i[k]++;

  }
}	

// 排序后, 贪心.
#include<stdio.h>
void Sort(int a[100], int n)
{
	int i, j;
	for (i = 0; i < n; i ++)
	{
		for (j = n - 1; j > i; j --)
		{
			if (a[j] < a[j - 1])
			{
				int t = a[j - 1];
				a[j - 1] = a[j];
				a[j] = t;				
			}
		}
	}
}

int f(int a[100], int n)
{
	int res = 0, i, j;
	Sort(a, n);
	for (i = 2; i < n; )
	{
		//printf("%d\n", i);
		if (a[i] - a[i - 1] == 1 && a[i - 1] - a[i - 2] == 1) 
		{
			res ++;
			i += 3;
		}
		else i ++;
	}
	return res;
}
int main()
{
	int a[100];
	int n;
	printf("Input n:");
	scanf("%d", &n);
	printf("Input card numbers:");
	int i;
	for (i = 0; i < n; i ++)
	{
		scanf("%d", &a[i]);
	}
	printf("Exchanged:%d", f(a, n));
	
	return 0;
}

无聊

困难——简单指针变量 1道题

// 困难完结撒花✿✿ヽ(°▽°)ノ✿
#include<stdio.h>

int main()
{
	char str[100];
	printf("请输入一个字符串，长度小于等于100：") ;
	gets(str);
	printf("该字符串的内存编码为： ");
	int i;
	for (i = 0; str[i]; i ++)
	{
		printf("%x ", (unsigned char)str[i]); // 为了不输出多余的ffff, 因为char可以为负数; 
	}
	return 0;
}