读书笔记-《大话数据结构》第三章线性表之链式存储结构

最新推荐文章于 2024-08-15 05:02:54 发布

weixin_30908707

最新推荐文章于 2024-08-15 05:02:54 发布

阅读量90

点赞数

文章标签：数据结构与算法 c/c++

原文链接：http://www.cnblogs.com/hiwoshixiaoyu/p/10035071.html

版权

线性表之链式存储结构

线性表的顺序存储结构要求逻辑关系上相邻的元素在物理位置上也相邻，这样方便了随机存取，但是在插入和删除元素时，需要移动大量元素，而线性表的链式存储则不要求逻辑上相邻的元素在物理位置上也相邻，因此它没有顺序存储结构的可随机存取的优点，不过在插入和删除元素时比较方便。

1.单链表

一.单链表可由头指针唯一确定，在C语言中可用“结构指针”来描述：

   1: typedef struct Node {

   2:     ElemType     data;

   3:     struct Node *next;

   4: }Node, *LinkList;

有时，我们会在单链表的第一个结点之前附设一个结点，称之为头结点。头结点的数据域可以不存储任何信息，也可以存储如链表的长度等一些附加信息。头结点的指针域指向第一个结点，如果线性表为空，则头结点的指针域为NULL。

#include "stdio.h"
#include <stdlib.h>
#include "string.h
 
typedef int elemType ;
 
/************************************************************************/
/*             以下是关于线性表链接存储（单链表）操作的18种算法        */
 
/* 1.初始化线性表，即置单链表的表头指针为空 */
/* 2.创建线性表，此函数输入负数终止读取数据*/
/* 3.打印链表，链表的遍历*/
/* 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 */
/* 5.返回单链表的长度 */
/* 6.检查单链表是否为空，若为空则返回１，否则返回０ */
/* 7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行 */
/* 8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL */
/* 9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０ */
/* 10.向单链表的表头插入一个元素 */
/* 11.向单链表的末尾添加一个元素 */
/* 12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０ */
/* 13.向有序单链表中插入元素x结点，使得插入后仍然有序 */
/* 14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行 */
/* 15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行 */
/* 16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行 */
/* 17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0 */
/* 18.交换2个元素的位置 */
/* 19.将线性表进行快速排序 */
 
 
/************************************************************************/
typedef struct Node{    /* 定义单链表结点类型 */
    elemType element;
    Node *next;
}Node;
 
 
/* 1.初始化线性表，即置单链表的表头指针为空 */
void initList(Node **pNode)
{
    *pNode = NULL;
    printf("initList函数执行，初始化成功\n");
}
 
/* 2.创建线性表，此函数输入负数终止读取数据*/
Node *creatList(Node *pHead)
{
    Node *p1;
    Node *p2;
 
    p1=p2=(Node *)malloc(sizeof(Node)); //申请新节点
    if(p1 == NULL || p2 ==NULL)
    {
        printf("内存分配失败\n");
        exit(0);
    }
    memset(p1,0,sizeof(Node));
 
    scanf("%d",&p1->element);    //输入新节点
    p1->next = NULL;         //新节点的指针置为空
    while(p1->element > 0)        //输入的值大于0则继续，直到输入的值为负
    {
        if(pHead == NULL)       //空表，接入表头
        {
            pHead = p1;
        }
        else               
        {
            p2->next = p1;       //非空表，接入表尾
        }
        p2 = p1;
        p1=(Node *)malloc(sizeof(Node));    //再重申请一个节点
        if(p1 == NULL || p2 ==NULL)
        {
        printf("内存分配失败\n");
        exit(0);
        }
        memset(p1,0,sizeof(Node));
        scanf("%d",&p1->element);
        p1->next = NULL;
    }
    printf("creatList函数执行，链表创建成功\n");
    return pHead;           //返回链表的头指针
}
 
/* 3.打印链表，链表的遍历*/
void printList(Node *pHead)
{
    if(NULL == pHead)   //链表为空
    {
        printf("PrintList函数执行，链表为空\n");
    }
    else
    {
        while(NULL != pHead)
        {
            printf("%d ",pHead->element);
            pHead = pHead->next;
        }
        printf("\n");
    }
}
 
