预定义常量和类型
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* 函数结果状态代码*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
三元组的表示及其基本操作
表示方法：
typedef ElemType *Triplet; /* 由InitTriplet分配3个元素存储空间*/
/* Triplet类型是ElemType类型的指针，存放ElemType类型的地址*/
基本操作（8个）：
Status InitTriplet(Triplet *T,ElemType v1,ElemType v2,ElemType v3)
{ /* 操作结果：构造三元组T，依次置T的3个元素的初值为v1，v2和v3 */ *T=(ElemType *)malloc(3*sizeof(ElemType));
if(!*T)
exit(OVERFLOW);
(*T)[0]=v1,(*T)[1]=v2,(*T)[2]=v3;
return OK;
Status DestroyTriplet(Triplet *T)
{ /* 操作结果：三元组T被销毁*/
free(*T);
*T=NULL;
return OK;
}
Status Get(Triplet T,int i,ElemType *e)
{ /* 初始条件：三元组T已存在，1≤i≤3。操作结果：用e返回T的第i元的值*/
if(i<1||i>3)
return ERROR;
*e=T[i-1];
return OK;
}
Status Put(Triplet T,int i,ElemType e)
{ /* 初始条件：三元组T已存在，1≤i≤3。操作结果：改变T的第i元的值为e */
if(i<1||i>3)
return ERROR;
T[i-1]=e;
return OK;
}
Status IsAscending(Triplet T)
{ /* 初始条件：三元组T已存在。操作结果：如果T的3个元素按升序排列，返回1，否则返回0 */
return(T[0]<=T[1]&&T[1]<=T[2]);
}
Status IsDescending(Triplet T)
{ /* 初始条件：三元组T已存在。操作结果：如果T的3个元素按降序排列，返回1，否则返回0 */
return(T[0]>=T[1]&&T[1]>=T[2]);
}
Status Max(Triplet T,ElemType *e)
{ /* 初始条件：三元组T已存在。操作结果：用e返回指向T的最大元素的值*/
*e=T[0]>=T[1]?T[0]>=T[2]?T[0]:T[2]:T[1]>=T[2]?T[1]:T[2];
return OK;
Status Min(Triplet T,ElemType *e)
{ /* 初始条件：三元组T已存在。操作结果：用e返回指向T的最小元素的值*/
*e=T[0]<=T[1]?T[0]<=T[2]?T[0]:T[2]:T[1]<=T[2]?T[1]:T[2];
return OK;
}
线性表的顺序表示及其基本操作
表示方法：
#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/
#define LIST_INCREMENT 2 /* 线性表存储空间的分配增量*/
typedef struct
{
ElemType *elem; /* 存储空间基址*/
int length; /* 当前长度*/
int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */
}SqList;
基本操作（9个）：
void InitList(SqList *L) /* 算法2.3 */
{ /* 操作结果：构造一个空的顺序线性表L */
(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!(*L).elem)
exit(OVERFLOW); /* 存储分配失败*/
(*L).length=0; /* 空表长度为0 */
(*L).listsize=LIST_INIT_SIZE; /* 初始存储容量*/
}
Status ListEmpty(SqList L)
{ /* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
if(L.length==0)
return TRUE;
else
return FALSE;
}
int ListLength(SqList L)
{ /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数*/ return L.length;
}
Status GetElem(SqList L,int i,ElemType *e)
{ /* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)。操作结果：用e返回L中第i个数据元素的值*/
if(i<1||i>L.length)
return ERROR;
*e=*(L.elem+i-1);
return OK;
}
int LocateElem(SqList L,ElemType e)
{ /* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0) */
/* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。*/ /* 若这样的数据元素不存在，则返回值为0。算法2.6 */
ElemType *p;
int i=1; /* i的初值为第1个元素的位序*/
p=L.elem; /* p的初值为第1个元素的存储位置*/
while(i<=L.length&& *p++!=e)
++i;
if(i<=L.length)
return i;
else
return 0;
}
Status ListInsert(SqList *L,int i,ElemType e) /* 算法2.4 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */ ElemType *newbase,*q,*p;
if(i<1||i>(*L).length+1) /* i值不合法*/
return ERROR;
if((*L).length>=(*L).listsize) /* 当前存储空间已满,增加分配*/
{
newbase=(ElemType
*)realloc((*L).elem,((*L).listsize+LIST_INCREMENT)*sizeof(ElemType));
if(!newbase)
exit(OVERFLOW); /* 存储分配失败*/
(*L).elem=newbase; /* 新基址*/
(*L).listsize+=LIST_INCREMENT; /* 增加存储容量*/
}
q=(*L).elem+i-1; /* q为插入位置*/
for(p=(*L).elem+(*L).length-1;p>=q;--p) /* 插入位置及之后的元素右移*/
*(p+1)=*p;
*q=e; /* 插入e */
++(*L).length; /* 表长增1 */
return OK;
}
Status ListDelete(SqList *L,int i,ElemType *e) /* 算法2.5 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */ ElemType *p,*q;
if(i<1||i>(*L).length) /* i值不合法*/
return ERROR;
p=(*L).elem+i-1; /* p为被删除元素的位置*/
*e=*p; /* 被删除元素的值赋给e */
q=(*L).elem+(*L).length-1; /* 表尾元素的位置*/
for(++p;p<=q;++p) /* 被删除元素之后的元素左移*/
*(p-1)=*p;
(*L).length--; /* 表长减1 */
return OK;
}
void Union(SqList *La,SqList Lb) /* 算法2.1 */
{ /* 将所有在线性表Lb中但不在La中的数据元素插入到La中*/
ElemType e;
int La_len,Lb_len;
int i;
La_len=ListLength(*La);/* 求线性表的长度*/
Lb_len=ListLength(Lb);
for(i=1;i<=Lb_len;i++)
{
GetElem(Lb,i,&e); /* 取Lb中第i个数据元素赋给e */
if(!LocateElem(*La,e)) /* La中不存在和e相同的元素，则插入之*/
ListInsert(La,++La_len,e);
}
}
void MergeList(SqList La,SqList Lb,SqList *Lc) /* 算法2.2 */
{ /* 已知线性表La和Lb中的数据元素按值非递减排列。*/
/* 归并La和Lb得到新的线性表Lc，Lc的数据元素也按值非递减排列*/ int i=1,j=1,k=0;
int La_len,Lb_len;
ElemType ai,bj;
InitList(Lc); /* 创建空表Lc */
La_len=ListLength(La);
Lb_len=ListLength(Lb);
while(i<=La_len&&j<=Lb_len) /* 表La和表Lb均非空*/
{
GetElem(La,i,&ai);
GetElem(Lb,j,&bj);
if(ai<=bj)
{
ListInsert(Lc,++k,ai);
++i;
}
else
{
ListInsert(Lc,++k,bj);
++j;
}
} /* 以下两个while循环只会有一个被执行*/
while(i<=La_len) /* 表La非空且表Lb空*/
{
GetElem(La,i++,&ai);
ListInsert(Lc,++k,ai);
}
while(j<=Lb_len) /* 表Lb非空且表La空*/
{
GetElem(Lb,j++,&bj);
ListInsert(Lc,++k,bj);
}
}
线性表的链式表示及其基本操作
带头结点链表的表示方法（不带头结点的单链表不再总结，在书上28页）：typedef struct LNode /* 结点类型*/
{
ElemType data;
struct LNode *next;
}LNode,*Link,*Position;
typedef struct LinkList /* 链表类型*/
{
Link head,tail; /* 分别指向线性链表中的头结点和最后一个结点*/ int len; /* 指示线性链表中数据元素的个数*/
}LinkList;
基本操作（24个）：
void MakeNode(Link *p,ElemType e)
{ /* 分配由p指向的值为e的结点。若分配失败，则退出*/
*p=(Link)malloc(sizeof(LNode));
if(!*p)
exit(ERROR);
(*p)->data=e;
}
void FreeNode(Link *p)
{ /* 释放p所指结点*/
free(*p);
*p=NULL;
}
void InitList(LinkList *L)
{ /* 构造一个空的线性链表L */
Link p;
p=(Link)malloc(sizeof(LNode)); /* 生成头结点*/
if(p)
{
p->next=NULL;
(*L).head=(*L).tail=p;
(*L).len=0;
}
else
exit(ERROR);
}
void ClearList(LinkList *L)
{ /* 将线性链表L重置为空表，并释放原链表的结点空间*/
Link p,q;
if((*L).head!=(*L).tail) /* 不是空表*/
{
p=q=(*L).head->next;
(*L).head->next=NULL;
while(p!=(*L).tail)
{
p=q->next;
free(q);
q=p;
}
free(q);
(*L).tail=(*L).head;
(*L).len=0;
}
}
void DestroyList(LinkList *L)
{ /* 销毁线性链表L，L不再存在*/
ClearList(L); /* 清空链表*/
FreeNode(&(*L).head);
(*L).tail=NULL;
(*L).len=0;
}
void InsFirst(LinkList *L,Link h,Link s) /* 形参增加L,因为需修改L */
{ /* h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前*/
s->next=h->next;
h->next=s;
if(h==(*L).tail) /* h指向尾结点*/
(*L).tail=h->next; /* 修改尾指针*/
(*L).len++;
}
Status DelFirst(LinkList *L,Link h,Link *q) /* 形参增加L,因为需修改L */
{ /* h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q 返回。*/
/* 若链表为空(h指向尾结点)，q=NULL，返回FALSE */
*q=h->next;
if(*q) /* 链表非空*/
{
h->next=(*q)->next;
if(!h->next) /* 删除尾结点*/
(*L).tail=h; /* 修改尾指针*/
(*L).len--;
return OK;
}
else
return FALSE; /* 链表空*/
}
void Append(LinkList *L,Link s)
{ /* 将指针s(s->data为第一个数据元素)所指(彼此以指针相链，以NULL结尾)的*/
/* 一串结点链接在线性链表L的最后一个结点之后，并改变链表L的尾指针指向新的尾结点*/
int i=1;
(*L).tail->next=s;
while(s->next)
{
s=s->next;
i++;
}
(*L).tail=s;
(*L).len+=i;
}
Position PriorPos(LinkList L,Link p)
{ /* 已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置。若无前驱，则返回NULL */
Link q;
q=L.head->next;
if(q==p) /* 无前驱*/
return NULL;
else
{
while(q->next!=p) /* q不是p的直接前驱*/
q=q->next;
return q;
}
}
Status Remove(LinkList *L,Link *q)
{ /* 删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点*/
Link p=(*L).head;
if((*L).len==0) /* 空表*/
{
*q=NULL;
return FALSE;
}
while(p->next!=(*L).tail)
p=p->next;
*q=(*L).tail;
p->next=NULL;
(*L).tail=p;
(*L).len--;
return OK;
}
void InsBefore(LinkList *L,Link *p,Link s)
{ /* 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前，*/
/* 并修改指针p指向新插入的结点*/
Link q;
q=PriorPos(*L,*p); /* q是p的前驱*/
if(!q) /* p无前驱*/
q=(*L).head;
s->next=*p;
q->next=s;
*p=s;
(*L).len++;
}
void InsAfter(LinkList *L,Link *p,Link s)
{ /* 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后，*/
/* 并修改指针p指向新插入的结点*/
if(*p==(*L).tail) /* 修改尾指针*/
(*L).tail=s;
s->next=(*p)->next;
(*p)->next=s;
*p=s;
(*L).len++;
}
void SetCurElem(Link p,ElemType e)
{ /* 已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值*/ p->data=e;
}
ElemType GetCurElem(Link p)
{ /* 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值*/ return p->data;
}
Status ListEmpty(LinkList L)
{ /* 若线性链表L为空表，则返回TRUE，否则返回FALSE */
if(L.len)
return FALSE;
else
return TRUE;
}
int ListLength(LinkList L)
{ /* 返回线性链表L中元素个数*/
return L.len;
}
Position GetHead(LinkList L)
{ /* 返回线性链表L中头结点的位置*/
return L.head;
}
Position GetLast(LinkList L)
{ /* 返回线性链表L中最后一个结点的位置*/
return L.tail;
}
Position NextPos(Link p)
{ /* 已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置。若无后继，则返回NULL */
return p->next;
}
Status LocatePos(LinkList L,int i,Link *p)
{ /* 返回p指示线性链表L中第i个结点的位置，并返回OK，i值不合法时返回ERROR。i=0为头结点*/
int j;
if(i<0||i>L.len)
return ERROR;
else
{
*p=L.head;
for(j=1;j<=i;j++)
*p=(*p)->next;
return OK;
}
}
Position LocateElem(LinkList L,ElemType e,Status
(*compare)(ElemType,ElemType))
{ /* 返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置，*/
/* 若不存在这样的元素，则返回NULL */
Link p=L.head;
do
p=p->next;
while(p&&!(compare(p->data,e))); /* 没到表尾且没找到满足关系的元素*/ return p;
}
void ListTraverse(LinkList L,void(*visit)(ElemType))
{ /* 依次对L的每个数据元素调用函数visit() */
Link p=L.head->next;
int j;
for(j=1;j<=L.len;j++)
{
visit(p->data);
p=p->next;
}
printf("\n");
}
void OrderInsert(LinkList *L,ElemType e,int (*comp)(ElemType,ElemType))
{ /* 已知L为有序线性链表，将元素e按非降序插入在L中。(用于一元多项式) */
Link o,p,q;
q=(*L).head;
p=q->next;
while(p!=NULL&&comp(p->data,e)<0) /* p不是表尾且元素值小于e */
{
q=p;
p=p->next;
}
o=(Link)malloc(sizeof(LNode)); /* 生成结点*/
o->data=e; /* 赋值*/
q->next=o; /* 插入*/
o->next=p;
(*L).len++; /* 表长加1 */
if(!p) /* 插在表尾*/
(*L).tail=o; /* 修改尾结点*/
}
Status LocateElemP(LinkList L,ElemType e,Position
*q,int(*compare)(ElemType,ElemType))
{ /* 若升序链表L中存在与e满足判定函数compare()取值为0的元素，则q指示L中*/
/* 第一个值为e的结点的位置，并返回TRUE；否则q指示第一个与e满足判定函数*/
/* compare()取值>0的元素的前驱的位置。并返回FALSE。(用于一元多项式) */
Link p=L.head,pp;
do
{
pp=p;
p=p->next;
}while(p&&(compare(p->data,e)<0)); /* 没到表尾且p->data.expn
{
*q=pp;
return FALSE;
}
else /* 找到*/
{
*q=p;
return TRUE;
}
}
栈的表示及其基本操作
顺序存储表示：（链式表示不常用，这里不再列出）
#define STACK_INIT_SIZE 10 /* 存储空间初始分配量*/
#define STACK_INCREMENT 2 /* 存储空间分配增量*/
typedef struct SqStack
{
SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */
SElemType *top; /* 栈顶指针*/
int stacksize; /* 当前已分配的存储空间，以元素为单位*/
}SqStack; /* 顺序栈*/
基本操作（9个）：
void InitStack(SqStack *S)
{ /* 构造一个空栈S */
(*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!(*S).base)
exit(OVERFLOW); /* 存储分配失败*/
(*S).top=(*S).base;
(*S).stacksize=STACK_INIT_SIZE;
}
void DestroyStack(SqStack *S)
{ /* 销毁栈S，S不再存在*/
free((*S).base);
(*S).base=NULL;
(*S).top=NULL;
(*S).stacksize=0;
}
void ClearStack(SqStack *S)
{ /* 把S置为空栈*/
(*S).top=(*S).base;
}
Status StackEmpty(SqStack S)
{ /* 若栈S为空栈，则返回TRUE，否则返回FALSE */
if(S.top==S.base)
return TRUE;
else
return FALSE;
}
int StackLength(SqStack S)
{ /* 返回S的元素个数，即栈的长度*/
return S.top-S.base;
}
Status GetTop(SqStack S,SElemType *e)
{ /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */ if(S.top>S.base)
{
*e=*(S.top-1);
return OK;
}
else
return ERROR;
}
void Push(SqStack *S,SElemType e)
{ /* 插入元素e为新的栈顶元素*/
if((*S).top-(*S).base>=(*S).stacksize) /* 栈满，追加存储空间*/
{
(*S).base=(SElemType
*)realloc((*S).base,((*S).stacksize+STACK_INCREMENT)*sizeof(SElemType));
if(!(*S).base)
exit(OVERFLOW); /* 存储分配失败*/
(*S).top=(*S).base+(*S).stacksize;
(*S).stacksize+=STACK_INCREMENT;
}
*((*S).top)++=e;
}
Status Pop(SqStack *S,SElemType *e)
{ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
if((*S).top==(*S).base)
return ERROR;
*e=*--(*S).top;
return OK;
}
void StackTraverse(SqStack S,void(*visit)(SElemType))
{ /* 从栈底到栈顶依次对栈中每个元素调用函数visit() */
while(S.top>S.base)
visit(*S.base++);
printf("\n");
}
void print(SElemType c)
{
printf("%d ",c);
}
队列的表示及其基本操作
单链队列的存储表示（循环队列只作为了解内容，这里不再列出）：
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
QueuePtr front,rear; /* 队头、队尾指针*/
}LinkQueue;
链队列的基本操作（9个）：
void InitQueue(LinkQueue *Q)
{ /* 构造一个空队列Q */
(*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));
if(!(*Q).front)
exit(OVERFLOW);
(*Q).front->next=NULL;
}
void DestroyQueue(LinkQueue *Q)
{ /* 销毁队列Q(无论空否均可) */
while((*Q).front)
{
(*Q).rear=(*Q).front->next;
free((*Q).front);
(*Q).front=(*Q).rear;
}
}
void ClearQueue(LinkQueue *Q)
{ /* 将Q清为空队列*/
QueuePtr p,q;
(*Q).rear=(*Q).front;
p=(*Q).front->next;
(*Q).front->next=NULL;
while(p)
{
q=p;
p=p->next;
free(q);
}
}
Status QueueEmpty(LinkQueue Q)
{ /* 若Q为空队列，则返回TRUE，否则返回FALSE */ if(Q.front->next==NULL)
return TRUE;
else
return FALSE;
}
int QueueLength(LinkQueue Q)
{ /* 求队列的长度*/
int i=0;
QueuePtr p;
p=Q.front;
while(Q.rear!=p)
{
i++;
p=p->next;
}
return i;
}
Status GetHead_Q(LinkQueue Q,QElemType *e) /* 避免与bo2-6.c重名*/
{ /* 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR */ QueuePtr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front->next;
*e=p->data;
return OK;
}
void EnQueue(LinkQueue *Q,QElemType e)
{ /* 插入元素e为Q的新的队尾元素*/
QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
if(!p) /* 存储分配失败*/
exit(OVERFLOW);
p->data=e;
p->next=NULL;
(*Q).rear->next=p;
(*Q).rear=p;
}
Status DeQueue(LinkQueue *Q,QElemType *e)
{ /* 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR */
QueuePtr p;
if((*Q).front==(*Q).rear)
return ERROR;
p=(*Q).front->next;
*e=p->data;
(*Q).front->next=p->next;
if((*Q).rear==p)
(*Q).rear=(*Q).front;
free(p);
return OK;
}
void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
{ /* 从队头到队尾依次对队列Q中每个元素调用函数vi() */
QueuePtr p;
p=Q.front->next;
while(p)
{
vi(p->data);
p=p->next;
}
printf("\n");
}
串的表示及其基本操作
串的堆分配存储表示（串的定长表示方法了解，这里不再列出）：
typedef struct
{
char *ch; /* 若是非空串，则按串长分配存储区，否则ch为NULL */
int length; /* 串长度*/
}HString;
串采用堆分配存储表示的基本操作（14个）：
#define DestroyString ClearString /* DestroyString()与ClearString()作用相同*/ void StrAssign(HString *T,char *chars)
{ /* 生成一个其值等于串常量chars的串T */
int i,j;
if((*T).ch)
free((*T).ch); /* 释放T原有空间*/
i=strlen(chars); /* 求chars的长度i */
if(!i)
{ /* chars的长度为0 */
(*T).ch=NULL;
(*T).length=0;
}
else
{ /* chars的长度不为0 */
(*T).ch=(char*)malloc(i*sizeof(char)); /* 分配串空间*/
if(!(*T).ch) /* 分配串空间失败*/
exit(OVERFLOW);
for(j=0;j (*T).ch[j]=chars[j]; (*T).length=i; } } void StrCopy(HString *T,HString S) { /* 初始条件：串S存在。操作结果：由串S复制得串T */ int i; if((*T).ch) free((*T).ch); /* 释放T原有空间*/ (*T).ch=(char*)malloc(S.length*sizeof(char)); /* 分配串空间*/ if(!(*T).ch) /* 分配串空间失败*/ exit(OVERFLOW); for(i=0;i (*T).ch[i]=S.ch[i]; (*T).length=S.length; } Status StrEmpty(HString S) { /* 初始条件：串S存在。操作结果：若S为空串，则返回TRUE，否则返回FALSE */ if(S.length==0&&S.ch==NULL) return TRUE; else return FALSE; } int StrCompare(HString S,HString T) { /* 若S>T，则返回值>0；若S=T，则返回值=0；若S for(i=0;i if(S.ch[i]!=T.ch[i]) return S.ch[i]-T.ch[i]; return S.length-T.length; } int StrLength(HString S) { /* 返回S的元素个数，称为串的长度*/ return S.length; } void ClearString(HString *S) { /* 将S清为空串*/ free((*S).ch); (*S).ch=NULL; (*S).length=0; } void Concat(HString *T,HString S1,HString S2) { /* 用T返回由S1和S2联接而成的新串*/ int i; if((*T).ch) free((*T).ch); /* 释放旧空间*/ (*T).length=S1.length+S2.length; (*T).ch=(char *)malloc((*T).length*sizeof(char)); if(!(*T).ch) exit(OVERFLOW); for(i=0;i (*T).ch[i]=S1.ch[i]; for(i=0;i (*T).ch[S1.length+i]=S2.ch[i]; } Status SubString(HString *Sub, HString S,int pos,int len) { /* 用Sub返回串S的第pos个字符起长度为len的子串。*/ /* 其中，1≤pos≤StrLength(S)且0≤len≤StrLength(S)-pos+1 */ int i; if(pos<1||pos>S.length||len<0||len>S.length-pos+1) return ERROR; if((*Sub).ch) free((*Sub).ch); /* 释放旧空间*/ if(!len) /* 空子串*/ { (*Sub).ch=NULL; (*Sub).length=0; } else { /* 完整子串*/ (*Sub).ch=(char*)malloc(len*sizeof(char)); if(!(*Sub).ch) exit(OVERFLOW); for(i=0;i<=len-1;i++) (*Sub).ch[i]=S.ch[pos-1+i]; (*Sub).length=len; } return OK; } 混凝土结构设计基本原理复习重点(总结很好) 第 1 章绪论 1.钢筋与混凝土为什么能共同工作： （1）钢筋与混凝土间有着良好的粘结力，使两者能可靠地结合成一个整体，在荷载作用下能够很好地共同变形，完成其结构功能。 （2）钢筋与混凝土的温度线膨胀系数也较为接近，因此，当温度变化时，不致产生较大的温度应力而破坏两者之间的粘结。 （3）包围在钢筋外面的混凝土，起着保护钢筋免遭锈蚀的作用，保证了钢筋与混凝土的共同作用。 1、混凝土的主要优点：1)材料利用合理2 )可模性好3)耐久性和耐火性较好4)现浇混凝土结构的整体性好5)刚度大、阻尼大6)易于就地取材 2、混凝土的主要缺点：1)自重大2)抗裂性差3 )承载力有限4)施工复杂、施工周期较长5 )修复、加固、补强较困难 建筑结构的功能包括安全性、适用性和耐久性三个方面 作用的分类：按时间的变异，分为永久作用、可变作用、偶然作用 结构的极限状态：承载力极限状态和正常使用极限状态 结构的目标可靠度指标与结构的安全等级和破坏形式有关。 荷载的标准值小于荷载设计值；材料强度的标准值大于材料强度的设计值 第2章钢筋与混凝土材料物理力学性能 一、混凝土 立方体抗压强度（f cu,k）：用150mm×150mm×150mm的立方体试件作为标准试件，在温度为（20±3）℃，相对湿度在90%以上的潮湿空气中养护28d，按照标准试验方法加压到破坏，所测得的具有95%保证率的抗压强度。（f cu,k为确定混凝土强度等级的依据） 1.强度轴心抗压强度（f c）：由150mm×150mm×300mm的棱柱体标准试件经标准养护后用标准试验方法测得的。（f ck=0.67 f cu,k） 轴心抗拉强度（f t）：相当于f cu,k的1/8～1/17, f cu,k越大，这个比值越低。 复合应力下的强度：三向受压时，可以使轴心抗压强度与轴心受压变形能力都得到提高。 双向受力时，（双向受压：一向抗压强度随另一向压应力的增加而增加；双向受拉：混凝土的抗拉强度与单向受拉的基本一样； 一向受拉一向受压：混凝土的抗拉强度随另一向压应力的增加而降低，混凝土的抗压强度随另一向拉应力的增加而降低） 受力变形：（弹性模量：通过曲线上的原点O引切线，此切线的斜率即为弹性模量。反映材料抵2.变形抗弹性变形的能力） 体积变形（温度和干湿变化引起的）：收缩和徐变等。 混凝土单轴向受压应力-应变曲线数学模型 1、美国E.Hognestad建议的模型 2、德国Rusch建议的模型 混凝土的弹性模量、变形模量和剪变模量 弹性模量 变形模量 切线模量 3、（1）徐变：混凝土的应力不变，应变随时间而增长的现象。 混凝土产生徐变的原因： 1、填充在结晶体间尚未水化的凝胶体具有粘性流动性质 2、混凝土内部的微裂缝在载荷长期作用下不断发展和增加的结果 线性徐变：当应力较小时，徐变变形与应力成正比；非线性徐变：当混凝土应力较大时，徐变变形与应力不成正比，徐变比应力增长更快。影响因素：应力越大，徐变越大；初始加载时混凝土的龄期愈小，徐变愈大；混凝土组成成分水灰比大、水泥用量大，徐变大；骨料愈坚硬、弹性模量高，徐变小；温度愈高、湿度愈低，徐变愈大；尺寸大小，尺寸大的构件，徐变减小。养护和使用条件 对结构的影响：受弯构件的长期挠度为短期挠度的两倍或更多；长细比较大的偏心受压构件，侧向挠度增大，承载力下降；由于徐变产生预应力损失。（不利）截面应力重分布或结构内力重分布，使构件截面应力分布或结构内力分布趋于均匀。（有利） （2）收缩：混凝土在空气中结硬时体积减小的现象，在水中体积膨胀。 影响因素：1、水泥的品种：水泥强度等级越高，则混凝土的收缩量越大； 2、水泥的用量：水泥越多，收缩越大；水灰比越大，收缩也越大； 3、骨料的性质：骨料的弹性模量大，则收缩小； 4、养护条件：在结硬过程中，周围的温、湿度越大，收缩越小； 5、混凝土制作方法：混凝土越密实，收缩越小； 6、使用环境：使用环境的温度、湿度大时，收缩小； 7、构件的体积与表面积比值：比值大时，收缩小。 对结构的影响：会使构件产生表面的或内部的收缩裂缝，会导致预应力混凝土的预应力损失等。 措施：加强养护，减少水灰比，减少水泥用量，采用弹性模量大的骨料，加强振捣等。 混凝土的疲劳是荷载重复作用下产生的。（200万次及其以上） 二、钢筋 光圆钢筋：HPB235 表面形状 带肋钢筋：HRB335、HRB400、RRB400 有明显屈服点的钢筋：四个阶段（弹性阶段、屈服阶段、强化阶段、破坏阶段），屈服强度力学性能是主要的强度指标。 （软钢） 2017年数据分析年度工作总结范文 “2017年数据分析”，望给大家带来帮助! 工作总结1 在数据分析岗位一年以来，在公司部门领导和党支部的的正确领导下，认真贯彻执行党的各项方针、政策，紧紧围绕公司开展的“积极主动谋发展，务实奋进争一流”的主题实践活动，深入学习实践科学发展观，全面完成了各项工作目标，现简单的向领导汇报一下我一年来的工作情况。 一、虚心学习，不断提高政治素质和业务水平。 作为一名党员和公司的一份子，具备良好的政治和业务素质是做好本职工作的前提和必要条件。一年来，我一方面利用工作和业余时间认真学习了科学发展观、十一届全国人大二次会议和xx在中纪委十七届三次全会上的讲话精神，进一步提高了自己的党性认识和政治水平;一方面虚心向周围的领导、同事学习工作经验、工作方法和相关业务知识，取人之长，补己之短，加深了与各位同事之间的感情，同时还学习了相关的数据库知识，提高了自己在数据分析和处理上的技术水平，坚定了做好本职工作的信心和决心。 二、踏实工作，努力完成好领导交办的各项工作任务。 一年来，在主管的带领和同事们的支持下，自己主要做了以下几项工作： 一是认真做好各项报表的定期制作和查询，无论是本部门需要的报表还是为其他部门提供的报表。保证报表的准确性和及时性，并 与报表使用人做好良好的沟通工作。并完成各类报表的分类、整理、归档工作。 二是协助主管做好现有系统的维护和后续开发工作。包括topv 系统和多元化系统中的修改和程序开发。主要完成了海关进出口查验箱报表、出口当班查验箱清单、驳箱情况等报表导出功能以及龙门吊班其他箱量输入界面、其他岗位薪酬录入界面的开发，并完成了原有系统中交接班报表导出等功能的修改。同时，完成了系统在相关岗位的安装和维护工作，保证其正常运行。 三是配合领导和其他岗位做好各种数据的查询、统计、分析、汇总工作。做好相关数据的核实和上报工作，并确保数据的准确性和及时性。 四是完成领导交办的其他工作，认真对待，及时办理，不拖延、不误事、不敷衍，尽力做到让领导放心和满意。 三、存在的不足和今后的努力方向一年来，在办公室领导和同事们的指导帮助下，自己虽然做了一些力所能及的工作，但还存在很多的不足： 主要是阅历浅，经验少，有时遇到相对棘手的问题考虑欠周密，视角不够灵活，缺乏应变能力;理论和专业知识不够丰富，导致工作有时处于被动等等。 针对以上不足，在今后的工作中，自己要加强学习、深入实践、继续坚持正直、谦虚、朴实的工作作风，摆正自己的位置，尊重领导，团结同志，共同把办公室的工作做细做好。 数据分析员工作总结数据分析员是根据数据分析方案进行数据分析的人员，能进行较高级的数据统计分析。下面是出国留学网的先、编为大家精心整理的“数据分析员工作总结”，供大家阅读!希望能够帮助到大家!篇一：数据分析员工作总结在数据分析岗位工作三个月以来，在公司领导的正确领导下，深入学习关于淘宝网店的相关知识，我已经从一个网店的门外汉成长为对网店有一定了解和认知的人。现向公司领导简单汇报一下我三个月以来的工作情况。 一、虚心学习 努力提高网店数据分析方面的专业知识作为一个食品专业出身的人，刚进公司时，对网店方面的专业知识及网店运营几乎一无所知，曾经努力学习掌握的数据分析技能在这里根本就用不到，我也曾怀疑过自己的选择，怀疑自己对踏出校门的第一份工作的选择是不是冲动的。 但是，公司为我提供了宽松的学习环境和专业的指导，在不断的学习过程中，我慢慢喜欢上自己所选择的行业和工作。一方面，虚心学习每一个与网店相关的数据名词，提高自己在数据分析和处理方面的能力，坚定做好本职工作的信心和决心。另一方面，向周围的同同事学习业务知识和工作方法，取人之长，补己之短，加深了与同事之间的感 情。 二、踏实工作 努力完成领导交办的各项工作任务三个月来，在领导和同事们的支持和配合下，自己主要做了一下几方面的工作 1、汇总公司的产品信息日报表，并完成信息日报表的每日更新，为产品追单提供可靠依据。 2、协同仓库工作人员盘点库存，汇总库存报表，每天不定时清查入库货品，为各部门的同事提供最可靠的库存数据。 3、完成店铺经营月报表、店铺经营日报表。 4、完成每日客服接待顾客量的统计、客服工作效果及工作转化率的查询。 5、每日两次对店铺里出售的宝贝进行逐个排查，保证每款宝贝的架上数的及时更新，防止出售中的宝贝无故下架。 6、配合领导和其他岗位的同事做好各种数据的查询、统计、分析、汇总等工作。做好数据的核实和上报工作，并确保数据的准确性和及时性。 7、完成领导交代的其它各项工作，认真对待、及时办理、不拖延、不误事、不敷衍，尽量做到让领导放心和满意。 三、存在的不足及今后努力的方向 三个月来，在公司领导和同事们的指导和配合下，自己虽然做了一些力所能及的工作，但还存在很多的不足，主要是阅历浅，经验少，有时遇到相对棘手的问题考虑欠周密， 数据结构知识点概括 第一章概论 数据就是指能够被计算机识别、存储和加工处理的信息的载体。 数据元素是数据的基本单位，可以由若干个数据项组成。数据项是具有独立含义的最小标识单位。 数据结构的定义： ·逻辑结构：从逻辑结构上描述数据，独立于计算机。·线性结构：一对一关系。 ·线性结构：多对多关系。 ·存储结构：是逻辑结构用计算机语言的实现。·顺序存储结构：如数组。 ·链式存储结构：如链表。 ·索引存储结构：·稠密索引：每个结点都有索引项。 ·稀疏索引：每组结点都有索引项。 ·散列存储结构：如散列表。 ·数据运算。 ·对数据的操作。定义在逻辑结构上，每种逻辑结构都有一个运算集合。 ·常用的有：检索、插入、删除、更新、排序。 数据类型：是一个值的集合以及在这些值上定义的一组操作的总称。 ·结构类型：由用户借助于描述机制定义，是导出类型。 抽象数据类型ADT：·是抽象数据的组织和与之的操作。相当于在概念层上描述问题。 ·优点是将数据和操作封装在一起实现了信息隐藏。 程序设计的实质是对实际问题选择一种好的数据结构，设计一个好的算法。算法取决于数据结构。 算法是一个良定义的计算过程，以一个或多个值输入，并以一个或多个值输出。 评价算法的好坏的因素：·算法是正确的； ·执行算法的时间； ·执行算法的存储空间（主要是辅助存储空间）； ·算法易于理解、编码、调试。 时间复杂度：是某个算法的时间耗费，它是该算法所求解问题规模n的函数。 渐近时间复杂度：是指当问题规模趋向无穷大时，该算法时间复杂度的数量级。 评价一个算法的时间性能时，主要标准就是算法的渐近时间复杂度。 算法中语句的频度不仅与问题规模有关，还与输入实例中各元素的取值相关。 时间复杂度按数量级递增排列依次为：常数阶O（1）、对数阶O（log2n）、线性阶O（n）、线性对数阶O（nlog2n）、平方阶O （n^2）、立方阶O（n^3）、……k次方阶O（n^k）、指数阶O（2^n）。 结构设计个人工作总结 专业技术工作总结 本人马xx于2xx年6月毕业于xx科技学院，取得土木工程专业学士学位。毕业后进入xx新宇建筑设计有限公司参加工作，从事结构设计的技术工作，现任助理工程师职务。在各位领导和同事的支持和帮助下，自己的思想、工作、学习等各方面都取得了一定的成绩，个人综合素质也得到了一定的提高，下面就从专业技术角度对我的工作做一次全面总结： （一）、政治思想方面 在工作中，我坚决拥护党的各项政策、方针，每天都密切关注国内、国外的重大新闻和事件，关心和学习国家时事政治，把党的政治思想和方针应用于工程建设中。 （二）、主要工作业绩 在工作这些年里，我设计完成了如xx市xx房地产开发有限公司城东街道半沙村地块住宅建设项目，金海湾花苑商住建设项目，xx市北白象镇经济适用房和限价房建设工程项目，长城电器集团有限公司生产用房及辅助非生产。 （三）、结构技术工作方面的一些经验总结 （1）、拿到条件图不要盲目建模计算。先进行全面分析，与建筑设计人员进行沟通，充分了解工程的各种情况（功能、选型等）。 （2）、建模计算前的前处理要做好。比如荷载的计算要准确，不能估计。要完全根据建筑做法或使用要求来输入。 （3）、在进行结构建模的时候，要了解每个参数的意义，不要盲目修改参数，修改时要有依据。 （4）、在计算中，要充分考虑在满足技术条件下的经济性。不能随意加大配筋量或加大构件的截面。这一点要作为我们的设计理念之一来重视。 （5）、梁、柱、板等电算结束后要进行优化调整和修改，这都要有依据可循（需根据验算简图等资料）。 （四）、努力学习新知识，用知识武装自己 在完成好本职工作的同时，我还不断学习新知识，努力丰富自己。在这几年工作任务十分繁重的情况下，学习上，我一直严格要求自己，认真对待自己的工作。理论来源于生活，高于生活，更应该还原回到生活。工作中我时刻牢记要不断的学习，将理论知识与实际的工作很 数据分析员年终总结 数据分析员是本单位进行数据挖掘的三要素。其中数据仓库功能包括，源数据抽取、清洗、转换;，今天给大家找来了数据分析员年终总结，希望能够帮助到大家。 数据分析员年终总结篇一大家好! 我叫xx，20xx年3月份进入公司工作，现任公司调度员，现将我20xx年的工作情况简要汇报如下，敬请各位领导评议。我的述职报告共分以下三个部分： 一、20xx年工作回顾 1、积极学习，自我提高 只有懂生产、了解生产，才能很好的服务生产、监督生产。无论是管理经验，还是业务水平，都与优秀的调度员存在很大的差距。所以，我积极学习，虚心向老工人请教，到车间生产一线，了解生产现状，提高业务技能，提升管理水平。 2、精心调度，合理安排生产 每月月底结合各个分厂下月肉制品大致产量，制定出合理的内转产销量，结合销售部，制定外销产品的产销计划。即保证正常的生产运行，又没有造成不良库存;每日下午根据次日销售订单及发货情况，结合车间实际生产状况及仓库现有库存量，安排合理的次日生产计划，满足市场正常供应;每天依据生产计划，跟踪生产进度，及时正 确解决生产中出现的各种问题，保证生产计划及时完成。 3、和各个部门沟通协调，保障生产顺利进行 和集团公司采购部门保持良好的沟通，保证原辅包的及时供应;协助销售部，组织好外销产品的发运工作;和品管部、事业部、技术中心相关人员紧密结合，对生产中出现的问题，及时协调解决，保障生产的顺利进行。 4、充分发挥监督考核职能，做好日常管理工作 从现场卫生、生产过程过程、成本、质量、计划、工艺、安全、库房、数据交接、出门证管理等日常管理工作入手，定期组织相关人员检查，对检查中发现的问题整改落实情况进行跟踪，做好公司的各项日常管理工作。 二、工作中存在的不足 1、管理考核上放不开手脚 以往的工作只注重服务和协调，缺少监督和考核。在管理考核力度上不够，不能够很好的起到监督考核的作用。 2、在对两名新调度员的传帮带工作上没有做好 由于没有很好的对新人做好传帮带的工作，致使两名新调度员在很长的一段时间上找不到工作方向和工作重点。 3、工作的细致度上面还不够精细 由于以往的工作中存在粗心大意，细致度不够，致使个人工作中出现纰漏，出现问题。 三、下一步工作思路 第一章数据结构概述 基本概念与术语 1．数据：数据是对客观事物的符号表示，在计算机科学中是指所有能输入到计算机中并被计算机程序所处理的符号的总称。 2. 数据元素：数据元素是数据的基本单位，是数据这个集合中的个体，也称之为元素，结点，顶点记录。 (补充：一个数据元素可由若干个数据项组成。数据项是数据的不可分割的最小单位。 ) 3．数据对象：数据对象是具有相同性质的数据元素的集合，是数据的一个子集。(有时候也 叫做属性。) 4．数据结构：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 (1)数据的逻辑结构：数据的逻辑结构是指数据元素之间存在的固有逻辑关系，常称为数据结构。 数据的逻辑结构是从数据元素之间存在的逻辑关系上描述数据与数据的存储无关，是独立于计算机的。 依据数据元素之间的关系，可以把数据的逻辑结构分成以下几种： 1. 集合：数据中的数据元素之间除了“同属于一个集合“的关系以外，没有其他关系。 2. 线性结构：结构中的数据元素之间存在“一对一“的关系。若结构为非空集合，则除了第一个元素之外，和最后一个元素之外，其他每个元素都只有一个直接前驱和一个直接后继。 3. 树形结构：结构中的数据元素之间存在“一对多“的关系。若数据为非空集，则除了第一个元素 (根)之外，其它每个数据元素都只有一个直接前驱，以及多个或零个直接后继。 4. 图状结构：结构中的数据元素存在“多对多”的关系。若结构为非空集，折每个数据可有多个(或零个)直接后继。 (2)数据的存储结构：数据元素及其关系在计算机内的表示称为数据的存储结构。想要计算机处理数据，就必须把数据的逻辑结构映射为数据的存储结构。逻辑结构可以映射为以下两种存储结构： 1. 顺序存储结构：把逻辑上相邻的数据元素存储在物理位置也相邻的存储单元中，借助元素在存储器中的相对位置来表示数据之间的逻辑关系。 2. 链式存储结构：借助指针表达数据元素之间的逻辑关系。不要求逻辑上相邻的数据元素物理位置上也相邻。 5. 时间复杂度分析：1.常量阶：算法的时间复杂度与问题规模n 无关系T(n)=O(1) 2. 线性阶：算法的时间复杂度与问题规模 n 成线性关系T(n)=O(n) 3. 平方阶和立方阶：一般为循环的嵌套，循环体最后条件为i++ 时间复杂度的大小比较： O(1)< O(log 2 n)< O(n )< O(n log 2 n)< O(n2)< O(n3)< O(2 n ) 第一章 钢筋混凝土结构基本概念及材料的物理力学性能 1.混凝土立方体抗压强度cu f ：（基本强度指标）以边长150mm 立方体试件，按标准方法制作养护28d ，标准试验方法（不涂润滑剂，全截面受压，加载速度0.15~0.25MPa/s ）测得的抗压强度作为混凝土立方体抗压强度 cu f 。 影响立方体强度主要因素为试件尺寸和试验方法。尺寸效应关系： cu f （150）=0.95cu f （100） cu f （150）=1.05cu f （200） 2.混凝土弹性模量和变形模量。 ①原点弹性模量：在混凝土受压应力—应变曲线图的原点作切线，该切线曲率即为原点弹性模量。表示为：E '=σ/ε=tan α0 ②变形模量：连接混凝土应力应变—曲线的原点及曲线上某一点K 作割线，K 点混凝土应力为σc （=0.5c f ），该割线（OK ）的斜率即为变形模量，也称割线模量或弹塑性模量。 E c '''=tan α1=σc /εc 混凝土受拉弹性模量与受压弹性模量相等。 ③切线模量：混凝土应力应变—上某应力σc 处作一切线，该切线斜率即为相应于应力σc 时的切线模量''c E =d σ/d ε 3 . 徐变变形：在应力长期不变的作用下，混凝土的应变随时间增长的现象称为徐变。 影响徐变的因素：a. 内在因素，包括混凝土组成、龄期，龄期越早，徐变越大；b. 环境条件，指养护和使用时的温度、湿度，温度越高，湿度越低，徐变越大；c. 应力条件，压应力σ﹤0.5 c f ，徐变与应力呈线性关系；当压应力σ介于（0.5～0.8）c f 之间，徐变增长比应力快；当压应力σ﹥0.8 c f 时，混凝土的非线性徐变不收敛。 徐变对结构的影响：a.使结构变形增加；b.静定结构会使截面中产生应力重分布；c.超静定结构引起赘余力；d.在预应力混凝土结构中产生预 应力损失。 4.收缩变形：在混凝土中凝结和硬化的物理化学过程中体积随时间推移而减少的现象称为收缩。 混凝土收缩原因：a.硬化初期，化学性收缩，本身的体积收缩；b.后期，物理收缩，失水干燥。 影响混凝土收缩的主要因素：a.混凝土组成和配比；b.构件的养护条件、使用环境的温度和湿度，以及凡是影响混凝土中水分保持的因素；c.构件的体表比，比值越小收缩越大。 混凝土收缩对结构的影响：a.构件未受荷前可能产生裂缝；b.预应力构件中引起预应力损失；c.超静定结构产生次内力。 5.钢筋的基本概念 1.钢筋按化学成分分类，可分为碳素钢和普通低合金钢。 2钢筋按加工方法分类，可分为a.热轧钢筋；b.热处理钢筋；c.冷加工钢筋（冷拉钢筋、冷轧钢筋、冷轧带肋钢筋和冷轧扭钢筋。） 6.钢筋的力学性能 物理力学指标：（1）两个强度指标：屈服强度，结构设计计算中强度取值主要依据；极限抗拉强度，材料实际破坏强度，衡量钢筋屈服后的抗拉能力，不能作为计算依据。（2）两个塑性指标：伸长率和冷弯性能：钢材在冷加工过程和使用时不开裂、弯断或脆断的性能。 7.钢筋和混凝土共同工作的的原因：（1）混凝土和钢筋之间有着良好的黏结力；（2）二者具有相近的温度线膨胀系数；（3）在保护层足够的前提下，呈碱性的混凝土可以保护钢筋不易锈蚀，保证了钢筋与混凝土的共同作用。 第二章 结构按极限状态法设计计算的原则 1.结构概率设计的方法按发展进程划分为三个水准：a.水准Ⅰ，半概率设计法，只对影响结构可靠度的某些参数，用数理统计分析，并与经验结合，对结构的可靠度不能做出定量的估计；b.水准Ⅱ，近似概率设计法，用概率论和数理统计理论，对结构、构件、或截面设计的可靠概率做出近似估计，忽略了变量随时间的关系，非线性极限状态方程线性化；c.水准Ⅲ，全概略设计法，我国《公桥规》采用水准Ⅱ。 2.结构的可靠性：指结构在规定时间（设计基准期）、规定的条件下，完成预定功能的能力。 可靠性组成：安全性、适用性、耐久性。 可靠度：对结构的可靠性进行概率描述称为结构可靠度。 3.结构的极限状态：当整个结构或构件的一部分超过某一特定状态而不能满足设计规定的某一功能要求时，则此特定状态称为该功能的极限状态。 极限状态分为承载能力极限状态、正常使用极限状态和破坏—安全状态。 承载能力极限状态对应于结构或构件达到最大承载力或不适于继续承载的变形，具体表现：a.整个构件或结构的一部分作为刚体失去平衡；b.结构构件或连接处因超过材料强度而破坏；c.结构转变成机动体系；d.结构或构件丧失稳定；e.变形过大，不能继续承载和使用。 正常使用极限状态对应于结构或构件达到正常使用或耐久性能的某项规定限值，具体表现：a.由于外观变形影响正常使用；b.由于耐久性能的局部损坏影响正常使用；c.由于震动影响正常使用；d.由于其他特定状态影响正常使用。 破坏—安全状态是指偶然事件造成局部损坏后，其余部分不至于发生连续倒塌的状态。（破坏—安全极限状态归到承载能力极限状态中） 4.作用：使结构产生内力、变形、应力、应变的所有原因。 作用分为：永久作用、可变作用和偶然作用。 永久作用：在结构使用期内，其量值不随时间变化，或其变化与平均值相比可忽略不计的作用 可变作用：在结构试用期内，其量值随时间变化，且其变化值与平均值相比较不可忽略的作用。 复习提纲 第一章数据结构概述 基本概念与术语（P3） 1．数据结构是一门研究非数值计算程序设计问题中计算机的操作对象以及他们之间的关系和操作的学科. 2．数据是用来描述现实世界的数字,字符,图像,声音,以及能够输入到计算机中并能被计算机识别的符号的集合 2．数据元素是数据的基本单位 3．数据对象相同性质的数据元素的集合 4．数据结构包括三方面内容:数据的逻辑结构.数据的存储结构.数据的操作. （1）数据的逻辑结构指数据元素之间固有的逻辑关系. （2）数据的存储结构指数据元素及其关系在计算机内的表示 ( 3 ) 数据的操作指在数据逻辑结构上定义的操作算法,如插入,删除等. 5.时间复杂度分析 -------------------------------------------------------------------------------------------------------------------- 1、名词解释：数据结构、二元组 2、根据数据元素之间关系的不同，数据的逻辑结构可以分为 集合、线性结构、树形结构和图状结构四种类型。 3、常见的数据存储结构一般有四种类型，它们分别是___顺序存储结构_____、___链式存储结构_____、___索引存储结构_____和___散列存储结构_____。 4、以下程序段的时间复杂度为___O(N2)_____。 int i,j,x; for(i=0;i 第一章金属材料 抗大气、酸、碱、盐等介质腐蚀作用的不锈耐酸钢总称。要达到不锈耐蚀作用,含铬(Cr)量不少于13%；此外可加入镍(Ni)或钼(Mo)等来增加效果。由于合金种类及含量不同，种类繁多。 不锈钢特点：耐蚀好，光亮度好，强度高；有一定弹性；昂贵。 不锈钢材料特性: 1、铁素体型不锈钢：其含Cr量高,具有良好耐蚀性及高温抗氧化性能。 2、奥氏体不锈钢：典型牌号如1Cr18Ni9,1Cr18Ni9T1无磁性,耐蚀性能良好,温强度及高温抗氧化性能好,塑性好,冲击韧性好,且无缺口效应,焊接性能优良,因而广泛使用。这种钢一般强度不高,屈服强度低,且不能通过热处理强化,但冷压,加工后,可使抗拉强度高,且改善其弹性,但其在高温下冷拉获得的强度易化。不宜用于承受高载荷。 3、马氏体不锈钢： 典型如2Cr13,GX-8,具磁性,消震性优良,导热性好,具高强度和屈服极限,热处理强化后具良好综合机械性能。加含碳量多,焊后需回为处理以消除应力、高温冷却易形成8氏体,因此锻后要缓冷,并应立即进行回火。主要用于承载部件。 例： SUS 301 弹性不锈钢 SUS304 不锈钢 10Cr18Ni9 它是一种奥氏体不锈钢,淬火不能强化,只能消除冷作硬化和获得良好的抗蚀,淬火冷却必须在水是进行,以保证得到最好的抗蚀性;在900℃以下有稳定的抗氧化性。适于各种方法焊接;有晶间腐蚀倾向,零件长期在腐蚀介质、水中及蒸汽介质中工作时可能遭受晶界腐蚀破坏;钢淬火后冷变形塑性高,延伸性能良好,但切削加工性较差。 1Cr18Ni9 它是标准的18-8型奥氏体不锈钢,淬火后能强化,但此时具有良好的耐蚀性和冷塑性变形性能；因塑性和韧性很高,切削性较差；适于各种方法焊接；由于含碳量较0Cr18ni9高,对晶界腐蚀敏感性较焊接后需热处理,一般不适宜用作耐腐蚀的焊接件；在850℃以下空气介质、以及750℃以下航空燃料燃烧产物的气氛中肯有较稳定的抗氧化性。 Cr13Ni4Mn9 它属奥氏体不锈耐热钢,淬火不能强化,钢在淬火状态下塑性很高,可时行深压延及其它类型的冷冲压;钢的切削加工性较差;用点焊和滚焊焊接的效果良好,经过焊接后必须进行热处理;在大气中具有高耐蚀性;易产晶界腐蚀,故在超过450的腐蚀介质是为宜采用;在750～800℃以下的热空气中具有稳定的抗氧化性。 1Cr13 它属于铁素体-马氏体型为锈钢,在淬火回火后使用;为提高零件的耐磨性,疲劳性能及抗腐蚀性可渗氮、氰化;淬火及抛光后在湿性大气、蒸汽、淡水、海水、和自来水中具有足够的抗腐蚀性,在室温下的硝酸中有较好的安定性;在750℃温度以下具有稳定的抗氧化性。退火状态下的钢的塑性较高,可进行深压延钢、冲压、弯曲、卷边等冷加工;气焊和电弧焊结果还满意;切削加工性好,抛光性能优良;钢锻造后冷并应立即进行回火处理。 2Cr13 它属于马氏体型不锈钢,在淬火回火后使用;为提高零件的耐磨性耐腐蚀性、疲劳性能及抗蚀性并可用于渗氮处理、氰化；淬火回火后钢的强度、硬度均较1Cr13钢高,抗腐蚀性与耐热性稍低;在700℃温度以下的空气介质中仍有稳定的抗氧化性。钢的焊接性和退火状态下塑性虽比不上1Cr13 ,但仍满意;切削加工性好;抛光性能优良;钢在锻造后应缓冷,并立即进行回火处理。 3Cr13 它属于马氏体型不锈钢,在淬火回火后使用,耐腐蚀性和在700℃以下的热稳定性均比1Cr13 ,2Cr13低,但强度、硬度,淬透性和热强性都较高。冷加工性和焊接性不良,焊后应立即热处理;在退火后有较好的切削性;在锻造后应缓冷,并应立即进行回火处理。 9Cr18 它属于高碳含铬马氏体不锈钢,淬火后具有高的硬度和耐磨性;对海水,盐水等介质尚能抗腐蚀;钢经退火后有很好的切削性;由于会发生硬化和应力裂纹,不适于焊接;为了避免锻后产生裂纹,必须缓慢冷却(最好在炉中冷却),在热态下,将零件转放入700～725℃的炉中进行回火处理。 特点：保持了低碳钢较好的塑性，及成形性；一般料厚不超过0.6mm。 用途：遮蔽磁干扰的遮片及冲制少零件； 中碳钢含锰(Mn)、铬(Cr)、硅(Si)等合金钢； 特性：材料可以产生很大弹性变形，利用弹性变形来吸收冲击或减震，亦可储存能量使机件完成动作。 特点：导电、导热、耐蚀性好，光泽度好，塑性加工容易，易于电镀、涂装。 1.纯铜(含Cu 99.5%以上) 亦称紫铜，材料强度低，塑性好；极好导电性，导热性，耐蚀性；用于电线、电缆、导电设备上。 2.黄铜 铜锌合金，机械性能同含锌量有关；一般锌量不超过50%。 特点：延展性，冲压性好，运用于电镀，对海水及大气腐蚀有好的抗力。但本体容易发生局部腐蚀。 3. 青铜 铜锡合金为主的一类铜基合金金属统称。 特点：比纯铜及黄铜有更好的耐磨性：加工性好，耐腐蚀。 4. 铍铜 含铍(Be)的铜合金； 数据分析个人工作总结 在数据分析岗位工作三个月以来，在公司领导的正确领导下，深入学习关于淘宝网店的相关知识，我已经从一个网店的门外汉成长为对网店有一定了解和认知的人。现向公司领导简单汇报一下我三个月以来的工作情况。 一、虚心学习，努力提高网店数据分析方面的专业知识 作为一个食品专业出身的人，刚进公司时，对网店方面的专业知识及网店运营几乎一无所知，曾经努力学习掌握的数据分析技能在这里根本就用不到，我也曾怀疑过自己的选择，怀疑自己对踏出校门的第一份工作的选择是不是冲动的。但是，公司为我提供了宽松的学习环境和专业的指导，在不断的学习过程中，我慢慢喜欢上自己所选择的行业和工作。一方面，虚心学习每一个与网店相关的数据名词，提高自己在数据分析和处理方面的能力，坚定做好本职工作的信心和决心。另一方面，向周围的同同事学习业务知识和工作方法，取人之长，补己之短，加深了与同事之间的感情。 二、踏实工作，努力完成领导交办的各项工作任务 三个月来，在领导和同事们的支持和配合下，自己主要做了一下几方面的工作： 1.汇总公司的产品信息日报表，并完成信息日报表的每日更新，为产品追单提供可靠依据。 2.协同仓库工作人员盘点库存，汇总库存报表，每天不定时清查入库货品，为各部门的同事提供最可靠的库存数据。 3.完成店铺经营月报表、店铺经营日报表。 4.完成每日客服接待顾客量的统计、客服工作效果及工作转化率的查询。 5.每日两次对店铺里出售的宝贝进行逐个排查，保证每款宝贝的架上数的及时更新，防止出售中的宝贝无故下架。 6.配合领导和其他岗位的同事做好各种数据的查询、统计、分析、汇总等工作。做好数据的核实和上报工作，并确保数据的准确性和及时性。 7.完成领导交代的其它各项工作，认真对待、及时办理、不拖延、不误事、不敷衍，尽量做到让领导放心和满意。 三、存在的不足及今后努力的方向 三个月来，在公司领导和同事们的指导和配合下，自己虽然做了一些力所能 自考02331数据构造重点总结(最后修订) 第一章概论 1.瑞士计算机科学家沃思提出：算法+数据构造=程序。算法是对数据运算描述，而数据构造涉及逻辑构造和存储构造。由此可见，程序设计实质是针对实际问题选取一种好数据构造和设计一种好算法，而好算法在很大限度上取决于描述实际问题数据构造。 2.数据是信息载体。数据元素是数据基本单位。一种数据元素可以由若干个数据项构成，数据项是具备独立含义最小标记单位。数据对象是具备相似性质数据元素集合。 3.数据构造指是数据元素之间互有关系，即数据组织形式。 数据构造普通涉及如下三方面内容：数据逻辑构造、数据存储构造、数据运算 ①数据逻辑构造是从逻辑关系上描述数据，与数据元素存储构造无关，是独立于计算机。 数据逻辑构造分类：线性构造和非线性构造。 线性表是一种典型线性构造。栈、队列、串等都是线性构造。数组、广义表、树和图等数据构造都是非线性构造。 ②数据元素及其关系在计算机内存储方式，称为数据存储构造（物理构造）。 数据存储构造是逻辑构造用计算机语言实现，它依赖于计算机语言。 ③数据运算。最惯用检索、插入、删除、更新、排序等。 4.数据四种基本存储办法：顺序存储、链接存储、索引存储、散列存储 （1）顺序存储：普通借助程序设计语言数组描述。 （2）链接存储：普通借助于程序语言指针来描述。 （3）索引存储：索引表由若干索引项构成。核心字是能唯一标记一种元素一种或各种数据项组合。 （4）散列存储：该办法基本思想是：依照元素核心字直接计算出该元素存储地址。 5.算法必要满足5个准则：输入，0个或各种数据作为输入；输出，产生一种或各种输出；有穷性，算法执行有限步后结束；拟定性，每一条指令含义都明确；可行性，算法是可行。 算法与程序区别：程序必要依赖于计算机程序语言，而一种算法可用自然语言、计算机程序语言、数学语言或商定符号语言来描述。当前惯用描述算法语言有两类：类Pascal和类C。 6.评价算法优劣：算法"对的性"是一方面要考虑。此外，重要考虑如下三点： ①执行算法所耗费时间，即时间复杂性； ②执行算法所耗费存储空间，重要是辅助空间，即空间复杂性； ③算法应易于理解、易于编程，易于调试等，即可读性和可操作性。 1.屋面可变荷载包括屋面均布活荷载、屋面雪荷载和屋面积灰荷载三部分，作用点同屋盖自重。屋面均布活荷载不与屋面雪荷载同时考虑，取两者中的较大值。所以考虑组合时，只有a.屋面均布活荷载+屋面积灰荷载 b.屋面雪荷载+屋面积灰荷载取a, b 中较大值考虑 2.适筋梁（或柱，当主要是梁）受拉纵筋屈服后，截面可以有较大转角，形成类似于铰一样的效果，称作塑性铰。 3.塑性铰与一般理想铰的区别在于：塑性铰不是集中在一点，而是形成一小段局部变形很大的区域；塑性铰为单向铰，仅能沿弯矩作用方向产生一定限度的转动，而理想铰不能承受弯矩，但可以自由转动；塑性铰在钢筋屈服后形成，截面能承受一定的弯矩，但转动能力受到纵筋配筋率、钢筋种类和砼极限压应变的限制。配筋率越大或截面相对受压区高度越大，塑性铰的转动能力却越小。 4.厂房竖向荷载传递路线图 5. a.横向框架承重方案：纵向布置连系梁。横向抗侧刚度大。有利采光和通风。 b.纵向框架承重方案：横向布置连系梁。横向抗侧刚度小。有利获得较高净空。 c.纵横向框架承重方案: 两个方向均有较好的抗侧刚度。 6.为什么钢筋混凝土框架梁的弯距能作塑性调幅？如何进行调幅？调幅与组合的先后次序什么安排？ 答：(1)因为在计算钢筋混凝土框架梁的梁端弯矩时,是按固端支撑计算的,但实际上柱子并不是无限刚性的,这就导致得出的梁端弯矩偏大,所以能进行塑性调幅。 (2)为了减少钢筋混凝土框架梁支座处的配筋数量,在竖向荷载作用下可以考虑框架梁塑性内力重分布,主要是降低支座负弯矩,以减小支座处的配筋,跨中则应相应增大弯矩. (3)在竖向荷载作用下的弯矩应先调幅，再与其它荷载效应进行组合。 7.考虑厂房的整体空间作用时，上柱内力将增大，下柱内力将减小；μ越小，整体空间作用越强。 8.何谓弯矩调幅？考虑塑性内力重分布的分析方法中，为什么要对塑性铰除弯矩调查幅度加以限制？ 答：弯矩调整幅度是指按弹性理论获得的弯矩值与其塑性铰处弯矩绝对值的差值。若弯矩调幅系数β为正值，属于截面弯矩值减小的情况，将导致混凝土裂缝宽度及结构变形增大， 第一章概论 1.数据结构描述的是按照一定逻辑关系组织起来的待处理数据元素的表示及相关操作，涉及数据的逻辑结构、存储结构和运算 2.数据的逻辑结构是从具体问题抽象出来的数学模型，反映了事物的组成结构及事物之间的逻辑关系 可以用一组数据（结点集合K）以及这些数据之间的一组二元关系（关系集合R）来表示：(K, R) 结点集K是由有限个结点组成的集合，每一个结点代表一个数据或一组有明确结构的数据 关系集R是定义在集合K上的一组关系，其中每个关系r（r∈R）都是K×K上的二元关系 3.数据类型 a.基本数据类型 整数类型(integer)、实数类型(real)、布尔类型(boolean)、字符类型（char）、指针类型（pointer）b.复合数据类型 复合类型是由基本数据类型组合而成的数据类型；复合数据类型本身，又可参与定义结构更为复杂的结点类型 4.数据结构的分类：线性结构（一对一）、树型结构（一对多）、图结构（多对多） 5.四种基本存储映射方法：顺序、链接、索引、散列 6.算法的特性：通用性、有效性、确定性、有穷性 7.算法分析：目的是从解决同一个问题的不同算法中选择比较适合的一种，或者对原始算法进行改造、加工、使其优化 8.渐进算法分析 a．大Ο分析法：上限，表明最坏情况 b．Ω分析法：下限，表明最好情况 c．Θ分析法：当上限和下限相同时，表明平均情况 第二章线性表 1.线性结构的基本特征 a.集合中必存在唯一的一个“第一元素” b.集合中必存在唯一的一个“最后元素” c.除最后元素之外，均有唯一的后继 d.除第一元素之外，均有唯一的前驱 2.线性结构的基本特点:均匀性、有序性 3.顺序表 a.主要特性：元素的类型相同；元素顺序地存储在连续存储空间中，每一个元素唯一的索引值；使用常数作为向量长度 b. 线性表中任意元素的存储位置：Loc(ki) = Loc(k0) + i * L（设每个元素需占用L个存储单元） c. 线性表的优缺点： 优点：逻辑结构与存储结构一致；属于随机存取方式，即查找每个元素所花时间基本一样 缺点：空间难以扩充 d.检索：ASL=【Ο（1）】 e.插入：插入前检查是否满了，插入时插入处后的表需要复制【Ο（n）】 f.删除：删除前检查是否是空的，删除时直接覆盖就行了【Ο（n）】 4.链表 4.1单链表 a.特点：逻辑顺序与物理顺序有可能不一致；属于顺序存取的存储结构，即存取每个数据元素所花费的时间不相等 b.带头结点的怎么判定空表：head和tail指向单链表的头结点 c.链表的插入（q->next=p->next; p->next=q;）【Ο（n）】 d.链表的删除（q=p->next; p->next = q->next; delete q;）【Ο（n）】 e.不足：next仅指向后继，不能有效找到前驱 4.2双链表 a.增加前驱指针，弥补单链表的不足 b.带头结点的怎么判定空表:head和tail指向单链表的头结点 c.插入：（q->next = p->next; q->prev = p; p->next = q; q->next->prev = q;） d.删除：（p->prev->next = p->next; p->next->prev = p->prev; p->prev = p->next = NULL; delete p;） 4.3顺序表和链表的比较 4.3.1主要优点 a.顺序表的主要优点 没用使用指针，不用花费附加开销；线性表元素的读访问非常简洁便利 b.链表的主要优点 无需事先了解线性表的长度；允许线性表的长度有很大变化；能够适应经常插入删除内部元素的情况 4.3.2应用场合的选择 a.不宜使用顺序表的场合 经常插入删除时，不宜使用顺序表；线性表的最大长度也是一个重要因素 b.不宜使用链表的场合 当不经常插入删除时，不应选择链表；当指针的存储开销与整个结点内容所占空间相比其比例较大时，应该慎重选择 第三章栈与队列 1.栈 a.栈是一种限定仅在一端进行插入和删除操作的线性表；其特点后进先出；插入：入栈（压栈）；删除：出栈（退栈）；插入、删除一端被称为栈顶（浮动），另一端称为栈底（固定）；实现分为顺序栈和链式栈两种 b.应用： 1）数制转换 while (N) { N%8入栈； N=N/8;} while (栈非空){ 出栈； 输出；} 2）括号匹配检验 不匹配情况：各类括号数量不同；嵌套关系不正确 算法： 逐一处理表达式中的每个字符ch： ch=非括号：不做任何处理 ch=左括号：入栈 ch=右括号：if (栈空) return false else { 出栈，检查匹配情况， if (不匹配) return false } 如果结束后，栈非空，返回false 3）表达式求值 3.1中缀表达式： 计算规则：先括号内，再括号外；同层按照优先级，即先乘*、除/,后加+、减-；相同优先级依据结合律，左结合律即为先左后右 3.2后缀表达式： <表达式> ::= <项><项> + | <项><项>－|<项> <项> ::= <因子><因子> * |<因子><因子>/|<因子> <因子> ::= <常数> ?<常数> ::= <数字>|<数字><常数> <数字> ∷= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 3.3中缀表达式转换为后缀表达式 InfixExp为中缀表达式，PostfixExp为后缀表 达式 初始化操作数栈OP，运算符栈OPND； OPND.push('#'); 读取InfixExp表达式的一项 操作数：直接输出到PostfixExp中； 操作符： 当‘（’：入OPND; 当‘）’：OPND此时若空，则出错；OPND若 非空，栈中元素依次弹出，输入PostfixExpz 中，直到遇到‘（’为止；若为‘（’，弹出即 可 当‘四则运算符’：循环（当栈非空且栈顶不是 ‘（’&& 当前运算符优先级>栈顶运算符优先 级），反复弹出栈顶运算符并输入到 PostfixExp中，再将当前运算符压入栈 3.4后缀表达式求值 初始化操作数栈OP； while （表达式没有处理完) { item = 读取表达式一项; 操作数：入栈OP； 运算符：退出两个操作数， 计算，并将结果入栈} c.递归使用的场合：定义是递归的；数据结构是 递归的；解决问题的方法是递归的 2.队列 a.若线性表的插入操作在一端进行，删除操作 在另一端进行，则称此线性表为队列 b.循环队列判断队满对空： 队空：front==rear；队满： (rear+1)%n==front 第五章二叉树 1.概念 a. 一个结点的子树的个数称为度数 b.二叉树的高度定义为二叉树中层数最大的叶 结点的层数加1 c.二叉树的深度定义为二叉树中层数最大的叶 结点的层数 d.如果一棵二叉树的任何结点，或者是树叶， 或者恰有两棵非空子树，则此二叉树称作满二 叉树 e.如果一颗二叉树最多只有最下面的两层结点 度数可以小于2；最下面一层的结点都集中在 该层最左边的位置上，则称此二叉树为完全二 叉树 f.当二叉树里出现空的子树时，就增加新的、特 殊的结点——空树叶组成扩充二叉树，扩充二 叉树是满二叉树 外部路径长度E：从扩充的二叉树的根到每个 外部结点（新增的空树叶）的路径长度之和 内部路径长度I：扩充的二叉树中从根到每个内 部结点（原来二叉树结点）的路径长度之和 2.性质 a. 二叉树的第i层（根为第0层，i≥0）最多有 2^i个结点 b. 深度为k的二叉树至多有2k+1-1个结点 c. 任何一颗二叉树，度为0的结点比度为2的 结点多一个。n0 = n2 + 1 d. 满二叉树定理：非空满二叉树树叶数等于其 分支结点数加1 e. 满二叉树定理推论：一个非空二叉树的空子 树(指针)数目等于其结点数加1 f. 有n个结点（n>0）的完全二叉树的高度为 ?log2(n+1)?，深度为?log2(n+1)?? g. 对于具有n个结点的完全二叉树，结点按层 次由左到右编号，则有： 1) 如果i = 0为根结点；如果i>0，其父结点 编号是(i-1)/2 2) 当2i+1混凝土结构设计原理复习重点(非常好)
2017年数据分析年度工作总结范文
最新数据分析员工作总结
(完整版)非常实用的数据结构知识点总结
结构设计个人工作总结最新总结
数据分析员年终总结
数据结构复习要点(整理版).docx
结构设计原理知识点
数据结构复习提纲(整理)
关于结构设计基础知识
数据分析师个人工作总结
2021年自考02331数据结构重点总结最终修订
混凝土结构设计复习知识点
大学数据结构期末知识点重点总结
相关主题
文本预览