数据结构绪论、线性表

第一章 绪论

1.1 什么是数据结构

1.1.1 数据结构的定义

定义：用计算机解决一个具体问题的步骤

（1）分析问题，确定数据模型。

（2）设计相应的算法。

（3）编写程序，运行并调试程序直至得到正确的结果。

1.1.2数据的逻辑结构

逻辑结构的二元组表示：B（D，R）

关系用序偶<x,y>（x,y属于D）表示

1.1.3数据的存储结构

（1）顺序存储结构

（2）链式存储结构

（3）索引存储结构

（4）哈希（或散列）存储结构

1.1.4数据的运算

数据的运算是对数据的操作，分为两个层次：运算描述和运算的实现

1.1.5数据结构和数据类型

抽象数据类型=逻辑结构+抽象运算

抽象数据类型暂不考虑计算机的具体存储结构和运算的具体实现。

抽象数据类型实质上，就是在描述问题本身（与计算机无关）。

1.2算法及其描述

1.2.1什么是算法

算法是对特定问题求解方法和步骤的一种描述，是指令的有限序列。其中每个指令表示一个或者多个操作。

1.2.2算法的描述

Java的8种基本数据类型：

（1）4种整数类型（byte、short、int、long）

1. 两种浮点数类型（float、double）
2. 一种字符类型（char）
3. 一种布尔类型（boolean）

基本数据类型之间的转换：

表示范围小的数据类型可以自动转换成数据表示范围大的数据类型，

通过强制类型转换把一个数据类型转换为另一个数据结构。

基本数据类型的输入

基本数据类型的输出

1. system.out.println();换行
2. system.out.print();不换行
3. system.out.printf();

Java引用类型分为值类型与引用类型。

Java中的类设计

1. 创建类
2. 类成员变量的定义及修饰符
3. 方法的声明与实现
4. 构造方法

创建对象

类名 对象名；

对象名 = new 构造方法名（「参数表」）；

类名 对象名 = new 构造方法名（「参数表」）；

类变量（静态变量和实例变量）和类方法（静态方法和实例方法）

方法的参数传递

1. 参数为基本数据类型的情况
2. 参数为引用类型的情况

Java中的泛型设计、继承、接口、迭代器

1.3算法分析

1.3.1算法设计的要求

1.3.2算法的时间性能分析

一个算法是由控制结构和原操作构成的。

原操作：指固有数据类型的操作。

算法的执行时间取决于控制结构和原操作的综合效果。

时间复杂度是由嵌套最深语句的频度决定的。

 1.3.3算法的存储空间分析

空间复杂度分析只考虑临时占用的存储空间。

1.4数据结构的目标

（1）问题的描述

（2）设计存储结构

（3）算法设计

（4）算法分析

第二章 线性表

2.1线性表的定义

2.1.1什么是线性表

 线性表的逻辑特征：

（1）在非空的线性表，有且仅有开始节点，它没有直接前趋，而仅有一个直接后继

（2）有且仅有一个终端节点，它没有直接后继，而仅有一个直接前趋

（3）其余的内部节点都仅有一个直接前趋和一个直接后继

2.1.2线性表的抽象数据类型描述

数据对象、数据关系、基本运算

2.2线性表的顺序存储结构

2.2.1线性表的顺序存储结构

2.2.2线性表的基本运算算法在顺序表中的实现 

 

 

 

2.2.3顺序表的应用算法设计示例

 

 

2.24顺序表容器——ArrayList

 

 

2.3线性表的链式存储结构 

2.3.1线性表的链式存储结构——链表

 

 

 

2.3.2单链表 

class LinkNode<E>{//单链表结点泛型类
    E data;//结点的指针域
    LinkNode<E>next;//后继结点的指针域

    public LinkNode(){//构造方法

        next=null;
    }
    public LinkNode(E d){//重载构造方法
        this.data=d;
        this.next=null;
    }
}

//单链表泛型类

public class LinkListClass<E> {//链表泛型类
    public LinkNode<E> head;//存放头结点

    public LinkListClass() {//构造方法
        this.head = new LinkNode<E>();//创建头结点
        this.head.next = null;
    }
    //线性表的基本运算算法
    public  void  CreateListF(E[] a){//头插法
        LinkNode<E> s;
        for (int i = 0;i<a.length;i++){
            s = new LinkNode<E>(a[i]);
            s.next = head.next;
            head.next = s;
        }

    }
    public void CreateListR(E[] a){
        LinkNode<E> s,t = head;
        for (int i=0;i<a.length;i++){
            s = new LinkNode<E>(a[i]);
            t.next = s;
            t=s;
        }
        t.next = null;
    }