/* 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 */
void clearList(Node *pHead)
{
    Node *pNext;            //定义一个与pHead相邻节点
 
    if(pHead == NULL)
    {
        printf("clearList函数执行，链表为空\n");
        return;
    }
    while(pHead->next != NULL)
    {
        pNext = pHead->next;//保存下一结点的指针
        free(pHead);
        pHead = pNext;      //表头下移
    }
    printf("clearList函数执行，链表已经清除\n");
}
 
/* 5.返回单链表的长度 */
int sizeList(Node *pHead)
{
    int size = 0;
 
    while(pHead != NULL)
    {
        size++;         //遍历链表size大小比链表的实际长度小1
        pHead = pHead->next;
    }
    printf("sizeList函数执行，链表长度 %d \n",size);
    return size;    //链表的实际长度
}
 
/* 6.检查单链表是否为空，若为空则返回１，否则返回０ */
int isEmptyList(Node *pHead)
{
    if(pHead == NULL)
    {
        printf("isEmptyList函数执行，链表为空\n");
        return 1;
    }
    printf("isEmptyList函数执行，链表非空\n");
 
    return 0;
}
 
/* 7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行 */
elemType getElement(Node *pHead, int pos)
{
    int i=0;
 
    if(pos < 1)
    {
        printf("getElement函数执行，pos值非法\n");
        return 0;
    }
    if(pHead == NULL)
    {
        printf("getElement函数执行，链表为空\n");
        return 0;
        //exit(1);
    }
    while(pHead !=NULL)
    {
        ++i;
        if(i == pos)
        {
            break;
        }
        pHead = pHead->next; //移到下一结点
    }
    if(i < pos)                  //链表长度不足则退出
    {
        printf("getElement函数执行，pos值超出链表长度\n");
        return 0;
    }
 
    return pHead->element;
}
 
/* 8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL */
elemType *getElemAddr(Node *pHead, elemType x)
{
    if(NULL == pHead)
    {
        printf("getElemAddr函数执行，链表为空\n");
        return NULL;
    }
    if(x < 0)
    {
        printf("getElemAddr函数执行，给定值X不合法\n");
        return NULL;
    }
    while((pHead->element != x) && (NULL != pHead->next)) //判断是否到链表末尾，以及是否存在所要找的元素
    {
        pHead = pHead->next;
    }
    if((pHead->element != x) && (pHead != NULL))
    {
        printf("getElemAddr函数执行，在链表中未找到x值\n");
        return NULL;
    }
    if(pHead->element == x)
    {
        printf("getElemAddr函数执行，元素 %d 的地址为 0x%x\n",x,&(pHead->element));
    }
 
    return &(pHead->element);//返回元素的地址
}
 
/* 9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０ */
int modifyElem(Node *pNode,int pos,elemType x)
{
    Node *pHead;
    pHead = pNode;
    int i = 0;
 
    if(NULL == pHead)
    {
        printf("modifyElem函数执行，链表为空\n");
    }
    if(pos < 1)
    {
        printf("modifyElem函数执行，pos值非法\n");
        return 0;
    }
    while(pHead !=NULL)
    {
        ++i;
        if(i == pos)
        {
            break;
        }
        pHead = pHead->next; //移到下一结点
    }
    if(i < pos)                  //链表长度不足则退出
    {
        printf("modifyElem函数执行，pos值超出链表长度\n");
        return 0;
    }
    pNode = pHead;
    pNode->element = x;
    printf("modifyElem函数执行\n");
     
    return 1;
}
 
/* 10.向单链表的表头插入一个元素 */
int insertHeadList(Node **pNode,elemType insertElem)
{
    Node *pInsert;
    pInsert = (Node *)malloc(sizeof(Node));
    memset(pInsert,0,sizeof(Node));
    pInsert->element = insertElem;
    pInsert->next = *pNode;
    *pNode = pInsert;
    printf("insertHeadList函数执行，向表头插入元素成功\n");
 
    return 1;
}
 
