java入门一DAY01------从数据结构开始1

   个人整理笔记

    好了，数据结构这门课程主要是看的严尉敏版本的，这本确实很经典也很精彩。

    第一章 绪论（笔记）

数据元素是数据结构的基本单位。

数据项是数据结构不可分割的最小单位。

数据结构的定义：数据结构是一门对现实问题进行分析，从已知数据和未知数据中建立数学模型，并构建存储结构以及在计算机上操作和实现的一门学科。

    四种基本结构：集合 线性结构 树形结构 图 

数据结构分为：

    逻辑结构：抽象的，数据关系

    存储结构：顺序存储结构,非顺序存储结构

数据的类型

    抽象数据类型：指一个数学模型以及定义在该模型上的操作

    ADT={数据抽象，数据关系，基本操作}

         定义      表示       操作

    ADT主要是 是对数据的抽象模型

    如下

    ADT抽象据类型名{

        数据对象：<数据对象的定义>

        数据关系：<数据关系的定义>

        基本操作：<基本操作的定义>

    }ADT 抽象数据类名

    基本操作名(参数表)

        初始条件：<初始条件描述>

        操作结果：<操作结果描述>

这种数据类型我们实际编程用的比较多

其他的还有 多形数据类型 主要是指其值的成分不确定的数据类型 三元组数据类型。

算法：是对特定的问题求解的一种描述。

    有5个特性：有穷性 确定性 可行性 输入 输出

算法设计要求达到四个:正确性 可读性 健壮性 效率与低存储量

算法效率的度量：    

    事后分析法，有很多计算机可以采用计时的方式度量

    事前分析估算法：这个主要是根据算法的策略，问题规模，实现算法的语言级别越高执行效率越低，编译和机器执行时间来估        计

时间复杂度

    从算法中选取一种对于所研究的问题来说是基本操作的原操作，以该操作的重复执行的次数作为算法的时间度量。

    在乘法运算中：    

        for(i=1;i<=n;++i)

            for(j=1;j<=n;++j){

                c[i][j]=0;

                    for(k=1;k<=n;++k)

                        c[i][j]+=a[i][k]*b[k][j]  //整个算法的执行时间与该基本操作重复执行的次数N（3）成正比     

       }                                            记作 T(n)==O(n[3])

如何估算算法的时间复杂度

    算法==控制结构+原操作

    算法的执行时间==原操作的执行次数 X 原操作的执行时间

    频度：语句的频度指的是该语句重复执行的次数

算法的空间复杂度：算法所需要的存储空间的度量

    若额外空间相对于输入数据量来说是常数，则称此算法为原地工作

    S(n)==O(F(n))

算法

