数据结构c语言版_c语言数据结构转python 数据结构 - CSDN
数据结构c语言版 订阅
《数据结构C语言版》是1997年清华大学出版社出版的一本图书,作者是严蔚敏,吴伟民。 展开全文
《数据结构C语言版》是1997年清华大学出版社出版的一本图书,作者是严蔚敏,吴伟民。
信息
作    者
严蔚敏,吴伟民
定    价
¥22.00
装    帧
平装
书    名
数据结构C语言版
重    量
0.470KG
出版时间
1997年04月
开    本
16开
出版社
清华大学出版社
ISBN
9787302023685 [十位:7302023689]
页    数
334
数据结构C语言版内容提要
本书的前半部分从抽象数据类型的角度讨论各种基本类型的数据结构及其应用;后半部分主要讨论查找和排序的各种实现方法及综合分析比较。
收起全文
精华内容
参与话题
  • 数据结构C语言版
  • 数据结构C语言版 学习整理

    千次阅读 2019-07-23 16:12:41
    上学期刚学完c语言版数据结构,收获颇丰。趁着暑假在此重新回顾整理,也希望能够与大家分享,欢迎批评指正。 配套用书为严蔚敏 清华大学出版社 《数据结构C语言版)》 详细见更新。啦啦啦,开心鸭。终于自己也有...

    上学期刚学完c语言版的数据结构,收获颇丰。趁着暑假在此重新回顾整理,也希望能够与大家分享,欢迎批评指正。
    配套用书为严蔚敏 清华大学出版社 《数据结构(C语言版)》
    详细见更新。啦啦啦,开心鸭。终于自己也有机会把所学分享给大家看惹~

    展开全文
  • 写在前面: 恰逢期末复习,用了几天时间结合老师勾画的重点以及课件教材等,将全书重要内容做了个大整合。一方面便于自己复习记忆,另一方面po出来让更多需要的人也可以做个参考... 《数据结构C语言版 (清华严...

    写在前面:

    本系列参考书目: 清华大学出版社 《数据结构》(C语言版)

    《数据结构》(C语言版)是为“数据结构”课程编写的教材,是很多学校数据结构课程的指定教材也是经典教材,同时也是考研数据结构的必选书目。

    本系列根据课程重难点 整合此书精华部分,以求在尽可能短的时间内掌握相应知识,希望能够让你有所收获o(* ̄▽ ̄*)ブ

    后续还会进行更进一步的优化整理,欢迎关注,尽请期待。

    同类梳理:

              《数据库系统概论》第五版(王珊版)全书知识梳理

              《计算机组成原理》第五版(唐朔飞考研版) 全书知识梳理

              《软件工程与实践》第三版 软件工程课程知识梳理


    索引目录:

    《数据结构》| 第一章 绪论 知识梳理

    《数据结构》| 第二章 线性表 知识梳理

    《数据结构》| 第三章 栈和队列 知识梳理

    《数据结构》| 第四章 串 知识梳理

    《数据结构》| 第五章 数组和广义表 知识梳理

    《数据结构》| 第六章 树和二叉树 知识梳理

    《数据结构》| 第七章 图 知识梳理

    《数据结构》| 第九章 查找 知识梳理

    《数据结构》| 第十章 排序 知识梳理

     

    如果有什么要补充的,欢迎下方👇评论区留言。

    1份赞许 = 100分的认可,如果感觉还不错,点个赞👍 支持一下吧 ~

    不定期分享 有趣、有料、有营养内容,欢迎 订阅关注 🤝 我的博客 ,期待在这里与你相遇 ~

    上一篇: 8种方法优雅地利用C++编程从1乘到20

    下一篇:  Facebook前身 哈佛大学"选美"网站核心算法 -- ELO等级分制度(附源码)

     

    展开全文
  • 数据结构C语言版本)

    万次阅读 多人点赞 2018-04-22 19:42:32
    数据结构C语言版本) 第1章 绪论 1.常用的数据结构类型:集合、线性、树形、图状。 2.数据结构: - 逻辑结构:数据元素之间的关系 - 存储结构:数据结构在计算机中的表示。存储结构分为:顺序存储结构和...

    数据结构(C语言版本)

    第1章 绪论

    1.常用的数据结构类型:集合、线性、树形、图状。

    2.数据结构:
    - 逻辑结构:数据元素之间的关系
    - 存储结构:数据结构在计算机中的表示。存储结构分为:顺序存储结构和链式存储结构。

    3.算法是对特定问题求解步骤的一种描述,算法具有如下特性:有穷性、确定性、可行性、输入、输出。

    4.算法的度量:
    - 时间复杂度
    - 空间复杂度

    第二章 线性表

    1.线性表的定义:
    - 存在唯一一个“第一个”元素
    - 存在唯一一个“最后一个”元素
    - 除第一个元素外,每一个元素都有且只有一个前驱
    - 除最后一个元素外,每个元素都有且只有一个后继

    2.线性表合并的方法:
    - 将表A中的元素逐个和B中的比较,不同就加入到B中。时间复杂度为O(len(A)*len(B))
    - AB是有序排列的前提下,使用两个指针分别指向A和B,将两者较小的元素插入到C中,然后移动较小的指针,直到全部插入到C。时间复杂度为O(len(A)+len(B))

    3.线性表的顺序实现:满足LOC(A(i+l))=LOC(A(i))+l,LOC表示元素地址。特点:下标读取快O(1),插入删除O(n)。

    #include <stdlib.h>
    #ifndef SEQUENCE_LINER_LIST_H
    #define SEQUENCE_LINER_LIST_H
    
    /*
        线性表的顺序实现
    */
    #define LIST_INIT_SIZE 100  //初始分配量
    #define LIST_INCREMENT 10   //增量
    #define LIST_TYPE int       //存储类型
    
    typedef struct strSequenceLinerList
    {
        LIST_TYPE *elem;        //存储空间基址
        unsigned int length;    //当前长度
        unsigned int listSize;  //当前存储容量
    }SequnceLinerList;
    
    static enum Status
    {
        OK,
        FAILED,
        OVERFLOW
    };
    
    /* 线性表初始化 */
    Status initSequenceLinerList(SequnceLinerList& list)
    {
        list.elem = (LIST_TYPE *)malloc(sizeof(LIST_TYPE)*LIST_INIT_SIZE);
        if (!list.elem)
        {
            return OVERFLOW;
        }
        list.length = 0;
        list.listSize = LIST_INIT_SIZE;
        return OK;
    }
    
    /* 扩展 */
    Status resizeSequenceLinerList(SequnceLinerList& list)
    {
        printf("Resize...\n");
        list.elem = (LIST_TYPE*)realloc(list.elem, sizeof(LIST_TYPE)*(list.listSize + LIST_INCREMENT));
        if (!list.elem)
        {
            return OVERFLOW;
        }
        list.listSize += LIST_INCREMENT;
        return OK;
    }
    
    /* 打印 */
    void printSequnceLinerList(SequnceLinerList& list)
    {
        printf("Begin print list...\n");
        printf("length=%d,listSize=%d.\n",list.length,list.listSize);
        unsigned int i = 0;
        for (; i < list.length-1;++i)
        {
            printf("%d,",list.elem[i]);
        }
        printf("%d\n", list.elem[i]);
        printf("End print list.\n");
    }
    
    /* 线性表插入:position表示插入的位置,从1开始。第一个元素是list.elem[0] */
    Status insertSequenceLinerList(SequnceLinerList& list, unsigned int position, LIST_TYPE value)
    {
        if (position<1 || position>list.length+1)
        {
            return FAILED;
        }
        if (list.length >= list.listSize)
        {
            Status res = resizeSequenceLinerList(list);
            if (OK != res)
            {
                return FAILED;
            }
        }
    
        LIST_TYPE* p = &list.elem[position -1];
        LIST_TYPE* q = &list.elem[list.length];
        for (; p != q; --q)
        {
            *(p + 1) = *p;
        }
        list.length++;
        *p = value;
        return OK;
    }
    
    /* 删除元素 */
    Status deleteSequenceLinerList(SequnceLinerList& list, unsigned int position)
    {
        if (position<1 || position>list.length)
        {
            return FAILED;
        }
    
        LIST_TYPE* p = &list.elem[position - 1];
        LIST_TYPE* q = &list.elem[list.length - 1];
        for (; p != q; ++p)
        {
            *p = *(p+1);
        }
        --list.length;
        return OK;
    }
    
    /* 查找:第一个值的下标 */
    unsigned int findSequenceLinerList(SequnceLinerList& list, int value)
    {
        for (unsigned int i = 0; i < list.length;++i)
        {
            if (value == list.elem[i])
            {
                return i;
            }
        }
        return -1;
    }
    
    /* 排序(冒泡) */
    void sortSequeceLinerList(SequnceLinerList& list)
    {
        unsigned int i = 0;
        unsigned int j = 0;
        for (; i < list.length-1;++i)
        {
            for (j = i + 1; j < list.length; ++j)
            {
                if (list.elem[i]>list.elem[j])
                {
                    LIST_TYPE tmp = list.elem[i];
                    list.elem[i] = list.elem[j];
                    list.elem[j] = tmp;
                }
            }
        }
    }
    
    /* 销毁 */
    void destroySequenceLincerList(SequnceLinerList& list)
    {
        delete list.elem;
        list.elem = NULL;
    }
    
    #endif

    4.线性表的链式实现:通过p=p.next查找具体位置的链表。特点:插入、删除快O(n)。

    #include <stdio.h>
    #include <stdio.h>
    #ifndef LINK_LINER_LIST_H
    #define LINK_lINER_LIST_H
    #define LINK_LIST_TYPE int
    
    /*
        线性表的链表实现
    */
    typedef struct strLinkLinerList
    {
        LINK_LIST_TYPE data;
        struct strLinkLinerList* pNext;
    }LinkLinerList;
    
    LinkLinerList* head = NULL;
    
    /* 链表初始化 */
    Status initLinkLinerList()
    {
        if (NULL == head)
        {
            head = (LinkLinerList*)malloc(sizeof(LinkLinerList));
            if (!head)
            {
                return OVERFLOW;
            }
            head->pNext = NULL;
            return OK;
        }
        else
        {
            return FAILED;
        }
    }
    
    /* 添加元素 */
    Status insertLinkLinerList(LINK_LIST_TYPE value)
    {
        if (NULL == head)
        {
            return FAILED;
        }
        LinkLinerList* p = head;
        while (p->pNext)
        {
            p = p->pNext;
        }
        LinkLinerList* tmp = (LinkLinerList*)malloc(sizeof(LinkLinerList));
        if (!tmp)
        {
            return OVERFLOW;
        }
        tmp->data = value;
        tmp->pNext = NULL;
        p->pNext = tmp;
        return OK;
    }
    
    /*打印*/
    void printLinkLinerList()
    {
        printf("Begin print...\n");
        if (NULL == head || NULL == head->pNext)
        {
            printf("List is null.");
        }
        LinkLinerList* p = head->pNext;
        while (p->pNext)
        {
            printf("%d,",p->data);
            p = p->pNext;
        }
        printf("%d\n", p->data);
        printf("End print.\n");
    }
    
    /* 排序 */
    Status sortLinkLinerList()
    {
        if (NULL == head || NULL == head->pNext)
        {
            return FAILED;
        }
        LinkLinerList* p = head->pNext;
        LinkLinerList* q = p->pNext;
        while (p)
        {
            q = p->pNext;
            while (q)
            {
                if (p->data > q->data)
                {
                    LINK_LIST_TYPE tmp = p->data;
                    p->data = q->data;
                    q->data = tmp;
                }
                q = q->pNext;
            }
            p = p->pNext;
        }
        return OK;
    }
    
    /* 长度 */
    unsigned int lengthLinkLinerList()
    {
        if (head == NULL || head->pNext == NULL)
        {
            return 0;
        }
        LinkLinerList* p = head->pNext;
        unsigned int length = 0;
        while (p)
        {
            p = p->pNext;
            length++;
        }
        return length;
    }
    
    /* 删除 */
    Status deleteLinkLinerList(unsigned int position)
    {
        if (position > lengthLinkLinerList() || position < 1)
        {
            return FAILED;
        }
        else
        {
            LinkLinerList* p = head;
            LinkLinerList* q = p->pNext;
            if (NULL == p || NULL == q)
            {
                return FAILED;
            }
            while (--position)
            {
                p = p->pNext;
                q = p->pNext;
            }
            p->pNext = q->pNext;
            free(q);
            return OK;
        }
    }
    
    /* 销毁 */
    void destroyLinkLinerList()
    {
        if (NULL == head)
        {
            return;
        }
        else
        {
            LinkLinerList* p = head->pNext;
            LinkLinerList* q = p;
            while (p)
            {
                p = p->pNext;
                free(q);
                q = p;
            }
        }
    }
    
    #endif

    上面实现的是线性表的链式结构。此外,线性表通过链表还可以实现:
    - 循环列表:表最后的一个节点的指针指向表头
    - 双列表:指针可以指向下一个元素或者上一个元素

    5.线性表的用途:
    - 一元多项式的表示和相加

    第3章 栈和队列

    1.栈和队列是特殊的线性表。

    2.栈是先进后出的线性表,其表示:typedef struct{Type *base;Type *top; int stacksize;}SqStack;其中base始终指向栈底,top随元素的添加一直指向栈顶。可以有顺序实现和链表实现。

    3.栈的应用举例:
    - 数制转换
    - 括号匹配
    - 行编辑器帮助处理错误输入
    - 迷宫求解
    - 表达式求解
    - 实现递归

    3.队列是先进先出的线性表。可以由链表实现和顺序实现。

    第四章 串

    1.串是由零到多个字符组成的字符序列。

    2.串的模式匹配算法(查找子串):
    - 找到主串中第一个等于子串首字符的位置,开始逐步遍历子串和主串:时间复杂度O(n*(m-n+1)),其中m,n是主串、子串长度
    - kmp算法:关键是部分匹配值的计算(”部分匹配”的实质是,有时候,字符串头部和尾部会有重复。比如,”ABCDAB”之中有两个”AB”,那么它的”部分匹配值”就是2(”AB”的长度)。搜索词移动的时候,第一个”AB”向后移动4位(字符串长度-部分匹配值),就可以来到第二个”AB”的位置)。时间复杂度O(n+m)。KMP算法仅当子串与主串之间存在很多”部分匹配”的情况下才快的多。详见http://kb.cnblogs.com/page/176818/

    第五章 数组和广义表

    1.广义表(Lists,又称列表)是一种非线性的数据结构,是线性表的一种推广。即广义表中放松对表元素的原子限制,容许它们具有其自身结构。

    第六章 树和二叉树

    1.树的相关概念:
    - 度:节点的子树数目称之为节点的度。度为0的节点称之为叶子。
    - 深度:树中结点的最大层次。

    2.二叉树子节点至多有两个,且有左右之分。二叉树有五种基本形态:空、根、右子树为空、左右子树非空、左子树为空。二叉树的性质:
    - 第i层有2^(i-1)个节点
    - 深度为k的二叉树至多2^k-1个节点
    - 终端节点数为n,度为2的节点数为m,则n=m+1
    - 具有n个结点的完全二叉树的深度是(log2N)+1

    3.二叉树分类:
    - 满二叉树:深度为k且有2^k-1个结点的二叉树
    - 完全二叉树:深度为k,有n个结点的二叉树,每个结点的编号与深度为k的满二叉树编号一一对应

    4.二叉树的存储结构:
    - 顺序结构:按照完全二叉树的编号将其存放在一位数组中标有i-1的分量中。
    - 链表结构:typedef struct BitNode{ElemType data; struct BitNode *lchild,*rchild}BitNode;

    5.二叉树的遍历:
    - 先序(根)遍历
    - 中序(根)遍历
    - 后序(根)遍历
    先根和后根反映的是双亲与孩子节点的关系,中根反映的是兄弟节点之间的左右次序。对于表达式而言,这三种遍历分别前缀表达式(波兰表达式)、中缀表达式和后缀表达式(逆波兰表达式)。

    6.二叉树的确定:
    - 已知先根和中根遍历可以建立唯一二叉树
    - 已知后根和中根遍历可以建立唯一二叉树
    - 已知先根和后根遍历不可以建立唯一二叉树

    7.二叉树的遍历可以使用递归实现,其非递归中根遍历的算法是(使用栈操作):

    8.二叉树从根开始分层从左至右遍历算法是(使用队列操作):

    9.线索二叉树:指向前驱或者后继的节点的链成为线索。线索二叉树使用的节点结构为:data、left、right、ltag、rtag。其中ltag(rtag)=0表示子树,=1表示前驱(后继)节点。

    10.赫夫曼树又称最优树,是一类带权路径长度(子叶到根的路径个数)最短的树。赫夫曼树的构造算法:赫夫曼算法:
    - (1)以权值分别为W1,W2...Wn的n各结点,构成n棵二叉树T1,T2,...Tn并组成森林F={T1,T2,...Tn},其中每棵二叉树 Ti仅有一个权值为 Wi的根结点;
    - (2)在F中选取两棵根结点权值最小的树作为左右子树构造一棵新二叉树,并且置新二叉树根结点权值为左右子树上根结点的权值之和(根结点的权值=左右孩子权值之和,叶结点的权值= Wi)
    - (3)从F中删除这两棵二叉树,同时将新二叉树加入到F中;
    - (4)重复(2)、(3)直到F中只含一棵二叉树为止,这棵二叉树就是Huffman树。

    11.赫夫曼树的应用:
    - 不同分数段评定优良中差,可以按照分数出现比例为权值构造赫夫曼数,优化程序判断次序
    - 赫夫曼编码

    第七章 图

    1.图的遍历算法:
    - 深度优先算法
    - 广度优先算法

    第八章 动态管理内存

    第九章 查找

    1.查找算法(详见https://www.cnblogs.com/yw09041432/p/5908444.html)。平均查找长度(Average Search Length,ASL):需和指定key进行比较的关键字的个数的期望值,称为查找算法在查找成功时的平均查找长度。对于含有n个数据元素的查找表,查找成功的平均查找长度为:ASL = Pi*Ci的和。Pi:查找表中第i个数据元素的概率。Ci:找到第i个数据元素时已经比较过的次数。
    - (1)顺序表查找:顺序查找:
    - 要求:存储结构为顺序存储或者链表存储
    - 思想:顺序依次查找
    - ASL:(1/n)*(1+2+…+n)=(n+1)/2
    - 时间复杂度:O(n)
    - (2)二分查找、折半查找:
    - 要求:有序顺序存储列表
    - 思想:先将查找值与中间值比较,查找不成功折半查找区间
    - ASL:log2(n+1)
    - 时间复杂度:O(log2n)
    - (3)插值查找:
    - 要求:有序顺序存储列表
    - 思想:基于二分查找算法,将查找点的选择改进为自适应选择(由mid=low+1/2*(high-low)改为mid=low+(key-a[low])/(a[high]-a[low])*(high-low),),可以提高查找效率。
    - 时间复杂度:O(log2n)
    - (4)斐波那契额查找:
    - 要求:有序顺序存储列表
    - 思想:依然是对查找点的优化,采用Fibonacci数组,找到对于当前长度的有序表的黄金分割点,作为每次的中间值。
    - 时间复杂度:O(log2n)。平均性能,菲波那切查找优于折半查找,最坏情况低于折半查找。
    - (5)二叉查找树:
    - 要求:需要首先二叉查找树(左子树<根<右子树)
    - 思想:先对待查找的数据进行生成树,确保树的左分支的值小于右分支的值,然后在就行和每个节点的父节点比较大小,查找最适合的范围
    - 时间复杂度:O(log2n),最坏O(n),原因是没有保持平衡,形成单支树
    - (6)平衡二叉树AVL:
    - 要求:二叉查找树的基础上,需要进行树的平衡
    - 时间复杂度:一直是O(log2n)
    - 此外,在此基础上还有2-3树,2-3-4树,B+树,红黑树等。

    2.上述算法中:
    - 顺序表查找:(1)
    - 优点:简单
    - 缺点:效率低O(n)
    - 有序表查找:(2)/(3)/(4)
    - 优点:时间复杂度低O(log2n)
    - 缺点:有序表的插入和删除性能是比较差的

    第十章 第十一章 排序

    1.排序算法的稳定性:经过排序,这些记录的相对次序保持不变,即在原序列中,ri=rj,且ri在rj之前,而在排序后的序列中,ri仍在rj之前,则称这种排序算法是稳定的;否则称为不稳定的。例如冒泡排序是稳定的,但是如果交换条件改为a[j].key>=a[j+1].key,就是不稳定的。

    2.排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。

    3.常见的8种内部排序算法有(详见https://www.cnblogs.com/RainyBear/p/5258483.html):
    - 插入排序:将第一个元素看成是有序的序列,之后的元素看成是未排序的序列,然后遍历未排序的序列,将其插入到有序序列中
    - 希尔排序:先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录“基本有序”时,再对全体记录进行依次直接插入排序
    - 选择排序:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
    - 冒泡排序:比较相邻元素,如果前面的大就交换
    - 归并排序
    - 快速排序
    - 堆排序
    - 基数排序

    第十二章 文件

    展开全文
  • 数据结构c语言版 严蔚敏 课本源码

    万次阅读 多人点赞 2018-02-28 20:22:11
    吴伟民概述 数据结构的学习当然要从线性表学起,而线性表里首先需要学习单链表,这里从单链表最简单的顺序存储结构(本质就是可变数组存储)开始。解析 单链表强调元素在逻辑上紧密相邻,所以首先想到用数组存储...

    第2章  线性表 - 单链表顺序存储结构

    ——《数据结构》-严蔚敏.吴伟民版



    概述

           数据结构的学习当然要从线性表学起,而线性表里首先需要学习单链表,这里从单链表最简单的顺序存储结构(本质就是可变数组存储)开始。

    解析

           单链表强调元素在逻辑上紧密相邻,所以首先想到用数组存储。但是普通数组有着无法克服的容量限制,在不知道输入有多少的情况下,很难确定出一个合适的容量。对此,一个较好的解决方案就是使用动态数组。首先用malloc申请一块拥有指定初始容量的内存,这块内存用作存储单链表元素,当录入的内容不断增加,以至于超出了初始容量时,就用calloc扩展内存容量,这样就做到了既不浪费内存,又可以让单链表容量随输入的增加而自适应大小。

           单链表顺序存储结构如下图:

    可能涉及到的语法难点

           刚接触数据结构的同学,单链表顺序存储结构可能会是其面对的第一个坎。这里涉及到了结构体动态数组结构指针,甚至还有函数变量(函数做参数,本质是函数指针),所以需要有相对扎实的语言语法基础。当然,这也并不是说一定得掌握了高级语法才能开始学习数据结构,可以先将语言学到入门(入门意味着学会了提问),再边学数据结构边巩固语法。一定要亲自动手写一写,否则,肯定学不好。

    概述

           数据结构的学习当然要从线性表学起,而线性表里首先需要学习单链表,这里从单链表最简单的顺序存储结构(本质就是可变数组存储)开始。

    解析

           单链表强调元素在逻辑上紧密相邻,所以首先想到用数组存储。但是普通数组有着无法克服的容量限制,在不知道输入有多少的情况下,很难确定出一个合适的容量。对此,一个较好的解决方案就是使用动态数组。首先用malloc申请一块拥有指定初始容量的内存,这块内存用作存储单链表元素,当录入的内容不断增加,以至于超出了初始容量时,就用calloc扩展内存容量,这样就做到了既不浪费内存,又可以让单链表容量随输入的增加而自适应大小。

           单链表顺序存储结构如下图:

    可能涉及到的语法难点

           刚接触数据结构的同学,单链表顺序存储结构可能会是其面对的第一个坎。这里涉及到了结构体动态数组结构指针,甚至还有函数变量(函数做参数,本质是函数指针),所以需要有相对扎实的语言语法基础。当然,这也并不是说一定得掌握了高级语法才能开始学习数据结构,可以先将语言学到入门(入门意味着学会了提问),再边学数据结构边巩固语法。一定要亲自动手写一写,否则,肯定学不好。

    stdlib 是c标准库  typedef 是起名字 

    #include"stdio.h"
    #include"stdlib.h"  
    #define TRUE 1 
    #define  ERROR 0
    typedef struct 
    {
      int * elem; //储存空间基地址     
      int length; // 记录当前链表长度  
      int listsize; //链表规模
    } SqList;
    int InitList(SqList *L)
    {
    (*L).elem =(int*)malloc( 100*sizeof(int) ); //返回NULL 
    if (!(*L).elem) 
         {
     printf("顺序表初始化失败");
      exit(-2); //内存分配失败 
    }
    (*L).length=1;
    (*L).listsize =100;  
        return 1;
    }


    void Clear_Sq(SqList *L)
    {
    (*L).length =0;

    void Destroy(SqList*L)
    {
    free((*L).elem);
    (*L).elem =NULL;

    (*L).length =0;
    }


    int ListEmpty_Sq(SqList L)  //值拷贝  


    {
    return L.length ==0 ?1:0; 

    }


    int ListLength_Sq(SqList L)
    {
        return L.length ;
        
     } 
     
     int  GetEle_Sq(SqList L,int i,int *e)
    {
       if (i<1||i>L.length)
       return 0;
           *e =L.elem[i-1];
           return 1;
     }  
    /*
    往顺序表中插入值。数字下标从零开始。 


    */ 
    int ListInsert_Sq(SqList *L ,int i, int e) 
    {  
       int * newbase;
       int *p,*q;
       if (i<1||i>(*L).length)
        return 0;
       if((*L).length >=(*L).listsize)
        {
        newbase = ( int *)realloc ((*L).elem,((*L).listsize+10)*sizeof(int));
                                    // 第一个参数是线性表节点地址 第二个参数是在开辟多大的内存 。
    (*L) .elem = newbase;
    (*L).listsize+=10;
    }
    q =&(*L).elem[i-1];  
    for (p=&(*L).elem[(*L).length-1];p>=q;--p) //元素储存位置挨个减一 ,插入第一个数不进入这个循环。 
        {
        *(p+1)=*p; 
    }
    *q=e;
    (*L).length++; 
       return 1;

    int LocateElem_Sq(SqList L,int e ) 
    {
       int i=1;
       while(i<L.length && L.elem [i-1]!=e)
        {
    i++;
    }
      if (i<L.length )
       {  return i;
      }
    return 0;
    }
      
    int ListDelete_Sq(SqList *L,int i,int *e)
    {
    int j;
    int *p,*q ;  
     if (i<1||i>(*L).length )
      return 0;
    p=&(*L).elem [i-1];
    *e=*p; 
    q=(*L).elem +(*L).length -1;//elem[length-1]
    for  (++p;p<=q;++p)
    {
    *(p-1)= *p;
     
    }
    (*L).length--;
    return 1;


    /* 线性表遍历 从0到legnth-1; 
    */
    int ListTraverse_Sq(SqList L)
    {
     int i;
     for (i=0;i<L.length-1 ;i++)
         printf(" 打表 %d ",L.elem [i]);

    }
    int main()
    {
    SqList L;
    int  e;
    int i; 
    if(InitList(&L)==1)
     {
      printf("顺序表初始化成功\n"); 
     } 
    printf("当前线性表长度%d\n",L.length-1); 
      //   L.length=1; 
    //ListTraverse_Sq(L);
    for(i=1;i<10;i++)
    ListInsert_Sq(&L,i, 2*i); //插入一个元素  
    printf("当前线性表长度%d\n",L.length-1); 
    printf("4的定 =% d\n",LocateElem_Sq(L,4));
    ListTraverse_Sq(L);
    ListDelete_Sq(&L,2,&e);
    printf("删除的第二个元素是%d\n",e); 
    ListTraverse_Sq(L);
    return 0;

    }

    用插入一个值给链表复制时候如果,链表长度小于1,会出现ele[-1],这个错误。







    概述

           数据结构的学习当然要从线性表学起,而线性表里首先需要学习单链表,这里从单链表最简单的顺序存储结构(本质就是可变数组存储)开始。

    解析

           单链表强调元素在逻辑上紧密相邻,所以首先想到用数组存储。但是普通数组有着无法克服的容量限制,在不知道输入有多少的情况下,很难确定出一个合适的容量。对此,一个较好的解决方案就是使用动态数组。首先用malloc申请一块拥有指定初始容量的内存,这块内存用作存储单链表元素,当录入的内容不断增加,以至于超出了初始容量时,就用calloc扩展内存容量,这样就做到了既不浪费内存,又可以让单链表容量随输入的增加而自适应大小。

           单链表顺序存储结构如下图:

    可能涉及到的语法难点

           刚接触数据结构的同学,单链表顺序存储结构可能会是其面对的第一个坎。这里涉及到了结构体动态数组结构指针,甚至还有函数变量(函数做参数,本质是函数指针),所以需要有相对扎实的语言语法基础。当然,这也并不是说一定得掌握了高级语法才能开始学习数据结构,可以先将语言学到入门(入门意味着学会了提问),再边学数据结构边巩固语法。一定要亲自动手写一写,否则,肯定学不好。

    展开全文
  • 数据结构-用C语言描述耿国华总结笔记(上篇)

    千次阅读 多人点赞 2019-06-01 10:04:30
    数据结构-----用C语言描述 两年前的考研笔记了,再回首,不忍唏嘘,时间过得真快。 下篇:https://blog.csdn.net/weixin_38244174/article/details/90707831 ...
  • 数据结构c语言版)代码

    千次阅读 2019-07-07 03:26:27
    文档中源码及测试数据存放目录:数据结构\▲课本算法实现\▲01 绪论 概述 第一章作为绪论,主要介绍了数据结构与算法中的一些基本概念和术语。对于这些概念术语,我个人不推崇死记硬背,记住了当然好,记不住也...
  • 这是精心整理的关于数据结构比较合适初学者做的习题,内容全面,适合期末复习使用,全是选择填空题,比较基础,难度适中,是一个很好的数据结构C语言版期末总复习题
  • 数据结构C语言版 第2版)课后习题答案 严蔚敏 等 编著,仅供参考,还是自己认真做了再看 第1章 绪论   5.选择题 (1)在数据结构中,从逻辑上可以把数据结构分成( C )。 A.动态结构和静态结构 B....
  • 数据结构C语言版(答案)

    万次阅读 多人点赞 2012-09-15 22:27:25
    1.1 简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。 解:数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。  ...
  • 数据结构与算法分析 C语言描述(原书第2)下载链接: https://pan.baidu.com/s/1VrsrvtCujFHbseuJjXJACA 提取码获取方式:关注下面微信公众号,回复关键字: 1136
  • 书 名:数据结构与算法分析:C语言描述  作 者:Mark Allen Weiss (维斯)   ISBN :9787111127482    页 数:391  定 价:35  出版社:机械工
  • 最近在慢慢写数据结构与算法分析(C语言描述)的课后习题答案。 地址:https://github.com/seineo/Data-Structures-and-Algorithm-Analysis-in-C(Please star it!!!) 有兴趣的朋友也可以follow一下:...
  • 数据结构题集(c语言版)严蔚敏答案pdf

    万次阅读 多人点赞 2020-03-07 11:51:58
    前言:最近在学习数据结构,在做习题的时候找答案费了一番力气,好不容易找到了,分享出来,希望想学的人找得没那么累 图书目录: 第一篇 习题与学习指导 第0章 本篇提要与作业规范 第1章 绪论(预备知识) 第2章 ...
  • 给大家分享一下数据结构C语言版第二版的答案及源程序 链接:https://pan.baidu.com/s/1P5-jn8_oqsJ4Wq_V2X3ybw 提取码:s7y8
  • (){function onclick(){return checkUrl(this)}}" href="ftp://202.106.156.143/down/computer/数据结构C语言版视频教程01.rar" target="_blank">ftp://202.106.156.143/do
  • zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
  • 期末复习看了很多博客来确定自己的课后答案,大同小异,很多博客转载的都是上面这位大佬的文章,很详细。美中不足,少了第四章。 先把选择题答案给大家,供大家核对。 1--5 BBCAB 6--10 BBCBB 11--15 ABDBC ...
  • 数据结构C语言版严蔚敏吴伟民PDF版 紫色封面 求数据结构C语言版严蔚敏吴伟民PDF版 紫色封面 求数据结构C语言版严蔚敏吴伟民PDF版 紫色封面
  • 数据结构C语言版——初始化一个线性表

    万次阅读 多人点赞 2017-03-09 20:31:44
    数据结构C语言版——初始化一个线性表
1 2 3 4 5 ... 20
收藏数 278,809
精华内容 111,523
关键字:

数据结构c语言版