/* 11.向单链表的末尾添加一个元素 */
int insertLastList(Node **pNode,elemType insertElem)
{
    Node *pInsert;
    Node *pHead;
    Node *pTmp; //定义一个临时链表用来存放第一个节点
 
    pHead = *pNode;
    pTmp = pHead;
    pInsert = (Node *)malloc(sizeof(Node)); //申请一个新节点
    memset(pInsert,0,sizeof(Node));
    pInsert->element = insertElem;
 
    while(pHead->next != NULL)
    {
        pHead = pHead->next;
    }
    pHead->next = pInsert;   //将链表末尾节点的下一结点指向新添加的节点
    *pNode = pTmp;
    printf("insertLastList函数执行，向表尾插入元素成功\n");
 
    return 1;
}
 
/* 12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０ */
 
 
/* 13.向有序单链表中插入元素x结点，使得插入后仍然有序 */
/* 14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行 */
/* 15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行 */
/* 16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行 */
/* 17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0 */
/* 18.交换2个元素的位置 */
/* 19.将线性表进行快速排序 */
 
/******************************************************************/
int main()
{
    Node *pList=NULL;
    int length = 0;
 
    elemType posElem;
 
    initList(&pList);       //链表初始化
    printList(pList);       //遍历链表，打印链表
 
    pList=creatList(pList); //创建链表
    printList(pList);
     
    sizeList(pList);        //链表的长度
    printList(pList);
 
    isEmptyList(pList);     //判断链表是否为空链表
     
    posElem = getElement(pList,3);  //获取第三个元素，如果元素不足3个，则返回0
    printf("getElement函数执行，位置 3 中的元素为 %d\n",posElem);   
    printList(pList);
 
    getElemAddr(pList,5);   //获得元素5的地址
 
    modifyElem(pList,4,1);  //将链表中位置4上的元素修改为1
    printList(pList);
 
    insertHeadList(&pList,5);   //表头插入元素12
    printList(pList);
 
    insertLastList(&pList,10);  //表尾插入元素10
    printList(pList);
 
    clearList(pList);       //清空链表
    system("pause");
     
}

2.循环链表

表中最后一个结点的指针域指向第一个结点，整个链表形成一个环。

循环链表的操作与单链表基本一致，差别在于算法中的循环条件不是p或者p->next是否为空，而是他们是否等于头指针。

有时候，在循环链表中设立尾指针而不设头指针，可以使某些操作简化。