    private LinkNode<E> geti(int i){
        LinkNode<E> p =head;
        int j = -1;
        while (j<i){
            j++;
            p=p.next;
        }
        return p;
    }
    public void Add(E e){
        LinkNode<E> s = new LinkNode<E>(e);
        LinkNode<E> p = head;
        while (p.next!=null){
            p=p.next;
        }
        p.next=s;
    }
    public  int size(){
        LinkNode<E> p = head;
        int cnt = 0;
        while (p.next!=null){
            cnt++;
            p=p.next;
        }
        return cnt;
    }
    public void Setsize(int nlen){
        int len = size();
        if (nlen<0||nlen>len){
            throw new IllegalArgumentException("设置长度：n不在有效范围内");

        }
        if (nlen==len){
            return;
        }
        LinkNode<E> p = geti(nlen-1);
        p.next = null;
    }
    public E GetElem(int i){
        int len = size();
        if(i<0||i>len-1){
            throw new IllegalArgumentException("查找：位置i不在有效范围内");

        }
        LinkNode<E> p = geti(i);
        return (E)p.data;

    }
    public void SetElem(int i,E e){
        if (i<0||i>size()-1){
            throw new IllegalArgumentException("设置:位置i不在有效范围内");

        }
        LinkNode<E> p = geti(i);
        p.data = e;

    }
    public int GetNo(E e){
        int j = 0;
        LinkNode<E> p = head.next;
        while (p!=null&&!p.data.equals(e)){
            j++;
            p=p.next;
        }
        if (p==null){
            return -1;
        }else {
            return j;
        }
    }
    public void swap(int i ,int j){
        LinkNode<E> p = geti(i);
        LinkNode<E> q = geti(j);
        E tmp = p.data;
        p.data = q.data;
        q.data = tmp;
    }

    public void Insert(int i ,E e){
        if (i<0||i>size()){
            throw new IllegalArgumentException("插入：位置i不在有效范围内");

        }
        LinkNode<E> s = new LinkNode<E>(e);
        LinkNode<E> p = geti(i-1);
        s.next = p.next;
        p.next = s;
    }

    public void Delete(int i){
        if (i<0||i>size()-1){
            throw new IllegalArgumentException("删除：位置i不在有效范围内");

        }
        LinkNode<E> p = geti(i-1);
        p.next=p.next.next;
    }

    @Override
    public String toString() {
        String ans = "";
        LinkNode<E> p = head.next;
        while (p!=null){
            ans+=p.data+"";
            p=p.next;
        }
        return ans;
    }
}

2.3.4双链表 

class DLinkNode<E> {
    E data;
    DLinkNode<E> prior;
    DLinkNode<E> next;
    public DLinkNode() {
        prior = null;
        next = null;
    }
    public DLinkNode(E d) {
        data = d;
        prior = null;
        next = null;
    }


}

public class DLinkListClass<E> extends Date.DLinkNode<E> {
    public Date.DLinkNode<E> dhead;
    private int size;


    public DLinkListClass() {
        dhead = new Date.DLinkNode<E>();
        dhead.prior = null;
        dhead.next = null;
    }


    public void CreateListF(E[] a) {
        Date.DLinkNode<E> s;
        for (int i = 0; i < a.length; i++) {
            s = new Date.DLinkNode<E>(a[i]);
            s.next = dhead.next;
            if (dhead.next != null) {
                dhead.next.prior = s;
                dhead.next = s;
                s.prior = dhead;
            }
        }
    }

2.3.5双链表的应用算法设计示例

public class Ex2_16 {
    public static LinkListClass<Integer> Merge2(LinkListClass<Integer> A,LinkListClass<Integer> B){
        LinkNode<Integer> p=A.head.next;
        LinkNode<Integer> q=B.head.next;
        LinkListClass<Integer> C=new LinkListClass<Integer>();
        LinkNode<Integer> t= C.head;
        while(p!=null && q!=null){
            if(p.data<q.data){
                t.next= p; t=p;
                p= p.next;
            }else {
                t.next= q; t=q;
                q= q.next;
            }
        }
        t.next= null;
        if(p!= null) t.next=p;
        if(q!= null) t.next=q;
        return C;
    }
}