数据结构与算法-1

数据结构与算法-1
Editor Feng / February 15, 2014 / No comments
算法的特征，有穷性，确定性，可行性，输入，输出。
算法的平价，算法的设计要求，正确性，易读性，高效性，可维护性。
分析算法的效率。。。算法整个运行过程所耗费的时间称为算法的时间复杂度，算法整个运行过程所占用的空间称算法的空间复杂度，
算法运算时间的度量通常有两种方法，一事后统计的方法，二事前分析估算的方法。。
用线性累加原则和几何累加原则，


在算法时间复杂度的分析中数量级通常有以下几种？常数，线性函数，幂函数，对数函数指数函数


算法的空间复杂度，算法在存储器内占用的存储空间主要分为三个部分，算法源代码本身占用的存储空间，算法输入输出数据所占用的存储空间，算法运行过程中临时占用的存储空间。。


——————————————————————


线性表，最简单的数据结构，顺序存储结构和链式存储结构。
线性表的常用运算有以下八种，取元素，岔路，删除，求表长，查找，合并，分拆，排序。


顺序表的描述__仅是描述
#define maxlen 1000 //定义顺序标的可能最大 元素数目为1000
typedef int elemtype; //elemtype 表示元素类型 ,简单定义为int
typedef struct {
elemtype elem[maxlen];
int len;
}SqList;


插入


int SqInsert(SqList *L,elemtype x, int i)
{
//在顺序表L前的的第i个数据元素之前插入一个数据
int j,n;
n=(*L).len;
if(i<1||i>n)
{printf(“Error!”); return (0);}
if(n>maxlen)
{printf(“Overflow!”); return (0);}
if(i==n+1) //如果插在末尾就可以直接加上
{(*L).elem[i-1]=x;
(*L).len++; return (1);
}
for (j=n;j>=i;j–)
(*L).elem[j]=(*L).elem[j-1]; //移动后端给空位子
(*L).elem[i-1]=x;
(*L).len++;
return (1);


}
int SqDelete (SqList *L,int i,elemtype *p)
{
//在顺序表里L中删除第i个数据元素
int j,n;
n= (*L).len;
if(i<1||i>n)
{printf(“Error!”) ; return 0;}
p=(*L).elem [i-1];
for(j=i-1;j (*L).elem[j]=(*L).elem[j+1];
(*L).len--;
return 1;
}


int SqSearch(SqList *L ,elemtype x)
{
// 在顺序表L中查找元素x在表中的位置
int j;
for (j=0;j<(*L).len ;j++)
if((*L).elemp[j]==x)
return(j+1);
else
return 0;


}


LinkList *LinkSearch(LinkList *L,elementype x)
{
//在单链表中查找数据元素为x的节点
LinkList *p;
p=L->next;
while (p!=NULL) //如果是循环链表,则改为 while(p!=L)
{
if(p->data!=k)
p=p->next;
else
break;
return (p);


}
}


int LinkInsert (LinkList *L,int i,elemtype x)
{
//在单链表L中第i个数据元素之前插入一个数据元素x
LinkList *p; int j;
p=L; j=0;
while (p!=NULL&&j {p=pp\->next;j++}
if(p==NULL) return(0);
s=(LinkList*)malloc(sizeof(LinkList));
s->data=x;
s->next=p->next; p->next=s;
return (1);
}


int LinkInsert(LinkList *L,int i,elementype x)
{
LInkList *p; int j;
p=L; j=0;
while(p!=NULL) return 0;
s=(LInkList*)malloc(sizeof(LinkList));
s->data =x;
s->next=p->next; p->next=s;
return 1;
}


int LinkDelet(LinkList *L,int i,elemtype *s)
{
LinkList *p,*q; int j;
p=L; j=0;
while (p->next!=NULL&&j {p=p->next; j++;}
if (p->next==NULL) return 0;
q=p->next;
p->next= q->next;
*s = q->data;
free(q);
return 1;


}


//生成单链表
void LinkCreate (LinkList *L,int n)
{
//逆序输入n个元素建立带头结点的单链表
L=(LinkList *)malloc(sizeof(LinkList));
L->next = NULL;
for (i=n;i>0;i–)
{
p=(LinkList*)malloc(sizeof(LinkList));
scanf(“%d”,&p->data);
p->next=L->next; L->next=p;


}
}


栈(stack)是仅限定在标的一端
进行插入或删除操作的线性表.通常把允许插入和删除操作的一端称为栈顶(top),另一端称为栈底(bottom)表空时为空栈.在栈的主要运算为插入和删除,栈的插入操作位进栈或入栈,删除操作位退栈或出栈,栈被称为后进先出表.


//初始化栈
void InitStack(SqStack *s)
{
//构造一个空栈s
s->top = 0;
}
//进栈
int push(SqStack *s, elementype x)
{
//数据元素x插入顺序栈s中成为新的元素
if (s->top == maxnum)
{
printf(“over flow!”);
return (0);
}
s->stack[s->top] = x;
s->top++;
return(1);
}
//出栈
int pop(SqStack *s, elemtype *p)
{
//顺序栈的栈顶元素退栈,*p保存
if (s->top == 0)
{
printf(“stack empty” );
return 0;
}
s->top–;
*p = s->stack[s->top];
return 1;
}
//取栈顶元素
elemetype GetTop(SqStack *s)
{
if (s->top == 0) return 0;
else return (s->stack[--s->top]);
}
//判断栈是否空栈
int StackEmpty(SqStack *s)
{
if (s->top == 0)
return 1;
else return 0;
}


字符串一般简称为串在，汇编和语言的编译程序中源程序和目标程序都是字符串数据。
串的定义，创或字符串是有零个或多个字符组成的有限序列。零个字符的串村为空转它的长度为零，字符串的数目n称为串的长度。
券中了一个连续的字符组成的子序列称为该串的字串，包含子串的串相应地称为主串，通常穿制服在训练中的学号为该字符在串中的位置。


用串变量赋值 assign(s.t)
判等函数 equal(s,t) 若串s和t相等 则返回正值
连接函数concat(s,t) 将两个串连接成一个新串
求长函数 length(s) 统计串中字符的个数返回一个整型值
求子串函数substring(s,pos,len) 求串s中从第pos个字符开始且长度为len的字符串
定位函数index(s,t) 定位s中第一次出现的子串t,若相等,则返回t第一次出现的位置,否则返回0
置换函数 replace (s,t,v) 用v置换s中所有的子串t(非空)
插入子串 insert (s,pos,t) 在字符串s的第pos个字符的前面插入字符t
删除子串 delete (s,pos,k) 从pos字符开始,连续k个字符组成的子串 ,
串的复制 copy(s,t)