精华内容
下载资源
问答
  • 数据结构基本算法录入

    千次阅读 2018-10-26 10:28:55
    本文主要收录《数据结构(C语言版)》第五版的基本算法,算法包括顺序表,栈,队列等。收录的算法是使用C语言实现的,在调用的时候请注意传参的类型。特别是对指针参数的传入。 宏&基本算法 宏定义(所有...

    说明

    在录入时还存在着诸多问题,以后会慢慢改正。

    本文主要收录《数据结构(C语言版)》第五版的基本算法,算法包括顺序表,栈,队列等。收录的算法是使用C语言实现的,在调用的时候请注意传参的类型。特别是对指针参数的传入。

    宏&基本算法

    宏定义(所有算法必须引入)

    /*
    **数据结构头文件
    **宏定义&基本算法及结构
    **asorb&201810
    */
    #include<stdio.h>
    #include<stdlib.h>
    
    //状态码
    #define TRUE 1
    #define FALSE 0
    #define OK 1
    #define ERROR 0
    #define INFEASIBLE -1
    #define OVERFLOW -2
    //函数返回状态码类型
    typedef int Status;
    

    线性表&顺序表

    /*线性表.顺序表&结构&算法*/
    typedef int ElemType;
    
    #define LIST_INIT_SIZE 100		//线性表存储空间的初始分配量
    #define LISTINCREMENT 10		//线性表存储空间的分配增量
    typedef struct {
    	ElemType *elem;
    	int length;			//当前长度
    	int listsize;		//当前分配的存储容量(以sizeof(ElemType)为单位)
    }SqList;
    
    Status InitList_Sq(SqList *L){
    	L->elem = (ElemType*)malloc(sizeof(ElemType)*LIST_INIT_SIZE);
    	if (!L->elem) exit(OVERFLOW);		//空间分配失败
    	L->length = 0;
    	L->listsize = LIST_INIT_SIZE;
    	return OK;
    }//构造一个空的线性表L
    Status DestroyList_Sq(SqList *L){
    	free(L->elem);
    	if (L->elem) return ERROR;
    	L->length = 0;
    	L->listsize = 0;
    	return OK;
    }//销毁线性表L
    Status ClearList_Sq(SqList *L){
    	L->length = 0;
    	return OK;
    }//将L重置为空表
    Status ListEmpty_Sq(SqList L){
    	if (L.length == 0)return TRUE;
    	else return FALSE;
    }//若L为空表,则返回TRUE,否则返回FALSE
    int ListLength_Sq(SqList L){
    	return L.length;
    }//返回L中的元素个数
    Status GetElem_Sq(SqList L,int i, ElemType *e){
    	if (i<1 || i>L.length)return ERROR;
    	*e = *(L.elem + i - 1);
    	return OK;
    }//用e返回L中第i个元素的值
    int LocateElem_Sq(SqList L, ElemType e, Status compare(ElemType,ElemType)){
    	int i = 0;
    	while (i < L.length){
    		if (compare(*(L.elem + i), e))
    			return i + 1;
    		i++;
    	}
    	return 0;
    }//返回L中第一个与e满足关系compare()的数据元素的位序。若这样的元素不存在,则返回值为0
    Status PriorElem_Sq(SqList L, ElemType cur_e, ElemType *pre_e){
    	for (int i = 1; i < L.length; i++){
    		if (*(L.elem + i) == cur_e){
    			*pre_e = *(L.elem + i - 1);
    			return TRUE;
    		}
    	}
    	return FALSE;
    }//用pre_e返回cur_e的前驱
    Status NextElem_Sq(SqList L, ElemType cur_e, ElemType *next_e){
    	for (int i = 0; i < L.length - 1; i++){
    		if (*(L.elem + i) == cur_e){
    			*next_e = *(L.elem + i + 1);
    			return TRUE;
    		}
    	}
    	return FALSE;
    }//用next_e返回cur_e的后继
    Status ListInsert_Sq(SqList *L, int i, ElemType e){
    	if (i<1 || i>L->length + 1)return ERROR;
    	if (L->length >= L->listsize){//空间不足,增加空间
    		L->elem = (ElemType*)realloc(L->elem, sizeof(ElemType)*(L->listsize + LISTINCREMENT));
    		if (!L->elem)exit(OVERFLOW);			//分配失败
    		L->listsize += LISTINCREMENT;
    	}
    	for (int ii = L->length; ii >= i; ii--){//i位以后开始后移
    		*(L->elem + ii) = *(L->elem + ii - 1);
    	}
    	*(L->elem + i - 1) = e;
    	L->length++;
    	return OK;
    }//在L中的第i个位置前插入e,L的长度加1
    Status ListDelete_Sq(SqList *L, int i, ElemType *e){
    	if (i < 1 || i>L->length)return ERROR;
    	*e = *(L->elem + i - 1);
    	for (int ii = i - 1; ii < L->length - 1; ii++){//i位以后前移覆盖
    		*(L->elem + ii) = *(L->elem + ii + 1);
    	}
    	L->length--;
    	return OK;
    }//删除L的第i的数据元素,并用e返回其值,L的长度减1
    Status ListTraverse_Sq(SqList L, Status visit(ElemType*)){
    	if (L.length == 0)return ERROR;
    	for (int i = 0; i < L.length; i++)
    	if (!visit(L.elem + i))return ERROR;
    	return OK;
    }//依次对L中的每个数据元素调用visit()

    线性表&链表

    /*线性表.链表&结构&算法*/
    typedef struct LNode{
    	ElemType data;
    	struct LNode *next;
    }*Link,Position;
    typedef struct{
    	Link head, tail;		//分别指向线性链表中的头结点和最后一个结点
    	int len;		//指示线性表元素的个数
    }LinkList;
    Status MakeNode(Link *p, ElemType e){
    	(*p) = (Link)malloc(sizeof(Position));
    	if (!(*p))return ERROR;
    	(*p)->data = e;
    	(*p)->next = NULL;
    	return OK;
    }//分配由p指向的值为e的结点,并返回OK,否则返回ERROR
    void FreeNode(Link p){
    	free(p);
    }//释放p所指的结点
    
    Status InitList_L(LinkList *L){
    	L->head = (Link)malloc(sizeof(Position));
    	if (!L->head)exit(OVERFLOW);	//空间分配失败
    	L->head->next = NULL;
    	L->tail = L->head;
    	L->len = 0;
    	return OK;
    }//构造一个空的线性链表L
    Status DestroyList_L(LinkList *L){
    	L->tail = L->head->next;
    	while (L->tail){
    		L->head->next = L->tail->next;
    		free(L->tail);
    		L->tail = L->head->next;
    	}
    	free(L->head);
    	L->len = 0;
    	return OK;
    }//销毁L,L不在存在
    Status ClearList_L(LinkList *L){
    	L->tail = L->head->next;
    	while (L->tail){
    		L->head->next = L->tail->next;
    		free(L->tail);
    		L->tail = L->head->next;
    	}
    	L->tail = L->head;
    	L->len = 0;
    	return OK;
    }//重置L为空表,释放原链表的结点空间
    Status InsFirst_L(Link h, Link s){
    	s->next = h->next;
    	h->next = s;
    	return OK;
    }//已知h指向线性表头结点,将s所指结点插入在第一个结点之前
    Status DelFirst_L(Link h, Position *q){
    	Link p = h->next;
    	if (!p)return ERROR;		//表空
    	h->next = p->next;
    	*q = *p;
    	free(p);
    	return OK;
    }//已知h指向线性表头结点,删除链表中的第一个结点并以q返回
    Status Append_L (LinkList *L, Link s){
    	L->tail->next = s;
    	while (s){
    		L->tail = s;
    		L->len++;
    		s = s->next;
    	}
    	return OK;
    }//把s所指指针接在L的最后一个结点之后,并改变链表L的尾指针指向新的尾结点
    Status Remove_L(LinkList *L, Position *q){
    	Link p = L->tail;
    	if (L->head == L->tail)return ERROR;		//表空
    	*q = *(L->tail);
    	L->tail = L->head;
    	while (L->tail->next != p)
    		L->tail = L->tail->next;
    	free(p);
    	L->len--;
    	return OK;
    }//删除线性表L中的尾结点并以返回,改变链表L的尾指针指向新的尾结点
    Status InsBefore_L(LinkList *L, Link p, Link s){
    	Link q = L->head->next;
    	while (q->next != p&&q->next != NULL)
    		q = q->next;
    	q->next = s;
    	s->next = p;
    	p = s;
    	L->len++;
    	return OK;
    }//已知p指向线性表L中的一个结点,将s所指结点插入在p所指结点前
    Status InsAfter_L(LinkList *L, Link p, Link s){
    	Link q = p->next;
    	p->next = s;
    	s->next = q;
    	if (p == L->tail)
    		L->tail = s;
    	L->len++;
    	return OK;
    }//已知p指向线性表L中的一个结点,将s所指结点插入在p所指结点后
    Status SetCurElem_L(Link p, ElemType e){
    	p->data = e;
    	return OK;
    }//已知p指向线性表中的一个结点,用e更新p所指结点的值
    ElemType GetCurElem_L(Link p){
    	return p->data;
    }//已知p指向线性表中的一个结点,返回p所指结点数据元素的值
    Status ListEmpty_L(LinkList L){
    	if (L.len == 0)return TRUE;
    	else return FALSE;
    }//若线性表L为空,则放回TRUE,否则返回FALSE
    int ListLength_L(LinkList L){
    	return L.len;
    }//返回线性表L中的元素个数
    Position* GetHead_L(LinkList L){
    	return L.head;
    }//返回L中头结点位置
    Position* GetLast_L(LinkList L){
    	return L.tail;
    }//返回线性表L中最后一个结点位置
    Position* PriorPos_L(LinkList L, Link p){
    	Link q = L.head->next;
    	while (q->next != p&&q != NULL)
    		q = q->next;
    	return q;
    }//已知p指向L中的一个结点,返回其前驱
    Position* NextPos_L(LinkList L, Link p){
    	return p->next;
    }//已知p指向线性表L中的一个结点,返回p所指结点的直接后继位置
    Status LocatePos_L(LinkList L, int i, Link *p){
    	if (i<1 || i>L.len)return ERROR;
    	*p = L.head;
    	for (i; i >= 1; i--){
    		*p= (*p)->next;
    	}
    	return OK;
    }//返回p指示线性表L中第i个结点的位置并返回OK,i不合法返回ERROR
    Position* LocateElem_L(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType)){
    	Link p = L.head;
    	while (p){
    		if ((*compare)(e, p->data))
    			return p;
    		p = p->next;
    	}
    	return NULL;
    }//返回线性表中第一个与e满足函数compare()判定关系的元素的位置,没有返回NULL
    Status ListTraverse_L(LinkList L, Status(*visit)(ElemType)){
    	Link p = L.head;
    	while (p){
    		if (!(*visit)(p->data))return ERROR;
    		p = p->next;
    	}
    	return OK;
    }//依次对L的每个元素调用函数visit()。一旦失败,则操作失败

    /*栈&结构&算法*/
    typedef int SElemType;
    
    #define STACK_INIT_SIZE 100		//存储空间初始分配量
    #define STACKINCREMENT 10		//存储空间分配增量
    
    typedef struct{
    	SElemType *base;		//在栈构造之前和销毁之后,base的值为NULL
    	SElemType *top;			//栈顶指针
    	int stacksize;		//当前已分配的存储空间,以元素为单位
    }SqStack;
    
    Status InitStack(SqStack *S){
    	S->base = (SElemType*)malloc(sizeof(SElemType)*STACK_INIT_SIZE);
    	if (!S->base)exit(OVERFLOW);		//分配失败
    	S->top = S->base;
    	S->stacksize = STACK_INIT_SIZE;
    	return OK;
    }//构造一个空栈S
    Status DestroyStack(SqStack *S){
    	free(S->base);
    	S->base = NULL; S->top = NULL;
    	S->stacksize = 0;
    	return OK;
    }//销毁栈S,S不再存在
    Status ClearStack(SqStack *S){
    	S->top = S->base;
    	return OK;
    }//把栈S置空
    Status StackEmpty(SqStack S){
    	if (S.base == S.top)return TRUE;
    	else return FALSE;
    }//栈为空返回TRUE,否则返回FALSE
    int StackLength(SqStack S){
    	int SElem_num = 0;
    	SElem_num = S.top - S.base;
    	return SElem_num;
    }//放回S的元素个数,即栈的长度
    Status GetTop(SqStack S, SElemType *e){
    	if (StackEmpty(S))return ERROR;		//栈空
    	*e = *(S.top - 1);
    	return OK;
    }//若栈不空,则用e返回S的栈顶元素,并返回OK,否则返回ERROR
    Status Push(SqStack *S, SElemType e){
    	if (S->top - S->base >= S->stacksize){
    		//栈满,追加空间
    		S->base = (SElemType*)realloc(S->base, sizeof(SElemType)*(S->stacksize + STACKINCREMENT));
    		if (!S->base)exit(OVERFLOW);		//分配失败
    		S->top = S->base + S->stacksize;
    		S->stacksize += STACKINCREMENT;
    	}
    	*S->top ++ = e;
    	return OK;
    }//插入元素e为新的栈顶元素
    Status Pop(SqStack *S, SElemType *e){
    	if (StackEmpty(*S))return ERROR;		//栈空
    	*e = * -- S->top;
    	return OK;
    }//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR
    Status StackTraverse(SqStack S, Status(*visit)(SElemType *e)){
    	if (StackEmpty(S))return ERROR;		//栈空
    	for (int i = 0; S.base + i < S.top; i++)
    		if(!(*visit)(S.base + i))return ERROR;
    	return OK;
    }//从栈低依次对栈中的每个元素调用函数visit()。一旦visit()失败,则操作失败

    队列

    /*队列&结构&算法*/
    /*单链队列,队列的链式存储结构*/
    typedef int QElemType;
    
    typedef struct QNode{
    	QElemType data;
    	struct QNode *next;
    }QNode,*QueuePtr;
    typedef struct{
    	QueuePtr front;		//队头指针
    	QueuePtr rear;		//队尾指针
    }LinkQueue;
    
    Status InitQueue(LinkQueue *Q){
    	Q->front = (QueuePtr)malloc(sizeof(QNode));
    	if (!Q->front)exit(OVERFLOW);		//空间分配失败
    	Q->rear = Q->front;
    	return OK;
    }//构造一个空队列
    Status DestroyQueue(LinkQueue *Q){
    	while (Q->front){
    		Q->rear = Q->front->next;
    		free(Q->front);
    		Q->front = Q->rear;
    	}
    	return OK;
    }//销毁队列Q,Q不在存在
    Status ClearQueue(LinkQueue *Q){
    	QueuePtr p = Q->front;
    	while (p){
    		Q->rear = p->next;
    		free(p);			//逐个释放空间
    		p = Q->rear;
    	}
    	Q->rear = Q->front;		//置空
    	return OK;
    }//将Q清为空队列
    Status QueueEmpty(LinkQueue Q){
    	if (Q.rear == Q.front)return TRUE;
    	else return FALSE;
    }//若队列Q为空队列,则返回TRUE,否则返回FALSE
    int QueueLength(LinkQueue Q){
    	int QueueL = 0;
    	QueueL = Q.rear - Q.front;
    	return QueueL;
    }//返回Q的元素个数,即为队列的长度
    Status GetHead(LinkQueue Q, QElemType *e){
    	if (QueueEmpty(Q)) return ERROR;		//队空
    	*e = Q.front->next->data;
    	return OK;
    }//若e不空,用e返回Q队头元素,并返回OK,否则返回ERROR
    Status DeQueue(LinkQueue *Q, QElemType *e){
    	QueuePtr p = NULL;
    	if (QueueEmpty(*Q))return ERROR;
    	p = Q->front->next;
    	Q->front->next = p->next;
    	*e = p->data;
    	if (Q->rear == p)Q->rear = Q->front;
    	free(p);
    	return OK;
    }//若e不空,则删除Q的队头元素,用e返回其值,并返回OK,否则ERROR
    Status QueueTraverse(LinkQueue Q, Status visit(QElemType*)){
    	QueuePtr p;
    	if (QueueEmpty(Q))return ERROR;
    	p = Q.front->next;
    	for (int i = QueueLength(Q); i > 0; i--){
    		if (!visit(&(p->data)))return ERROR;
    		p = p->next;
    	}
    	return OK;
    }//从队头到队尾,依次对Q的每个元素调用函数visit(),失败则返回ERROR


    本文内容正在持续更新中….结尾

    参考:数据结构(C语言版)第五版-严蔚敏

    展开全文
  • 基本算法:python递归算法

    千次阅读 2017-09-24 16:44:33
    最近在做语义识别的项目,为了对语义识别的算法有一个深入的了解,所以抽出部分精力研究一下递归算法,递归作为最简单的基本算法,不是很难,原理大家都理解,下面我就结合我的理解,讲解一下递归算法: ...

    有时候写代码就是“老中医给别人看病“,经验很重要!
    最近在做语义识别的项目,为了对语义识别的算法有一个深入的了解,所以抽出部分精力研究一下基本算法。递归作为最简单的基本算法,不是很难,原理大家都理解,下面我就结合我的理解,讲解一下递归算法:
    一)递归的定义:
    递归就是子程序(或函数)直接调用自己或通过一系列调用语句间接调用自己,是一种描述问题和解决问题的基本方法。递归常用来解决结构相似的问题。所谓结构相似,是指构成原问题的子问题与原问题在结构上相似,可以用类似的方法解决。具体地,整个问题的解决,可以分为两部分:第一部分是一些特殊情况,有直接的解法;第二部分与原问题相似,但比原问题的规模小,并且依赖第一部分的结果。实际上,递归是把一个不能或不好解决的大问题转化成一个或几个小问题,再把这些小问题进一步分解成更小的小问题,直至每个小问题都可以直接解决。因此,递归有两个基本要素:
    (1) 边界条件:确定递归到何时终止,也称为递归出口。
    (2) 递归模式:大问题是如何分解为小问题的,也称为递归体。
    递归函数只有具备了这两个要素,才能在有限次计算后得出结果。
    (二)基本例子:
    我们来计算阶乘 n! = 1 * 2 * 3 * … * n,用函数 fact(n)表示,可以看出:fact(n) = n! = 1 * 2 * 3 * … * (n-1) * n = (n-1)! * n = fact(n-1) * n
    所以,fact(n)可以表示为 n * fact(n-1),只有n=1时需要特殊处理(只就是我们的边界条件)。
    于是,fact(n)用递归的方式写出来就是:

    def fact(n):
    if n==1:
      return 1
    return n * fact(n - 1)

    上面就实现了一个简单的递归函数。
    同时需要注意:使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。会报错:`RecursionError: maximum recursion depth exceeded in comparison
    (三)经典例子实现:汉诺塔问题
    汉诺塔问题是递归函数的经典应用,它来自一个古老传说:在世界刚被创建的时候有一座钻石宝塔A,其上有64个金蝶。所有碟子按从大到小的次序从塔底堆放至塔顶。紧挨着这座塔有另外两个钻石宝塔B和C。从世界创始之日起,波罗门的牧师就一直在试图把塔A上的碟子移动到C上去,其间借助于塔B的帮助。每次只能移动一个碟子,任何时候都不能把一个碟子放在比它小的碟子上面。当牧师们完成这个任务时,世界末日也就到了。
    下面我们对汉诺塔问题进行求解:
    (1)将塔A上的n -1个碟子借助C塔先移动到B塔上;
    (2)把塔A上剩下的一个碟子移动到塔C上;
    (3)将n - 1个碟子从B塔借助塔A移动到塔C上。
    很显然,这是一个递归求解的过程,假设碟子数n=3时,汉诺塔问题的求解过程如下图所示:
    这里写图片描述
    汉诺塔的递归算法(Python实现):

    def Hanoi(n, A, B, C) :
      if (n == 1) :
        move(A, c)   #表示只有一个碟子时,直接从A塔移动到C塔
      else :
        Hanoi(n - 1, A, C, B)  #将剩下的A塔上的n-1借助C塔移动到B塔
        move(A, C)              #将A上最后一个直接移动到C塔上
        Hanoi(n - 1, B, A, C)  #将B塔上的n-1个碟子借助A塔移动到C塔

    递归函数的运行轨迹
    借助汉诺塔这个实例,来讲解一下递归函数的运行轨迹。在递归函数中,调用函数和被调用函数都是同一个函数,需要注意的是函数的调用层次,如果把调用递归函数的主函数称为第0层,进入函数后,首次递归调用自身称为第1层调用;从第i层递归调用自身称为第i+1层。反之退出i+1层调用应该返回第i层。下图是n=3时汉诺塔算法的运行轨迹,有向弧上的数字表示递归调用和返回的执行顺序。这里写图片描述
    上面就是我对递归函数的理解。

    `

    展开全文
  • 基本算法语句

    千次阅读 2013-04-02 07:47:10
    基本算法语句 教学目标:通过实例,使学生理解3种基本的算法语句(输入语句、输出语句和赋值语句)的表示方法、结构和用法,能用这三种基本的算法语句表示算法,进一步体会算法的基本思想。 教学重点:输入语句...

    基本算法语句

    教学目标:通过实例,使学生理解3种基本的算法语句(输入语句、输出语句和赋值语句)的表示方法、结构和用法,能用这三种基本的算法语句表示算法,进一步体会算法的基本思想。

    教学重点:输入语句、输出语句和赋值语句的表示方法、结构和用法,用这三种基本的算法语句表示算法。

    教学难点:理解输入语句、输出语句和赋值语句的表示方法、结构和用法。

    教学工具:电脑。

    教学过程:

    一、引入新课

    1、算法中的三种基本的逻辑结构是          、            、           。

    2、任何一种程序设计语言都包含五种基本的算法语句,它们分别是输入语句、输出语句、赋值语句、条件语句和循环语句。

    二、新课讲解

    1、输入语句、输出语句和赋值语句基本上对应于算法中的顺序结构。下面的例题是用这三种基本的算法语句表示的一个算法。

    例:用描点法作函数yx3+3x2-24x30的图象时,需要求出自变量和函数的一组对应值。编写程序,分别计算当x=-5,-4,-3,-2,-1012345时的函数值。

    程序:INPUTx=”;x                                       输入语句

          yx^33x^224*x30                                 赋值语句

          PRINT  x=”;x                                     打印语句

          PRINT  y=”;y                                     打印语句

          END

    2、输入语句

    1)输入语句的一般格式

    2)输入语句的作用是实现算法的输入信息功能;

    3)“提示内容”提示用户输入什么样的信息,变量是指程序在运行时其值是可以变化的量;

    4)输入语句要求输入的值只能是具体的常数,不能是函数、变量或表达式;

    5)提示内容与变量之间用分号“;”隔开,若输入多个变量,变量与变量之间用逗号“,”隔开。

    3、输出语句

    1)输出语句的一般格式

    2)输出语句的作用是实现算法的输出结果功能;

    3)“提示内容”提示用户输入什么样的信息,表达式是指程序要输出的数据;

    4)输出语句可以输出常量、变量或表达式的值以及字符。

    4、赋值语句

    1)赋值语句的一般格式

    2)赋值语句的作用是将表达式所代表的值赋给变量;

    3)赋值语句中的“=”称作赋值号,与数学中的等号的意义是不同的。赋值号的左右两边不能对换,它将赋值号右边的表达式的值赋给赋值号左边的变量;

    4)赋值语句左边只能是变量名字,而不是表达式,右边表达式可以是一个数据、常量和算式;

    5)对于一个变量可以多次赋值。

    1、给任意三个变量abc赋值,求b2-4ac的值。

    程序是:

    练习一:1、课本第13页思考、第14页思考、第15页思考。

    2、若三角形的三边长分别为abc,利用三角形面积公式S,其中p2(a+b+c),编写一个求三角形面积的程序。

    2、编写一个程序,计算一个学生数学、语文、英语三门课的平均成绩。

    程序一:                                       或

    程序二:

    通过上机操作比较两个程序的区别:程序一可以计算任何一个学生的平均成绩,而程序二只能计算一个学生的平均成绩。

    练习二:课本第15页第1234

    3、给一个变量重复赋值。

    程序:

    对于一个变量可以多次赋值,变量的值就是最后一次的赋值。

    4、交换两个变量AB的值,并输出交换前后的值。

    程序:                           或

    用赋值语句将两个变量的值交换,这时要引入一个中间变量x,暂时存放A的值,并把其传递给B

    练习三:

    1、 写出右边程序运行的结果:

    若输入102030,则输出结果为

                               。

    2、判断下列给出的输入语句、输出语句和赋值语句是否正确?为什么?

    1)输入语句 INPUT   abc

    2)输入语句 INPUT   x3

    3)输出语句 A4

    4)输出语句 PRINT  20.3*2

    5)赋值语句 3B

    6)赋值语句  xy0

    7)赋值语句  AB=-2

    8)赋值语句  TT*T

    略解:(1)错,变量之间应用“,”号隔开;

         (2)错,INPUT语句中只能是变量,而不能是表达式;

         (3)错,PRINT语句不能用赋值号“=”;

         (4)正确,PRINT语句可以输出常量、表达式的值;

         (5)错,赋值语句中“=”号左右不能互换;

         (6)错,不能给一个表达式赋值;

         (7)错,一个赋值语句只能给一个变量赋值;

         (8)正确,该句的功能是将当前T的值平方后再赋给变量T

    三、本课小结

    1、 利用三种语句编写程序时应明确:

    需输入信息时用INPUT语句,需输出信息时用PRINT语句,当变量需要的数据较少或给变量赋予算式时,用赋值语句,当变量需要输入多组数据且程序重复使用时,使用输入语句较好。

    2、赋值语句是最重要的一种基本语句,也是一个程序必不可少的重要组成部分。使用赋值语句,一定要注意其格式要求,如:赋值号左边只能是变量而不能是表达式;赋值号左右两边不能对换;不能利用赋值语句进行代数式计算等。

    3、利用赋值语句可以实现两个变量值的互换,方法是引进第三个变量,用三个赋值语句完成。

    4BASIC语言中的标准函数,如SQRx)表示x的算术平方根,ABSx)表示x的绝对值。

    四、布置作业:

    1、课本第23页第12题;

    2、 写出用公式法求x2-2x80的根的程序。

    3、 写出求直线上两点AB的距离的程序。

    基本算法语句(第2课时)

    珠海北大附属实验学校   何莲姣

    教学目标:通过实例,使学生理解条件语句的表示方法、结构和用法,能用条件语句表示算法,进一步体会算法的基本思想。

    教学重点:条件语句的表示方法、结构和用法,用条件语句表示算法。

    教学难点:理解条件语句的表示方法、结构和用法。

    教学工具:电脑。

    教学过程:

    一、引入新课

    1、输入语句的一般格式是      ,其作用是实现算法的       ;输出语句的一般格式是      ,其作用是实现算法         ;赋值语句的一般格式是      ,其作用是        。

    2、用输入语句、输出语句和赋值语句编写程序。

    3、算法逻辑结构中的条件结构一般由算法语言中的       来实现。

    二、讲授新课

    1、条件语句的一般格式有两种:

    1IFTHENELSE语句;(2IFTHEN语句。

    2IFTHENELSE语句

    1IFTHENELSE语句的一般格式为图1,对应的程序框图为图2

      

                                      

    1                                          2

    2)在IFTHENELSE语句中,“条件”表示判断的条件,“语句1”表示满足条件时执行的操作内容;“语句2”表示不满足条件时执行的操作内容;END  IF表示条件语句的结束。计算机在执行时,首先对IF后的条件进行判断,如果条件符合,则执行THEN后面的语句1;若条件不符合,则执行ELSE后面的语句2

    3IFTHEN语句

    1IFTHEN语句的一般格式为图3,对应的程序框图为图4

     

    3                                         4

    2)“条件”表示判断的条件;“语句”表示满足条件时执行的操作内容,条件不满足时,结束程序;END  IF表示条件语句的结束。计算机在执行时首先对IF后的条件进行判断,如果条件符合就执行THEN后边的语句,若条件不符合则直接结束该条件语句,转而执行其它语句。

                          x2-1x0),

    1、已知函数f(x)=                 编写一个程序,对每输入的一个x值,都得到

                          2x2-5x0),

    相应的函数值。

    分析:这是一个分段函数,计算函数值必须先判断x的范围,因而设计求函数值的算法必须用到条件结构,相应程序的书写也应用条件语句书写。

    解:用变量xy分别表示自变量和函数值。

    算法:

    第一步:输入x值;

    第二步:判断x的范围,若x0,则用函数yx2-1求函数值,否则用y2x2-5求函数值。

    第三步:输出y的值。

    程序:可分别用IFTHENELSE语句和IFTHEN语句表示程序。

    练习一:            2x2-1   x0),

    1、已知函数f(x)=   2x1    x0),编写一个程序,对每输入的一个x值,

    2x2+4x x0),

    都得到相应的函数值。(条件语句的嵌套)

    2课本第20页第12题。

    2、编写程序,输入一元二次方程ax2+bxc0的系数,输出它的实数根。

    算法分析:

    在求解方程之前,需要首先判断判别式的符号,再根据判别式的符号判断方程根的情况:△>0时,方程有两个不相等的实数根;△=0时,方程有两个相等的实数根;△<0时,方程没有实数根。这个过程可以用算法中的条件结构来表示。

    程序框图:见课本第17页。

    程序:

    练习二:

    1、阅读课本第1819页例题6:这是用IFTHEN语句表示的一个程序。

    2、 把下列程序补充完整:

    1)输入两个数,输出其中较大的数;

    2)判断输入的任意数x的奇偶性。

    你能用IFTHEN语句表示这两个程序吗?

    三、小结

    1、条件语句:用来实现算法中的条件结构。

    1)条件语句的两种形式(1IFTHENELSE语句;(2IFTHEN语句;

    2)条件语句的两种形式的一般格式;

    3)条件语句的嵌套。

    2、编程的一般步骤:

    1)算法分析

    根据提供的问题,利用数学及相关学科的知识,设计出解决问题的算法(熟悉之后可在大脑中进行);

    2)画出程序框图

    依据算法分析,画出程序框图(可在草稿纸上进行);

    3)写出程序

    根据程序框图中的算法步骤,逐步把算法用相应的程序语句表达出来。

    四、布置作业

    课本第23页第3题,第24B组第2题。

    基本算法语句(第3课时)

    教学目标:通过实例,使学生理解两种循环语句的表示方法、结构和用法,能用两种循环语句表示算法,进一步体会算法的基本思想。

    教学重点:两种循环语句的表示方法、结构和用法,用循环语句表示算法。

    教学难点:理解循环语句的表示方法、结构和用法。

    教学工具:电脑。

    教学过程:

    一、引入新课

    1、条件语句的一般格式有两种,一种是         ,另一种是          。

    2、算法中的循环结构是由      语句来实现的,对应于程序框图中的两种循环结构,循环语句也有两种:当型(WHILE)语句和直到型(UNTIL)语句。

    二、新课讲授

    1WHILE语句

    1WHILE语句的一般格式是                  对应的程序框图是

    2)计算机执行此程序时,遇到WHILE语句,先判断条件是否成立,如果成立,则执行WHILEWEND之间的循环体,然后再判断上述条件,再执行循环体,这个过程反复执行,直到某一次不符合条件为止,这时不再执行循环体,将跳到WEND语句后,执行WEND后面的语句。

    2UNTIL语句

    1UNTIL语句的一般格式是                对应的程序框图是

    2)计算机执行UNTIL语句时,先执行DOLOOP  UNTIL之间的循环体,然后判断条件是否成立,如果不成立,执行循环体。这个过程反复执行,直到某一次符合条件为止,这时不再执行循环体,跳出循环体执行LOOP  UNTIL后面的语句。

    3、当型循环与直到型循环的区别

    1)当型循环先判断后执行,直到型循环先执行后判断;

    2)当型循环用WHILE语句,直到型循环用UNTIL语句;

    3)对同一算法来说,当型循环和直到型循环的条件互为反条件。

    1、编写计算机程序计算123+……+100的值。

    程序(WHILE语句):                        程序(UNTIL语句):

    练习一、课本第23页练习第23题。(分别用两种循环语句表示算法)

    2、设计一个计算1×3×5×7×…×99的算法,编写算法程序。

    算法如下:                                  程序(WHILE语句)如下:

    第一步:s1

    第二步:i3

    第三步:ss×i

    第四步:ii2

    第五步:如果i99,那么转到第三步;

    第六步:输出s

    你能用UNTIL语句表示这一程序吗?

    答案:

    练习二、写出下列程序运算功能的算术表达式(不计算,只写式子)。

    1N=2                               2i=1

    T=1                                    S=0

    WHILE  N=5                         WHILE  i10

    T=N*T                                  S=S+1/(2*i+1)

    N=N+1                                  i=i+1

    WEND                                  WEND

    PRINT  T                               PRINT  S

    END                                    END

    上述程序的表达式为          ;          上述程序的表达式为           。

    3、设计一个求20个数的算术平均数的算法,写出其程序。

    分析:可用一个循环依次输入20个数,并将它们的和存在一个变量S中,最后用S除以20即可得到这20个数的平均数。

    程序如下:

    你可以用WHILE语句表示这一程序吗?

    创新应用:

    相传古代印度国王舍罕要褒赏他的聪明能干的宰相达依尔(国际象棋发明者),问他需要什么,达依尔回答说:“国王只要在国际象棋的棋盘第一个格子里放一粒麦子,第二个格子里放二粒,第三个格子里放四粒,以后按比例每一格加一倍,一直放到第64格(国际象棋盘是8×8=64格),我就感恩不尽,其他我什么也不要了。”国王想:“这有多少!还不容易!”让人扛来一袋小麦,但不到一会儿全没了,再来一袋很快又没了,结果全印度的粮食全部用完还不够,国王纳闷,怎样也算不清这笔帐,请你设计一个算法,帮国王计算一个,共需多少粒麦子,写出程序。

    解:依题意,本题是求1222+23+…+263的值。

    算法:

    第一步:令S0i=0

    第二步:P2i,SSPi=i+1

    第三步:如果i≤63,那么转第二步;

    第四步:输出S

    程序如下:

    三、本课小结

    1、循环语句的两种不同形式:WHILE语句和UNTIL语句,掌握它们的一般格式。

    2、在用WHILE语句和UNTIL语句编写程序解决问题时,一定要注意它们的格式及条件的表述方法。WHILE语句中是当条件满足时执行循环体,而UNTIL语句中是当条件不满足时执行循环体。

    四、布置作业

    课本第23页习题第345题。

    展开全文
  • C语言基础-基本算法

    千次阅读 2018-03-19 22:33:07
    C语言基础-基本算法 在之前的两篇文章中介绍了C语言的入门程序入门程序1,入门程序2,从这篇文章我们就开始介绍C语言基础。 今天来给大家介绍算法的特性和算法的表示。 算法的基本特性 算法包含两方面的内容:...

    C语言基础-基本算法

    在之前的两篇文章中介绍了C语言的入门程序入门程序1入门程序2,从这篇文章我们就开始介绍C语言基础。
    今天来给大家介绍算法的特性和算法的表示。

    算法的基本特性

    算法包含两方面的内容:算法设计和算法分析

    算法设计其实就是针对某一特定类型的问题而设计的一个实现过程。算法有以下几个特性:

    • 有穷性
    • 确定性
    • 可行性
    • 输入
    • 输出

    也就是说我们在设计算法是的满足上面所说的特性。当然算法也是有好有坏的,那么我们怎样去衡量一个算法的优劣呢?
    算法分析其实就是在衡量一个算法的优劣,通常会从一下几个方面来分析:

    1. 正确性
    2. 可读性
    3. 健壮性
    4. 时间复杂度和空间复杂度

    算法的表达方式

    在描述一个算法时通常使用的方法有:自然语言、流程图、N-S图等。

    自然语言

    自然语言这种表达方式通俗易懂,我们通过一个具体的实例了解一下。
    需求:任意输入3个数,求出其中的最小数。
    (1) 定义4个变量分别是a,b,c和min。
    (2) 输入大小不同的三个数分别赋值给a,b,c。
    (3) 判断a是否小于b,如果小于,则将a的值赋给min,否则将b的值赋给min。
    (4) 判断min是否小于c,如果小于,则执行(5),否则将c的值赋给min。
    (5) 输出min。
    这种表达方式的好处就是简单易懂,但是当遇到复杂的算法时自然语言就显得不是很方便了。

    流程图

    流程图就是用一些图框来代表各种不同性质的操作,用流程线来指示算法的执行方向。他的特点就是直观形象,应用很广泛。
    下图介绍了流程图的符号以及含义
    这里写图片描述

    流程图有三种基本结构,即顺序结构、选择结构和循环结构。

    • 顺序结构:顺序结构就是简单的线性结构

    这里写图片描述

    • 选择结构:选择结构也称为分支结构

    这里写图片描述

    • 循环结构:反复执行一系列操作,知道条件不成立时终止。

    这里写图片描述

    我们再把上面的需求用流程图来表示一下

    这里写图片描述

    N-S流程图

    N-S流程图是将全部的算法写在一个矩形框内,省去了流程图中的流程线。下面继续看一个实例:
    需求:输入一个数,判别是否为素数。

    这里写图片描述

    算法的基本特性和算法的表示介绍到就结束了。


    往期文章
    C语言学习入门01
    C语言学习入门02

    如果您觉得本篇文章对您有帮助,请转发给更多的人

    C语言中文社区】是一个C语言视频教程、学习笔记、电子书、计算机二级资料等专注于C语言编程学习者的干货知识分享平台,精选深度文章,分享优秀干货类、技能类的学习资源,帮助学习中的你。
    在这里插入图片描述

    展开全文
  • 算法导论之图的基本算法

    千次阅读 2016-10-11 12:01:38
    图的基本算法包括图的表示方法和图的搜索方法。图的搜索技术是图算法领域的核心,有序地沿着图的边访问所有顶点,可以发现图的结构信息。 1、图的表示方法: 给定图G=(V,E),其中V表示图的点、E表示图的边,V[G]...
  • 高精度乘法基本算法

    千次阅读 2018-07-14 18:23:57
    高精度乘法基本算法,两段,其实两段是同一种方法,第二段稍做优化。只是将计算结果显示到屏幕上。代码片段一(初学请参考这段代码):#include &lt;iostream&gt; #include &lt;cstdio&gt; #include...
  • 十大基本算法介绍

    万次阅读 多人点赞 2019-05-17 14:34:46
    一、算法概述: 1.算法分类: 十种常见算法可以分为两大类: 比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能超过Q(nlogn),因此也称为非线性时间比较类排序。 非比较类排序:不通过比较来...
  • 基本算法设计策略

    千次阅读 2016-03-31 16:16:15
    基本算法设计策略 贪心法 分治法 回溯法 分支限界法 随机化算法 动态规划 贪心法 求解问题最优解,将问题分解为若干步,每一步都取当前最优解,即局部最优解。 例子:N人过桥问题 分治法 求解问题唯一解,将问题...
  • WordCloud基本算法

    千次阅读 2012-06-13 11:52:52
    WordCloud基本算法: 关于wordcloud的用处我就不多说了,在这里我假定一个前提,然后在这个前提下来生成一个wordcloud。 1:要求生成的wordcloud占用的面积越小越好 2:要求尽量是矩形 下面是我的大概算法: 1...
  • 这里讨论下RIP和OSPF的基本算法,在CISCO课程中讨论RIP和OSPF的区别有不少,但是回溯源头,它们理论算法里面的原理差不多,比较大的区别主要有三点 1.Bellman-ford的链路距离是估算的,Dijkstra是传输链路距离给...
  • 机器学习实战-基本算法总结1

    万次阅读 2018-01-25 22:27:40
    机器学习基本算法总结 ☞监督学习——分类 代码在这,基于python3(原书代码是python2) 这里只是一个总结,原书已经讲解很清楚了,不清楚的直接看代码,或者李航的统计学习方法也有公式推导。 目录1 1....
  • 【推荐架构day2】微博怎么给你推荐信息的:基本原理 【推荐架构day3】微博推荐引擎的体系结构:技术实现   标签传播 微博用户量浩大,不同的人有不同的兴趣。挖掘每个用户的兴趣有助于更加精准的广告...
  • 求图形学基本算法好书推荐?

    千次阅读 2015-11-02 20:17:48
    求图形学基本算法好书推荐? 想从事实时渲染方向,图形学初学者,数学,英语,算法和数据结构等基础还算扎实,现在是《real time rendering》刚开始读,刚学完opengl es,按@张静推荐的那本OpenGL es 3.0书学习...
  • 图像匹配 一些基本算法

    万次阅读 多人点赞 2018-08-26 14:28:06
     本文主要介绍几种基于灰度的图像匹配算法:平均绝对差算法(MAD)、绝对误差和算法(SAD)、误差平方和算法(SSD)、平均误差平方和算法(MSD)、归一化积相关算法(NCC)、序贯相似性检测算法(SSDA)、hadamard...
  • 常见的负载均衡的基本算法

    千次阅读 2015-01-13 10:54:45
    负载均衡的基本算法,主要有以下几种(参考F5产品): 随机:负载均衡方法随机的把负载分配到各个可用的服务器上,通过随机数生成算法选取一个服务器,然后把连接发送给它。虽然许多均衡产品都支持该算法,...
  • Autoware 基本算法介绍

    千次阅读 2019-05-22 13:33:29
    转载 ...本文参考Autoware_wiki_overview,主要描述了Autoware的整体框架和模块描述,主要包括感知和规划两大部分。 感知包括定位模块,检测模块,...检测模块使用摄像头和激光雷达,结合传感器融合算法和深度学习网...
  • 线性链表的基本算法

    千次阅读 2011-11-24 21:12:43
    下面是线性链表的一些基本算法,留着以后翻案。下面的算法描述都是以字符串为数据元素。链表结构定义如下: typedef struct node { char data[100]; struct node *link; }LNode, *LinkList; 1。建立一个...
  • 模式识别的几种基本算法

    千次阅读 2015-06-10 18:22:00
    本学期选了模式识别的课程,该期末考试了, 将本课程的几种基本算法整理一下。  1.最近邻算法 (1)最近邻算法:为了判定未知样本的类别,以全部训练样本作为代表点,计算未知样本与所有训练样本的距离,并以最近...
  • 4个基本算法思想:穷举、递推、递归、概率 内容:这4个基本算法思想是解决基础问题的很实用的方法。这里开始其实就已经是把所有需要的知识准备好了,之后就要开始解题了。此文为初级算法总结的子篇第六章——4个...
  • 各种基本算法实现小结(七)—— 常用算法(均已测试通过)======================================================================1、判断素数测试环境:VC 6.0 (C)#include #include int is_sushu(int n) { ...
  • 各种基本算法实现小结(六)—— 查找算法(均已测试通过)=================================================================== 1、简单查找在一组无序数列中,查找特定某个数值,并返回其位置pos测试环境:VC ...
  • 用Python实现基本算法----冒泡法

    千次阅读 2019-06-23 12:28:05
    冒泡法—三个基本算法之一 冒泡法 属于交换排序 两两比较大小,交换位置,如同水泡咕噜咕噜往上冒 结果分为升序、降序 升序 n个数从左到右,编号从0开始到n-1,索引0和1的值进行比较,如果索引0的值大,则交换...
  • 滚动条设计:基本算法

    千次阅读 2013-05-03 19:58:05
    以纵向滚动条为例: >>已知条件:  滚动条高度=h  最大值=max  最小值=min  翻页跨度=p ...>>基本算法  页数: pageCount = (max - min) / p  滑块高度: thumbH = h / pageCount
  • GIS基本算法基础

    千次阅读 2016-08-11 16:46:21
    好记性不如烂笔头,把一些基本几何算法记录下来,供后续查阅。 1、矢量概念:如果一条线段的端点有次序之分,称之为有向线段,如果有向线段的起点在坐标原点,称之为矢量。 2、矢量加减法:p(x1,y1),q(x2,y2)...
  • 一直感觉差分隐私和纯粹概率有点不同的地方,看完苹果的CMS基本算法和谷歌的RAPPOR基本算法,感觉其实都是一回事。 比如CMS对独热向量的每一位按照 1/(1+e^(Epsilon/2)) 的概率进行翻转,最后达到隐私预算为Epsilon...
  • 五种基本算法思想

    万次阅读 多人点赞 2017-12-25 16:31:57
    基本算法思想 穷举算法的基本思想就是从所有可能的情况中搜索正确的答案,其执行步骤如下: (1)对于一种可能的情况,计算其结果。 (2) 判断结果是否满足要求,如果不满足则执行第(1 ) 步来搜索下一个可能的...
  • [基本算法]Java——编写一个线段类,实现基本数学算法主要属性有:e1,e2端点,类型为Point;编写构造方法,如(Point p1, Point p2)编写成员方法。如:检查线段是否位于第一象限求线段的长度判断两天线段是否相交求...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 142,456
精华内容 56,982
关键字:

基本算法