下面使用C++来实现的

    #include <iostream>  
    using namespace std;  
    template<class Type>  
    struct Node  
    {  
        Type data;  
        Node<Type> *next;  
    };  
    template<class Type>  
    class Circlist  
    {  
    protected:  
        int len;//链表中结点个数  
        Node<Type>* Head; //指向头结点  
    public:  
        Circlist();//默认构造函数  
        Circlist(const Circlist<Type>& otherList);//拷贝构造函数  
        ~Circlist();  
        void createListForward();//头插法  
        void createBackward();//尾插法  
        void initList();//生成头结点，尾部设置为NULL  
        bool isEmptyList();  
        void printList();  
        int  length();  
        void destoryList();  
        void getFirstData(Type& firstItem);  
        void search(const Type searchItem);  
        void insertFirst(const Type newItem);  
        void insertLast(const Type newItem);  
        void insertBefore(const int pos,const Type newItem);  
        void insertAfter(const int pos,const Type newItem);  
        void deleteNode(const Type deleteItem);  
        void deleteNode(const int pos,Type& deleteItem);  
        void reverse();  
        const Circlist<Type>& operator=(const Circlist<Type>&otherList);  
    };  
      
    template<class Type>  
    Circlist<Type>::Circlist() //初始化时，只有一个头结点，有head指向  
    {  
        Head = new Node<Type>;  
        Head->next = Head;  
        len =0;  
    }  
      
    template<class Type>  
    Circlist<Type>::Circlist(const Circlist<Type>&otherList)  
    {  
        Head = new Node<Type>;  
        Head->next = Head;  
        len =0;  
        Node<Type>* current = Head;  
        Node<Type>* otherListCurrent = otherList.Head->next;//otherListCurrent指向第一个元素  
        if (otherList.Head->next != otherList.Head)//被拷贝的表不是空表  
        {  
            while(otherListCurrent->next!=otherList.Head)//拷贝的目标不为空  
            {  
                Node<Type>* newNode = new Node<Type>;  
                newNode->data = otherListCurrent->data;  
                newNode->next = current->next;  
                current->next = newNode;  
                current=current->next;  
                otherListCurrent = otherListCurrent->next;  
                len++;  
            }  
            if (otherListCurrent->next==otherList.Head)  
            {  
                Node<Type>* newNode = new Node<Type>;  
                newNode->data = otherListCurrent->data;  
                newNode->next = current->next;  
                current->next = newNode;  
                len++;  
            }  
        }  
    }  
      
    template<class Type>  
    const Circlist<Type>& Circlist<Type>::operator=(const Circlist<Type>&otherList)//赋值函数  
    {  
        Node<Type>* current = Head;//current总是指向要插的位置  
        Node<Type>* otherListCurrent=otherList.Head->next;//otherListCurrent指向第一个元素  
        if (this!=&otherList)//避免自己给自己赋值  
        {  
            if (current->next!=Head)  
            {  
                initList();//自己有结点，先销毁  
            }  
            while(otherListCurrent!=otherList.Head)  
            {  
                Node<Type>* newNode = new Node<Type>;  
                newNode->data = otherListCurrent->data;  
                newNode->next = current->next;  
                current->next = newNode;  
                current=current->next;  
                otherListCurrent = otherListCurrent->next;  
                len++;  
            }  
              
        }  
        return *this;//为了连续赋值  
    }  
      
    template<class Type>  
    Circlist<Type>::~Circlist()  
    {  
        destoryList();  
    }  
      
    template<class Type>  
    void Circlist<Type>::createListForward()//头插法  
    {  
        Node<Type>* newNode;  
        cout<<"输入链表长度:"<<endl;  
        cin>>len;  
        for (int i=0;i<len;i++)  
        {  
            newNode = new Node<Type>;  
            cout<<"输入元素:"<<endl;  
            cin>>newNode->data;  
            newNode->next=Head->next;  
            Head->next = newNode; //每插入一个结点，都是要把它放在第一个结点的位置  
        }  
    }  
      
    template<class Type>  
    void Circlist<Type>::createBackward()//尾插法  
    {  
        Node<Type>* current = Head;//current指向头结点  
        Node<Type>* newNode;  
        cout<<"输入链表长度:"<<endl;  
        cin>>len;  
        for (int i=0;i<len;i++)  
        {  
            newNode = new Node<Type>;  
            cout<<"输入元素:"<<endl;  
            cin>>newNode->data;  
            newNode->next = current->next;  
            current->next = newNode;  
            current=current->next;  
        }  
    }  
      
    template<class Type>  
    void Circlist<Type>::initList() //只剩下头结点，和指针设置  
    {  
        destoryList();//所有结点都销毁，在重建头结点  
        Head = new Node<Type>;  
        Head->next = Head;  
        len =0;  
    }  
      
    template<class Type>  
    bool Circlist<Type>::isEmptyList()  
    {  
        if (Head->next==Head)  
        {  
            return true;  
        }  
        else  
        {  
            return false;  
        }  
    }  
      
    template<class Type>  
    void Circlist<Type>::printList()  
    {  
        Node<Type>*current=Head->next;  
        while (current!=Head)  
        {  
            cout<<current->data<<endl;  
            current=current->next;  
        }     
    }  
      
    template<class Type>  
    int Circlist<Type>::length()  
    {  
        return len;  
    }  
      
    template<class Type>  
    void Circlist<Type>::destoryList()//销毁包括头结点  
    {  
        Node<Type>* current;  
        Node<Type>* temp;  
        if (Head!=NULL)//析构函数也要调这个函数，因此要判断头是不是为空，为空表示已经释放  
        {  
            temp = Head;  
            current = Head->next;  
            while(current!=Head)  
            {  
                delete temp;  
                temp = current;  
                current = current->next;  
            }  
            delete temp;  
            len=0;  
        }  
    }  
      
    template<class Type>  
    void Circlist<Type>::getFirstData(Type& firstItem)  
    {  
        if (!isEmptyList())  
        {  
            firstItem = (Head->next)->data;  
        }  
        else  
        {  
            cout<<"链表为空!"<<endl;  
        }  
    }  
      
    template<class Type>  
    void Circlist<Type>::search(Type searchItem)  
    {  
        Node<Type>* current;  
        if (isEmptyList())  
        {  
            cout<<"List is Empty"<<endl;  
        }  
        else  
        {  
            current = Head->next;//越过头结点，指向第一个元素  
            while (current!=Head && current->data!=searchItem)  
            {  
                current = current->next;  
            }  
            if (current!=Head)  
            {  
                cout<<searchItem<<"is Found in the list"<<endl;  
            }  
            else  
            {  
                cout<<searchItem<<"Item is not Found in the list"<<endl;  
            }  
        }  
    }  
      
    template<class Type>  
    void Circlist<Type>::insertFirst(const Type newItem)  
    {  
        Node<Type> *newNode = new Node<Type>;  
        newNode->data = newItem;  
        newNode->next = Head->next;  
        Head->next = newNode;  
        len++;  
    }  
      
    template<class Type>  
    void Circlist<Type>::insertLast(const Type newItem)  
    {  
        Node<Type> *newNode = new Node<Type>;  
        newNode->data = newItem;  
        //寻找位置  
        Node<Type>* current = Head;  
        while (current->next != Head)  
        {  
            current = current ->next;  
        }  
        //此时current指向结点的尾部，就是应该插入的位置  
        newNode->next = current->next;  
        current->next = newNode;  
        len++;  
    }  
      
    template<class Type>  
    void Circlist<Type>::insertBefore(const int pos,const Type newItem)  
    {  
        int i=1;  
        Node<Type>* current = Head->next;  
        if (pos<1 || pos>len)  
        {  
            cout<<"插入位置不正确!"<<endl;  
            return;  
        }  
        Node<Type>* newNode = new Node<Type>;  
        newNode->data = newItem;  
        if (1==pos)  
        {  
            newNode->next = Head->next;  
            Head->next = newNode;  
        }  
        else  
        {  
            while(i<pos-1)  
            {  
                current = current->next;  
                i++;  
            }  
            newNode->next = current->next;  
            current->next = newNode;  
        }  
        len++;  
    }  
      
    template<class Type>  
    void Circlist<Type>::insertAfter(const int pos,const Type newItem)  
    {  
        int i=1;  
        Node<Type>* current = Head->next;//current指向第一个位置，和i配合，指向第i个结点  
        if (pos<1 || pos>len)  
        {  
            cout<<"插入位置不正确!"<<endl;  
            return;  
        }  
        Node<Type>* newNode = new Node<Type>;  
        newNode->data = newItem;  
        while(i<pos)  
        {  
            current = current->next;  
            i++;  
        }  
        newNode->next = current->next;  
        current->next = newNode;  
        len++;  
    }  
      
      
      
    template<class Type>  
    void Circlist<Type>::deleteNode(const Type deleteItem)  
    {  
        Node<Type>* current=Head -> next;  
        Node<Type>* trailCurrent = Head;//指向current前面的结点  
        if (isEmptyList())  
        {  
            cout<<"List is Empty"<<endl;  
        }  
        else  
        {  
            while (current!=Head && current->data!=deleteItem)//删除第一个元素后的元素  
            {  
                trailCurrent = current;  
                current=current->next;  
            }  
            if (current==NULL)  
            {  
                cout<<"Item is not Found in the list"<<endl;  
            }  
            else  
            {  
                trailCurrent->next = current->next;  
                delete current;  
                cout<<"Item is delete in the list"<<endl;  
            }  
            len--;  
        }  
    }  
      
    template<class Type>  
    void Circlist<Type>::deleteNode(const int pos,Type& deleteItem)  
    {  
        int i=1;  
        Node<Type>* current = Head;  
        Node<Type>* temp;  
        if (pos<1 || pos>len)  
        {  
            cout<<"删除位置不正确!"<<endl;  
            deleteItem = -1;  
            return;  
        }  
        while(i<pos)  
        {  
            current = current->next;  
            i++;  
        }  
        temp = current->next;  
        current->next = temp->next;  
        deleteItem = temp->data;  
        delete temp;  
        len--;  
    }  
      
    template<class Type>  
    void Circlist<Type>::reverse()  
    {  
        //先处理头结点  
        Node<Type>* current = Head->next;  
        Head->next=Head;  
        if (current==Head)  
        {  
            cout<<"链表为空!"<<endl;  
        }  
        else  
        {  
            while (current!=Head)  
            {  
                Node<Type>* nextCurrent = current->next;  
                current->next = Head->next;  
                Head->next=current;  
                current = nextCurrent;  
            }  
        }  
    }  
      
      
    int main()  
    {  
        Circlist<int> list1;  
        list1.createBackward();  
        list1.reverse();  
        list1.printList();  
        system("pause"); 
		return 0;
    }

