精华内容
下载资源
问答
  • /*链表表头插入数据,使用了一个头结点head专门记录表头位置*/ typedef struct node { int key; struct node *Next; }Node; void Insert(int num,Node *head)//插入新的节点 { Node *p = NULL; p = (Node *...
    #include  <stdio.h>
    #include  <stdlib.h>
    /*链表,在表头插入数据,使用了一个头结点head专门记录表头位置*/
    typedef struct node
    {
    	int key;
    	struct node *Next;
    }Node;
    void Insert(int num,Node *head)//插入新的节点 
    {
    	Node *p = NULL;
    	p = (Node *) malloc (sizeof(Node));//开辟新的节点 
     	p->key = num;//赋值 
    	p->Next=head->Next;//将原来的头结点挂在新节点后,并把新节点挂在表头上 
    	head->Next=p;
    }
    void Print_List(Node *head)
    {
    	Node *p = head->Next;
    	while(p != NULL)//遍历打印节点值 
    	{
    		printf("%d->", p->key);
    		p = p->Next;
    	}
    	printf("\n");
    }
    Node *Search_List(Node *head,int num)//寻找值为num的节点,并返回位置指针 
    {
         Node *p=NULL; p=head;
         while((p->Next!=NULL)&&p->key!=num)
             p=p->Next;
         if(p->Next==NULL)
         {
              printf("不存在值为%d的节点,将返回头结点",num);
              return head;
         }
         return p;     
         
    } 
    void Delete_List(Node *head,int num)//删除值为num的节点
    {
         Node *p=NULL; p=head;
         Node *pf=NULL;//记录p的前节点 
         while((p->Next!=NULL)&&p->key!=num)
         {
             pf=p;
             p=p->Next;
         }
         if(p->Next==NULL&&p->key!=num)
              printf("不存在值为%d的节点",num);
         else
         {
             pf->Next=p->Next;
         }
    } 
    int main()
    {	
    	int i;
    	Node *p=NULL;
    	Node *head = (Node *)malloc(sizeof(Node));
    	head->Next = NULL;//建立空表头 
    	for (i=0; i<10; i++)
    	{
    		Insert(i, head);
    	}
    	Print_List(head);
    	printf("输入你要查找的值:");
    	scanf("%d",&i);
    	p=Search_List(head,i);
    	printf("已查到节点,值为:%d",p->key); 
    	printf("输入你要删除的值:");
    	scanf("%d",&i);
    	Delete_List(head,i);
    	printf("删除以后\n");
    	Print_List(head);
    	system("PAUSE");
    	return 0;
    }
    


    
    
    
    
    
    
    
    
    展开全文
  • C++实现一个简单的单向链表

    千次阅读 2016-09-17 21:00:04
    最近linux了一个简单的单向链表,直接上代码 链表头文件 list.h #ifndef _LIST_H_ #define _LIST_H_ typedef int T; template class List { private:  struct Node  {  T data;  Node* next...

    最近在linux了一个简单的单向链表,直接上代码

    链表头文件   list.h

    #ifndef _LIST_H_
    #define _LIST_H_

    typedef int T;

    template<typename T>
    class List
    {
    private:
        struct Node
        {
            T      data;
            Node*  next;
            Node(const T& d=T()):data(d),next(NULL){} //零初始化
        };
        Node* head;//头指针,用来保存头节点的地址
        int len;
    public:
        List():head(NULL),len(0){}
        List(const List& l);
        void operator=(const List& l);
        ~List();
        T getElementAtIndex(int index)const;//取得链表中指定位置的元素值
        List<T>& push_front(const T& d);//前插
        List<T>& push_back(const T& d); //尾插
        int size()const;//获取链表中节点个数
        Node*& getptr(int pos); //在链表中找指向指定位置的指针
        List<T>& insert(const T& d,int pos); //在任意位置插入
        void travel()const; //遍历
        void clear(); //清空链表
        void erase(int pos); //删除链表中指定位置的元素
        int find(const T& d)const; //查找指定数值的元素在链表中出现的位置
        void remove(const T& d); //删除链表中指定的元素
        void set(int pos,const T& d);
        bool empty()const;
        const T& front()const;
        const T& back()const;
        void reverse();//链表元素倒置
    };

    #endif

    链表实现文件 list.cpp

    #include <iostream>
    #include <string>
    #include "list.h"

    using namespace std;

    template<typename T>
    List<T>::List(const List<T>& l)
    {
        len = l.len;
        Node* items[len];
        for(int i=0;i<len;i++)
        {
            items[i] = new Node(l.getElementAtIndex(i));
        }
        for(int i=0;i<len-1;i++)
        {
            items[i]->next = items[i+1];
        }
        head = items[0];
    }

    template<typename T>
    void List<T>::operator=(const List<T>& l)
    {
        clear();    
        len = l.len;
        Node* items[len];
        for(int i=0;i<len;i++)
        {
            items[i] = new Node(l.getElementAtIndex(i));
        }
        for(int i=0;i<len-1;i++)
        {
            items[i]->next = items[i+1];
        }
        head = items[0];
    }

    template<typename T>
    List<T>::~List()
    {
        clear();
    }

    //取得链表中指定位置的元素值
    template<typename T>
    T List<T>::getElementAtIndex(int index)const  
    {
        if(index < 0 || index >= len) throw "索引位置越界";
        if(index == 0) return head->data;
        Node* p = head;
        for(int i=1;i<index;i++)
        {
            p = p->next;
        }
        return p->next->data;
    }

    //前插
    template<typename T>
    List<T>& List<T>::push_front(const T& d)
    {
        insert(d,0);
        return *this;
    }

    //后插
    template<typename T>
    List<T>& List<T>::push_back(const T& d)
    {
        insert(d,len);
        return *this;
    }

    //获取链表中节点个数
    template<typename T>
    int List<T>::size()const
    {
        return len;
    }
        
    //在链表中找指向指定位置的指针
    template<typename T>
    typename List<T>::Node*& List<T>::getptr(int pos)
    {
        if(pos < 0 || pos > len) pos = 0;
        if(pos == 0) return head;
        Node* p = head;
        for(int i=1;i<pos;i++)
        {
            p = p->next;
        }
        return p->next;
    }

    //在任意位置插入节点
    template<typename T>
    List<T>& List<T>::insert(const T& d,int pos)
    {
        Node*& pn = getptr(pos);
        Node* p = new Node(d);
        p->next = pn;
        pn = p;
        ++len;
        return *this;
    }

    //遍历
    template<typename T>
    void List<T>::travel()const
    {
        Node* p = head;
        while(p)
        {
            cout << p->data << ' ';
            p = p->next;
        }
        cout << endl;
    }

    //清空链表
    template<typename T>
    void List<T>::clear()
    {
        while(head)
        {
            Node* p = head->next;
            delete head;
            head = p;
        }
        len = 0;
    }
        
    //删除链表中指定位置的节点
    template<typename T>
    void List<T>::erase(int pos)
    {
        if(pos < 0 || pos >= len) return;//有效位置为0~len-1
        Node*& pn = getptr(pos);
        Node* p = pn;
        pn = pn->next;
        delete p;
        --len;
    }

    //查找指定数值的节点在链表中出现的位置
    template<typename T>
    int List<T>::find(const T& d)const
    {
        Node* p = head;
        int pos = 0;
        while(p)
        {
            if(p->data == d)
              return pos;
            else
              p = p->next;
            ++pos;
        }
        return -1;
    }
        
    //删除链表中指定数值的节点
    template<typename T>
    void List<T>::remove(const T& d)
    {
        int pos;
        while((pos = find(d))!= -1)
        {
            erase(pos);
        }
    }

    //修改指定位置的节点数据
    template<typename T>
    void List<T>::set(int pos,const T& d)
    {
        if(pos < 0 || pos >= len) return;
        getptr(pos)->data = d;
    }

    //判断链表是否为空
    template<typename T>
    bool List<T>::empty()const
    {
        return head == NULL;
    }

    //取得链表中第一个节点数据
    template<typename T>
    const T& List<T>::front()const
    {
        if(empty()) throw "空";
        return head->data;
    }

    //取得链表中最后一个节点数据
    template<typename T>
    const T& List<T>::back()const
    {
        if(empty()) throw "空";
        Node* p = head;
        while(p->next)
        {
            p = p->next;
        }
        return p->data;
    }

    //将链表中的元素倒置
    template<typename T>
    void List<T>::reverse()
    {
        if(head == NULL) return;
        Node *pre,*cur,*next;
        pre = head;
        cur = head->next;
        while(cur)
        {
            next = cur->next;
             cur->next = pre;
             pre = cur;
             cur = next;
         }
         head->next = NULL;
         head = pre;
    }


    template class List<T>; // 显式实例化

    链表测试文件 listTest.cpp

    #include <iostream>
    #include "list.h"

    //typedef int T;
    using namespace std;

    int main()
    {
        List<T> l;
        List<T> m;
        l.push_front(5); //5
        l.push_front(8); //8 5
        l.push_front(20);// 20 8 5
        l.insert(9,2); // 20 8 9 5
        l.insert(8,100); //6 20 8 9 5
        l.insert(11,-10);//11 6 20 8 9 5
        l.insert(9,2);//11 6 1 20 8 9 5
        l.push_back(10).push_back(19);//11 8 9 20 8 9 5 10 19
        l.travel();
        l.reverse();
        l.travel();

        l.remove(8);
        l.remove(9);
        l.set(1,33);
        l.set(l.find(19),-8);

    //    cout << l.front() << "      " << l.back() << endl;
        l.travel();  // 11 33 5 10 -8

    //    while(!l.empty()) l.erase(0);
     //   cout << l.size() << endl;
        
     //   cout << l.getElementAtIndex(0) << endl;
        m.insert(-9,0);
        m.insert(13,1);
        m.push_front(-5);
        m.push_back(2);
        cout << "========m链表原始值======" << endl;
        m.travel();// -5 -9 13 2

        m = l;
        cout <<"==========将链表m中元素倒置==========" << endl;
        m.reverse();
        m.travel();
        cout <<"===========程序结束======" << endl;

        return 0;
    }


    展开全文
  • 单向链表中循环的查找方法总结

    千次阅读 2016-04-16 10:41:52
    一个单向链表中可能存在循环,如何判断单向链表中是否存在循环,又如何找到循环部分的起始节点?如果是非循环链表,如何找到中间节点? 本文结合网上找到的资料及自己的分析,进行了总结。

    一个单向链表中可能存在循环,如何判断单向链表中是否存在循环,又如何找到循环部分的起始节点?如果是非循环链表,如何找到中间节点?
    本文结合网上找到的资料及自己的分析,进行了总结。

    链表节点定义如下:

    typedef struct _node
    {
    int data;
    struct _node *next;
    }node,*pnode;

    1、判断单向链表中是否存在循环链表

    思路:设置两个指针,初始值都指向头节点,然后开始遍历,一个指针每次走一步,另一个指针每次走两步,如果存在循环链表,这两个链表肯定能相遇

    代码:

    //返回0表示没有循环
    //返回1表示有循环
    int FindLoop(node *head)
    {
    node *pOneStep, *pTwoStep;
    int iReturn = 0;
    if (NULL == head)
    return 0;


    pOneStep = head;
    pTwoStep = head;


    while ((NULL!=pTwoStep)&&(NULL!=pTwoStep->next))
    {
    pOneStep = pOneStep->next;
    pTwoStep = pTwoStep->next->next;
    if (pTwoStep == pOneStep)
    return 1;
    }
    return 0;
    }

    2、找到单向非循环链表的中间节点

    注意,是非循环链表

    思路:设置两个指针,初始值都指向头节点,然后开始遍历,一个指针每次走一步,另一个指针每次走两步,走两步的指针到链表末尾时,走一步的指针刚好就指向了中间节点

    代码:

    node* FindNoLoopListMiddleNode(node *head)
    {
    node *pOneStep, *pTwoStep;
    if (NULL == head || NULL==head->next)
    return head;
    pOneStep = head;
    pTwoStep = head;


    while ((NULL != pTwoStep) && (NULL != pTwoStep->next))
    {
    pTwoStep = pTwoStep->next->next;
    if (NULL != pTwoStep)
    pOneStep = pOneStep->next;
    }
    return pOneStep;
    }


    3、查找单向循环链表中的循环部分的起始节点

    方法一:

    首先用判断单向链表中是否存在循环链表的思路到达相遇节点,然后设置两个指针,分别从相遇节点和头节点单步进行遍历,两个指针相遇的节点就是循环的起始节点

    关于这个思路的详细解释请自行查询或参考链接:http://www.cnblogs.com/cyttina/archive/2012/10/28/2743760.html

    //寻找环的入口点
    NodeList FindLoopPort(NodeList head)
    {
        NodeList slow=head,fast=head;
        //得到相遇点
        while(fast && fast->next)
        {
            slow=slow->next;
            fast=fast->next->next;
            if(slow==fast)
                break;
        }
        if(fast==NULL||fast->next==NULL)
            return NULL;
        //slow指向开头,fast在相遇点
        //得到入口点
        slow=head;
        while(slow!=fast){
            slow=slow->next;
            fast=fast->next;
        }
        return slow;
    }

    方法二:

    思路: 设置两个指针 p1和p2,用p2遍历整个链表,用p1遍历p2走过的节点,当p1等于p2->next时,p1就是循环部分的起始节点。

    这种方法与第一种方法相比,理解起来会简单很多,但算法复杂度有所提高。

    代码:

    //没有循环返回NULL
    //如果存在循环返回循环起始节点的指针
    node* FindLoopNode(node *head)
    {
    node *pc = head;
    node *pf = NULL;
    if (!pc)
    return NULL;
    while (pc)
    {
    pf = head;
    while(pf && pf != pc)
    {
    //当前结点的下一个结点是它前面的某个结点或者是它自己,则为循环处
    if (pc->next == pf || pc->next == pc)
    return pc->next;
    pf = pf->next;
    }
    pc = pc->next;
    }
    return NULL;
    }

    展开全文
  • 1、有10个学生,每个学生的数据包括学号、姓名和1...(3) 输入一个学生的学号,查找链表中是否有该学生; (4) 第i个学生前插入一个学生信息; (5) 删除链表中第i个学生。 #include #include #define N 10 typede

    欢迎加qq群:453398542 学习讨论,会定期分享资料课程,解答问题。

    1、         有10个学生,每个学生的数据包括学号、姓名和1门课成绩,编写如下函数:

    (1)    根据学生的信息建立链表;

    (2)    输出链表;

    (3)    输入一个学生的学号,查找链表中是否有该学生;

    (4)    在第i个学生前插入一个学生信息;

    (5)    删除链表中第i个学生。

    #include<stdio.h>

    #include<stdlib.h> 

    #define N 10

    typedef struct Student{

    int num;

    char name[20];

    float score;

    }S;

    typedef struct Node{

    S date;

    struct Node *next;

    }Node,*LinkList;

    LinkList createlist(int n){

    int i;

    LinkList head,pre,p;

    head=pre=(LinkList)malloc(sizeof(Node));

    for(i=0;i<n;i++){

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

    scanf("%d%s%f",&(p->date.num),p->date.name,&(p->date.score));

    pre->next=p;

    pre=p;

    }

    pre->next=NULL; 

    return head; 

    }//输入 

    void output(LinkList head){

    LinkList p;

    p=head->next;

    while(p!=NULL){

    printf("%5d%10s%5.1f\n",p->date.num,p->date.name,p->date.score);

    p=p->next;

    }

    printf("\n");

    }//输出 

    void search(LinkList head,int n){

    LinkList p;

    p=head->next;

    while(p!=NULL)

    if(p->date.num==n)

    break;

    else

    p=p->next;

    if(p==NULL)

    printf("表中无学号为%d的学生。\n",n);

    else

    {

    printf("满足条件的同学的信息如下:\n");

    printf("%8d%10s%.1f",p->date.num,p->date.name,p->date.score);

    }

    printf("\n");

    }//查找 

    LinkList insert_node(LinkList head,int i,S st){

    int j;

    LinkList p,s;

    p=head; j=0;

    while(p!=NULL&&j<i){

    j++; p=p->next;

    }

    if(!p||j>i){

    printf("传递的参数非法\n");

    return NULL;

    }

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

    s->date=st;

    s->next=p->next;

    p->next=s;

    return 0;

    } //插入 

    LinkList delete_node(LinkList head,int i){

    int j;

    LinkList p,q;

    p=head; j=1;

    while(p->next!=NULL&&j<i){

    j++; p=p->next;

    }

    if(!p->next||j>i){

    printf("传递的数据非法\n");

    return NULL;

    }

    q=p->next; p->next=q->next;

    free(q);

    return head;

    }//删除 

    int main(){

    int i,n,a,b;

    S stu;

    LinkList head;

    printf("输入学生个数:\n");

    scanf("%d",&n);

      head=createlist(n);

      output(head);

        printf("输入一个学生的学号:\n");

      scanf("%d",&a);

      search(head,a);

      printf("插入一个学生;\n");

      scanf("%d%s%f",&stu.num,stu.name,&stu.score);

      printf("输入插入位置:\n");

      scanf("%d",&i);

      insert_node(head,i,stu);

      printf("删除第%d个学生;\n",i);

      delete_node(head,i);

      output(head);

    return 0;

    }

    展开全文
  • 1、什么是哈希表 2、主要方法的逻辑和代码实现 1)put()方法 2)get()方法 3) remove()方法 1、哈希表 hash,哈希表这个词,以前接触过好多次了,对哈希表了解最多的就是,这玩意儿也是...本文,我用的是一个数...
  • 本文将来讲解一下种常见的线性数据结构—链表,因为链表和数组一样都是种线性的数据结构,但是它俩的实现原理是完全不同的,所以讲解链表之前,我们来回顾一下 数组 结构。
  • 二分法是种快速查找的方法,时间复杂度低,逻辑简单易懂,总的来说就是不断的除以2除以2... 例如需要查找有序list里面的某个关键字key的位置,那么首先确认list的位数mid,下面分为三种情况: 如果 list[mid] ...
  • 上一篇文章讲解了链表的相关知识,并用代码实现了一个链表结构。那么本文将介绍一下另一种特殊的链表结构,叫做 双向链表。 顾名思义,普通的链表都是从 head 开始往后遍历结构内的元素,那么双向链表就是既可以从头...
  • C语言-------实现一个简单的单向链表

    千次阅读 2017-02-09 20:12:54
    编写一个链表程序,程序实现简单的功能#include #include struct node{ int num; char name[20]; struct node* next; //指向下一个地址的指针 }; //声明一个链表,此时内存不分配内存 typedef struct node...
  • 今天本人想要复习的是哈希表(散列表)的概念及具体实现,为此用java写了一个简单的实现,但仅仅只是实现了一些简单的功能,不过通过这个简单的实现的确可以帮助我们进一步理解JDK的HashMap,当然,想要进一步了解...
  • 【Java基础】【写一个简单链表

    千次阅读 2018-01-11 20:59:20
    1. 定义一个Link类和一个Node类,其中Node类为Link类的内部类(避免了反复的getter和setter方法) Link类的目的是进行节点创建 Node类的目的是进行数据和节点链接,并且Node只能为Link调用,需要定义为private 再...
  • 简单易懂的C语言实现双向链表代码

    万次阅读 2017-12-01 14:01:58
    链表是一种常见的数据结构,链表中的每一个节点都保存了上一个或下一个元素的位置,所以表现为增删元素效率较高,查找元素效率较低 简单的C语言实现代码: #include #include #include //节点结构体,每个节点...
  • Java实现简单链表-面向初学者

    万次阅读 多人点赞 2018-07-15 02:24:24
    就先用JAVA实现一个简单链表好了,还是使用最原始的C语言实现的思路,想来语言变了实现方式大同小异吧。后续可能会不断实现不一样的数据结构。 节点 先确定节点数据结构(一个节点一个数字好了),后续慢慢一点点...
  • 链表

    千次阅读 2010-03-04 11:25:00
    单链表:LinkList类,只有一个数据项,即对链表中一个链节点的引用,叫做first。他是唯一的链表需要维护的永久信息,用以定位所有其他的链结点。从first出发,沿着链表通过每个链结点(Link类的实例)的next字段,...
  • 链表动画图解及简单操作

    千次阅读 2019-09-06 20:04:50
    链表动画理解及简单操作链表简述及理解链表简单操作及图解这是关于链表的一些基本的操作,作为记录也是复习遍。因为是刚开 链表简述及理解 这里需要强调的是学习后面内容的同时要把C语言的指针和结构体掌握 ...
  • 链表基础知识总结

    万次阅读 多人点赞 2018-05-02 19:47:49
    链表和数组作为算法的两基本数据结构,程序设计过程经常用到。尽管两种结构都可以用来存储系列的数据,但又各有各的特点。数组的优势,在于可以方便的遍历查找需要的数据。查询数组指定位置(如查询数组...
  • Java双向链表简单实现

    千次阅读 2019-03-13 14:40:23
    LinkImpl类用于实现ILink的方法类,连接整个l链表,并内部定义内部类Node Node类用于存放实际数据,data,以及前后结点 定义内部类的最大好处:就是可以直接访问内部类的私有属性 下面直接上传代码: ILink...
  • 链表简单创建——C

    千次阅读 2011-01-27 10:19:00
    题目:创建固定长度的单向链表 <br /> 程序分析:链表是动态分配存储空间的链式存储结构, 其包括一个“头指针”变量,其中第0个结点称为整个链表的头结点,头结点存放一个地址,该地址指向...
  • 动画:面试如何轻松手写链表

    万次阅读 多人点赞 2019-09-26 08:10:31
    暑假参加的第一个公司的就让我手写一个双向链表,并完成插入数据和删除数据的操作。当时我很蒙蔽,懵逼的不是思路,而是手写,虽然写出来了,但是很多边界条件和代码规范自我感觉不好,所以有了这些细心的总结。那么...
  • 需要中间插入元素时,数组和链表哪个更好呢? 数组和链表哪个用得更多呢 数组和链表习题 选择排序 python代码实现将数组元素按从小到大的顺序排列 小结 二分法 一般而言,对于包含n元素的...
  • 【C语言代码】链表简单建立

    千次阅读 2014-03-21 16:36:07
    今天网上看到链表的...利用三个指针pHead,pNew,pEnd 来构造的,单向链表和双向链表中,头指针不是有效,它指向的才是有效的,也就是说头指针里面的一般为空,只有指针域里面有指向下一个结构体的地址;
  • 文章目录大纲图双向链表双向链表的基本结构 大纲图 双向链表 Algorithms_基础数据结构(02...链表的应用案例之单向链表中我梳理了 单向链表的基本操作,接下来我们继续来看下双向链表吧。 双向链表的基本结构 ...
  • 链表简单创建——C程序设计

    万次阅读 多人点赞 2011-01-27 10:20:00
    题目:创建固定长度的单向链表 <br /> 程序分析:链表是动态分配存储空间的链式存储结构, 其包括一个“头指针”变量,其中第0个结点称为整个链表的头结点,头结点存放一个地址,该地址指向...
  • C++链表类及链表常用功能实现

    千次阅读 多人点赞 2019-03-03 16:17:05
    使用C++编写链表类,实现以下功能: ...链表的每个节点都是一个独立的单元,每个单元由数据和指向下一节点的指针构成 //定义链表节点 template &amp;amp;lt;class T&amp;amp;gt; class Node {...
  • 提到 LinkedList,我相信大部分 Java 开发者是知道的。...集合其实 Java 是一个很重要的概念,而 LinkedList 也只是集合一个实现类而已。当然 LinkedList 并不是 Java 唯一的集合,但它却...
  • 前言 从前面的HashMap和ConcurrentHashMap的源码分析我们可以得知,其内部的数据结构都用到了链表,所以,对链表的深入掌握非常有必要。...首先我们来看看最简单链表-----单链表。 如上图所示,分别是...
  • 这里写目录标题链表的概念及结构链表的实现实现链表的函数操作一、实现链表的打印函数二、实现得到单链表的长度函数三、查找是否包含关键字key是否单链表当中三、链表头插法三、链表尾插法四、任意位置插入,第...
  • 链表-Java实现链表数据结构

    千次阅读 2020-06-08 19:08:07
    链表(Linked list):是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数 据,而是一个节点里存到下一个节点的指针(Pointer)。 使用链表结构可以克服数组需要预先知道数据大小的缺点,链表...
  • 数据结构一线性表 (顺序表、单链表、双链表)

    万次阅读 多人点赞 2018-07-17 16:38:57
    转载请标明出处: ...本文出自:【openXu的博客】 1、线性表及其逻辑结构   线性表是最简单也是最常用的一种数据...成绩单是一个线性表,表每一行是一个数据元素,每个数据元素又由学号、姓名、成绩等数据项...
  • C语言实现动态链表

    千次阅读 多人点赞 2019-12-21 12:41:56
    链表由一系列结点(链表中一个元素称为结点)组成,结点可以运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。 动态链表的C语言实现 结构体定义已经...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,620
精华内容 28,248
关键字:

在简单链表中查找一个指定值