冒泡排序：

    void bubble_sort(int a[],int n)

        //将a中整数序列重新排序自小至大    

        for(i=n-1,chang=TURE,i>=1&&change;--i){

            change=FALSE;

            for(j=0;j

                if(a[j]>a[j+1]){

                    a[j]<-->a[j,i];change=TURE;   

        }

    }

方法二：

        void BubbleSort（DataType a[],int n）

      {                  

        for(i=0;i<=n-1;i++)

            for(j=0;j<=n-i-1;j++)

                if(a[j]>a[j+1])

                    a[j]<--->a[j+1];

       }

逻辑结构+存储结构+操作==数据结构

存储结构：

    顺序存储结构

    链式存储结构

    索引

    散列

    第二章 线性表（笔记）

线性表示N个数据元素的有限序列

特点：第一个只有后继，最后一个只有前驱，前驱，后继

    1.逻辑上相邻的元素在物理上也相邻

    2.随机访问

类型的定义：数组+长度

基本算法--遍历

    顺序访问所有元素：

    for(i=0;i

        visit(L.elem[i]);

    查找元素xx

    for(i=0;i

        if(L.elem[i]==x) break;

       if(i

         找到；

       else

         未找到；

插入算法 ListInsert(&L,i,x)

    1 表不满的情况下才能插入

    2 合理的插入范围：1<=i<=L.lenght+1

    3.步骤

        第i至最后所有元素后移一个元素

        在第i个元素位置插入元素XX

        表长增加1

    4 算法

    bool ListInsert(Sqlist&L,int i,DataType x){

        if(L.length==MASIZE||i<1||i>L.length+1)

        return false;//失败 元素后移

        for(j=L.length-1;j>=1;j--)  //这里j为下标，从L.length-1到i-1

            L.elem[j+1]=L.elem[j];    

        //插入x

        L.elem[i-1]=x;

        //表长增1

        L.length++;

        return true; //插入成功

    }

删除算法 ListDelete(&L,i&x)

1 表非空

2 合理的删除范围 1<=i<=L.length

3 步骤

    取出第i个元素

    第i个元素之后的元素向前移动一个位置

    表长减1

4 算法

    bool ListDelete(Sqlist&L,int t,DataType&x)

   {

    if(L.length==0||i<1||i>L.lenght)

        return false; //失败

    x=L.elem[i-1];

    for(j=i;j

        L.elem[j-1]=L.elem[j];

    L.length--;

    return ture; //删除成功

    }

单链表-----线性表的链式存储结构之一

概念：线性链表，单链表，结点；数据域，指针域；头指针，头结点。

特点：用指针表示数据之间的逻辑关系（逻辑相邻的元素物理位置不一定相邻）

定义类型：数据+指针

    typedef struct LNode{

    DataType data;

    struct LNode*next;

}LNode, *LinkList;

基本形态

1 单链表空

    条件：L->next==0

2 单链表不空

    条件：L->next!==0

基本算法 遍历：

1 顺序访问所有元素

p=L->next;

while(p!==NULL){

    visit(p->data);

    p=p->next;

}

2 查找元素X

LinkList Find(LinkList L,DataType x)

{

    p=L->next;

    while(p!=NULL){

    if(p->data==x) return p; //找到x

    p=p->next;

 }

    return NULL;    //未找到

}

3 查找第i个元素

LinkList Get(LinkList L,int i)

{

    p=L->next;j=1;

    while(p&&j

    p=p->next;j++;

}

    if(p&&j==i)return p;

    else return 0;

}

4 查找第i-1个元素

p=L; j=0;

while (p&&j

    p=p->next;j++;

}

if(p&&j==i-1)return p;

else return 0;

插入算法 ListInsert（&L,i,x）

思路 先查找到i-1个元素

    若找到，在其后插入新结点

bool ListInsert(LinkList &L,int i,DataType x)

{

    //查找第i-1个元素p

    p=L;j=0;

    while(p&&j

        p=p->next;j++;

    }//若找到，在p后插入x

    if(p&&j==i-1){

    s=(LinkList)malloc(sizeof(Node));

    s->data=x;

    s->next=p->next;

    p->next=s;

    return ture;   

}

else

    return false;

}

删除算法 ListDelete（&L,i,&x）

思路 

    先查找第i-1个元素

    若找到且其后存在第i个元素，则用x返回数据，并删除之

//删除算法

if(p&&j==i-1&&p->next){

    s=p->next;

    p->next=s->next;

    x=s->data;

    fress(s);

    return ture;

}

else

    return false;

建立链表的2种方法

思路

    建立空表（头结点）

    一次插入数据结点（每一次插入尾的（a1,a2,a3...an）,每次插入头得（an,....a2,a1）).

    1 顺序建表

    2 逆序建表

循环链表

特点：最后一个结点的指针指向头结点

类型定义：同单链表 数据+指针

形态：空表：L-next==L 非空表

与单链表的关系

判断表尾的方法不同：单链表用P==NULL;循环链表用P==L; 其余操作相同

双向循环链表

特点：一个结点包括指向后继next和指向前驱的prior两个指针，两个方向又分别构成循环链表。

最大不同：前驱容易求得 判断表尾的方法与循环链表相同：P==L 插入和删除需要修改两个方向的指针

总结：需要反复插入，删除 采用链表合适；

      需要反复提取，很少插入删除采用顺序合适

---------------------- 拖走FM----期待与您交流！ --------

收音机,电台,网上电台,广播,在线广播,网络广播,广播电台,网络电台,在线电台,电台在线收听,广播电台在线收听,网络电台在线收听,在线收听电台,fm收音机,网络收音机,广播下载,在线收音机,收音机软件下载,电台软件下载,网络收音机下载--------------

---------------------- 拖走FM----期待与您交流！ --------