3.双向链表

在双向链表的结点中有两个指针域，其一指向直接后继，另一指向直接前驱，在C语言中可描述如下：

   1: typedef struct Node {

   2:     ElemType     data;

   3:     struct Node *next, *prev;

   4: }Node, *LinkList;

和单链表的循环链表类似，双向链表也可以有循环链表。

下面使用C++来实现的

#include <iostream>
using namespace std;

struct Data {
    Data() {
        no=0;
    }

    Data(int _no) {
        no=_no;
    }

    friend ostream & operator << (ostream & os,const Data & d) {
        os<<d.no;
        return os;
    }

    int no;
};

struct Node {
    Node() {
        pNext=NULL;
        prior=NULL;
    }
    Data data;
    Node *pNext;
    Node *prior;

};

struct Link {
    Link() {
        pHead=NULL;
    }

    bool insert(const Data & data) {
        if (pHead==NULL) {
            pHead=new Node;
            pHead->data=data;
            pHead->pNext=pHead;
            pHead->prior=pHead;

            return true;
        }

        if (pHead->data.no>data.no) {
            Node *pNew=new Node;
            pNew->data=data;
            pNew->prior=pHead->prior;
            pHead->prior->pNext=pNew;
            pHead->prior=pNew;
            pNew->pNext=pHead;
            pHead=pNew;

            return true;
        }

        Node *p=pHead;
        do {
            if (p->data.no<data.no&&p->pNext==pHead) {
                Node *pNew=new Node;
                pNew->data=data;
                pNew->pNext=p->pNext;
                pNew->prior=p;
                p->pNext=pNew;
                pHead->prior=pNew;
                return true;
            } else if(p->data.no<data.no&&p->pNext->data.no>data.no) {
                Node *pNew = new Node;
                pNew->data=data;
                pNew->pNext=p->pNext;
                pNew->prior=p;
                p->pNext->prior=pNew;
                p->pNext->prior=pNew;
                p->pNext=pNew;
                return true;
            }
            p=p->pNext;
        } while(p!=pHead);
        return false;
    }
    void print() {
        Node *p=pHead;
        do {

            cout<<p->data<<endl;
            p=p->pNext;

        } while (p!=pHead);
    }
    Node *pHead;
};

int main() {
    Link link;
    link.insert(Data(7));
    link.insert(Data(6));
    link.insert(Data(2));
    link.insert(Data(4));
    link.insert(Data(3));
    link.insert(Data(0));
    link.print();
    system("pause");
    return 0  ;
}

大部分代码是我从网上搜刮来的，我觉得我不太适合研究这些。所以我下一篇想写一下STL相关的介绍，

STL不少的东西更适合开发使用。

转载于:https://www.cnblogs.com/hiwoshixiaoyu/p/10035071.html

weixin_30908707

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
读书笔记-《大话数据结构》第三章线性表之链式存储结构

线性表之链式存储结构线性表的顺序存储结构要求逻辑关系上相邻的元素在物理位置上也相邻，这样方便了随机存取，但是在插入和删除元素时，需要移动大量元素，而线性表的链式存储则不要求逻辑上相邻的元素在物理位置上也相邻，因此它没有顺序存储结构的可随机存取的优点，不过在插入和删除元素时比较方便。1.单链表一.单链表可由头指针唯一确定，在C语言中可用“结构指针”来描述：...
复制链接

扫一扫