精华内容
下载资源
问答
  • 数据结构链表

    2013-05-20 17:21:46
    数据结构 链表 C语言 双向链表 自己照着书写的
  • 链表 数据结构 链表

    2011-12-29 18:16:54
    数据结构 链表
  • 数据结构 链表

    万次阅读 多人点赞 2018-03-30 16:03:57
    链表的生成上学期学链表的时候掌握了点皮毛,马马虎虎写了不带头结点的链表,这学期学数据结构觉得写代码要规范点才行,于是写了带头结点的链表链表,顾名思义就是一串像链子的表格串接起来,当你不够用了,再开辟...

    链表的生成

    上学期学链表的时候掌握了点皮毛,马马虎虎写了不带头结点的链表,这学期学数据结构觉得写代码要规范点才行,于是写了带头结点的链表。链表,顾名思义就是一串像链子的表格串接起来,当你不够用了,再开辟块内存接在这个链表的尾部,这时,就可以动态得分配内存大小,既不用担心拿多了内存造成浪费,也不用“处心积虑”地去考虑要存的数据到底需要多少。但是,相对于顺序表,链表的弊端还是有的,没错,就是要查哪个位置的元素内容,链表时间复杂度O(n),顺序表只需要O(1);然而,它的优势也是有的,在增加或者删除节点的时候,顺序表需要O(n),链表则只需要O(1)。各有所长!

    要求:

    实现链表各种基本运算的算法

    1 实验目的

    实现链表的各种基本运算(链表逆序的操作)

     

    实验内容

    实现链表的各种基本运算,在此基础上设计一个主程序完成以下功能:

    (1) 以学号分解后的数字,学号为20161100通过键盘输入20161100生成单链表L

    (2) 依次输出链表L的元素

    (3) 输出链表L的长度

    (4) 输出链表L的第2个元素

    (5) 输出元素6的位置

    (6) 在第4个元素位置上插入9元素

    (7) 依次输出链表L的元素

    (8) 删除L的第3个元素

    (9) 依次输出链表L的元素

    (10) 对链表进行逆序,再依次输出链表L的元素

    (11) 释放链表L


    具体代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    
    //******宏定义参数内容******
    #define DATA_SIZE 200
    #define EXTEND_DATA_SIZE 50
    #define NO 0
    #define OK 1
    #define ERROR -1
    
    //******基本数据类型别名******
    typedef int Status;
    typedef char Excelelem;
    typedef int Numelem;
    
    //******链表数据结构******
    typedef struct Node
    {
    	Excelelem book;
    	struct Node *next;
    }Liststruct;
    
    /******链表表头信息******/
    typedef struct
    {
    	Excelelem book[100]; //表头信息
    	Liststruct *next;
    	Numelem Length;
    }ListHead;
    
    //******初始化链表******
    Liststruct *init(int *i)
    {
    	Liststruct *Head,*p,*q;
    	Excelelem ch;
    	Head=q=NULL;
    	printf("请输入顺序表Head的内容:\n");
    	while((ch=getchar())!='\n')
    	{
    		p=(Liststruct *)malloc(sizeof(Liststruct));
    		p->book=ch;
    		if(!(*i)) Head=q=p,(*i)++;
    		else
    		{
    			q->next=p;
    			q=p;
    			(*i)++;
    		}
    	}//注意*q++与(*q)++,有区别!
    	if(q) q->next=NULL;
    	return Head;
    }
    
    ListHead *Headinit()
    {
    	ListHead *Head;
    	Head=(ListHead *)malloc(sizeof(ListHead));
    	Head->Length=0;
    	Head->next=init(&Head->Length);
    	return Head;
    }
    
    /******打印表中数据内容******/
    void DATA_cout(ListHead *Head)
    {
    	Liststruct *p=Head->next;
    	while(p!=NULL)
    	{
    		printf("%c",p->book);
    		p=p->next;
    	}
    	printf("\n");
    	return ;
    }
     /******打印表中local位置元素内容******/
    void Local(ListHead* Head,int local)
    {
    	if(Head->Length<local || local<1)
    	{
    		printf("警告!不存在%d位置的元素\n",local);
    		return ;
    	}
    	Liststruct *p=Head->next;
    	int i=1;
    	while(p && i++!=local)
    		p=p->next;
    	printf("%c\n",p->book);
    	return ;
    }
    
    /******找到表中出现的字符ch的位置******/
    void DATA_find(ListHead* Head,char ch)
    {
    	int i=1,flag=0,count=1;
    	Liststruct *p=Head->next;
    	while(p)
    	{
    		if(p->book==ch)
    		{
    			flag=1;
    			printf("%d.在第%d个位置出现元素%c\n",count++,i,ch);
    		}
    		p=p->next;
    		i++;
    	}
    	if(!flag)
    		printf("未能找到%c元素!\n",ch);
    	return ;
    }
    
    /******在第k个元素前插入一个元素******/
    void DATA_Insert(ListHead *Head,int k,Excelelem ch)
    {
    	if(Head->Length<k || k<1)
    	{
    		printf("警告!不存在%d位置的元素\n",k);
    		return ;
    	}
    	Liststruct *p=Head->next,*q,*t;
    	int i=1;
    	while(p && i++!=k)
    		t=p,p=p->next;
    	q=(Liststruct *)malloc(sizeof(Liststruct));
    	q->book=ch;
    	if(k==1)
    	{
    		Head->next=q;
    		q->next=p;
    	}
    	else
    	{
    		q->next=p;
    		t->next=q;
    	}
    	Head->Length++;
    	return ;
    }
    
    /******删除第k个元素******/
    void DATA_Delete(ListHead *Head,int k)
    {
    	if(Head->Length<k || k<1)
    	{
    		printf("警告!不存在%d位置的元素\n",k);
    		return ;
    	}
    	int i=1;
    	Liststruct *p=Head->next,*q;
    	while(p && i++!=k)
    		q=p,p=p->next;
    	if(k==1)
    		Head->next=p->next;
    	else
    		q->next=p->next;
    	free(p);
    	Head->Length--;
    	return ;
    }
    
    /******逆置链表******/
    void DATA_UN(ListHead *Head)
    {
    	Liststruct *p,*q;
    	p=Head->next;
    	Head->next=NULL;
    	while(p!=NULL)
    	{
    		q=p;
    		p=p->next;
    		q->next=Head->next;
    		Head->next=q;
    	}
    	return ;
    }
    
    /******返还内存******/
    void List_FREE(ListHead *Head)
    {
    	Liststruct *p=Head->next,*q;
    	free(Head);
    	while(p)
    	{
    		q=p;
    		p=p->next;
    		free(q);
    	}
    	return ;
    }
    
    int main()
    {
    	ListHead *Head;
    	Numelem i;
    	Excelelem ch;
    	puts("");
    	puts("******等待链表Head初始化!******");
    	Head=Headinit();
    	puts("******链表Head初始化完成!******");
    	printf("链表中的内容为:\n");
    	DATA_cout(Head);
    	printf("链表Head的长度为:\n");
    	printf("%d\n",Head->Length);
    	printf("链表第%d个元素是:\n",i=2);
    	Local(Head,i);
    	printf("链表中出现%c元素的位置分别是:\n",ch='6');
    	DATA_find(Head,ch);
    	printf("在链表的第%d个元素之前插上%c\n",i=4,ch='9');
    	DATA_Insert(Head,i,ch);
    	printf("链表中的内容为:\n");
    	DATA_cout(Head);
    	printf("将链表中第%d个元素删除\n",i=3);
    	DATA_Delete(Head,i);
    	printf("链表中的内容为:\n");
    	DATA_cout(Head);
    	printf("将链表所有元素逆置,请稍后...\n\n");  //多种方法
    	DATA_UN(Head);
    	printf("链表中的内容为:\n");
    	DATA_cout(Head);
    	puts("******链表Head使用完毕!******\n");
    	List_FREE(Head);
    	return 0;
    }
    
    

    总结:

    链表写法有挺多种的,关键在于怎么定义那个结构,指向结构体的指针非常重要,有头的节点在使用上非常便捷,同时在进行增删改查也显得容易。

    展开全文
  • 数据结构 链表 线性表的链接实现(链表) 上讲回顾 单链表 结点结构 2单链表的类型定义 3头结点的概念与作用 4单链表的常用算法 5应用实例 6小结 7思考题 数据结构 链表 上讲回顾 上讲主题:线性表的顺序实现(顺序表) ...
  • 主要介绍了JAVA 数据结构链表操作循环链表的相关资料,需要的朋友可以参考下
  • 数据结构 链表 C语言 单向链表
  • java 数据结构 链表

    2009-07-16 20:30:58
    java 数据结构 链表 自己写的 java 数据结构 链表 自己写的 java 数据结构 链表 自己写的
  • 主要介绍了Java 数据结构链表操作的相关资料,并附实例代码,需要的朋友可以参考下
  • 湖南大学数据结构链表实验1.zip
  • c 数据结构 链表源码

    2009-12-27 15:51:24
    c 数据结构 链表源码 c 数据结构 链表源码 c 数据结构 链表源码 c 数据结构 链表源码 c 数据结构 链表源码 c 数据结构 链表源码
  • 主要介绍了C语言数据结构 链表与归并排序实例详解的相关资料,需要的朋友可以参考下
  • 数据结构-链表 链表:是用一组地址任意的存储单元存放线性 表的各个数据元素,通过保存直接后继的存储 位置来表示元素之间的逻辑关系; 结点是链表的基本存储单位,每个结点在链表 中使用一块连续的存储空间,而相邻结点...
  • c++数据结构链表的使用c++数据结构链表的使用c++数据结构链表的使用c++数据结构链表的使用c++数据结构链表的使用c++数据结构链表的使用
  • 多种数据结构链表实例解析(C语言版),多种数据结构链表实例解析(C语言版)很全面
  • 数据结构链表的操作程序 初始化,删除,添加等完成的链表操作。供大家分享
  • 嵌入式常用数据结构-链表、队列、堆栈、可删除key值链表、优先级队列,消息队列
  • 学号1208210146数据结构 学号 1208210146 数据结构课程设计报告 2014-2015 学年 第一学期 数据结构 课程设计报告 题目 专业 链表结构的相关函数库的设计 计算机科学与技术 班级 12 级计科3班 姓名 指导教师 成绩 ...
  • 数据结构链表倒排方法解析及代码,多种方法:创建新链表实现倒排,不创建新链表实现倒排。
  • 数据结构 链表的操作 win32 VS 链表的操作
  • educoder数据结构链表及其应用

    千次阅读 多人点赞 2021-03-27 19:20:12
    educoder数据结构链表及其应用第一题第二题第三题 第一题 void LL_GetAt(LinkList L, int i, ElemType &e) // 在带头结点的单链表L中获取第i个元素的值赋给e,i的取值范围[1,n] { // 请在这里补充代码,完成本...

    educoder数据结构链表及其应用


    仅供学习与交流,不要无意义照抄

    第一题

    void LL_GetAt(LinkList L, int i, ElemType &e)
    // 在带头结点的单链表L中获取第i个元素的值赋给e,i的取值范围[1,n]
    {
    	// 请在这里补充代码,完成本关任务
        /********** Begin *********/
    	LNode* p;
    	p = L ->next;
    	int j = 1;
    	while (i > j && p)
    	{
    		p = p->next;
    		j++;
    	}
    	e = p->data;
    	/********** End **********/
    }
    
    LNode *LL_FindValue(LinkList L, ElemType e,int &i)
    //在带头结点的单链表L中查找第一个值为e的元素,
    //找到则将该元素在链表中的位置赋给i,并返回该结点指针,否则i赋值为0并返回空指针
    {
    	LNode* p = L ->next;
    	i++;
    	while (p && p->data != e)//返回该结点指针
    	{
    		p = p->next;
    		i++;
    	}
    	if (!p)
    	{
    		i = 0;
    		return p;
    	}
    	return p;
    }
    

    第二题

    void LL_InsAt(LinkList L,int i,ElemType e)
    // 在带头结点的单链表L中第i个位置插入值为e的新元素,i的取值范围[1,n+1]
    {
    	LNode* p, *in;
    	p = L;
    	int j = 0;
    	while (p && j<i-1)
    	{
    		p = p->next;
    		j++;
    	}
    	in = (LNode*)malloc(sizeof(LNode));
    	in->data = e;
    	in->next = p->next;
    	p->next = in;
    }
    
    void LL_DelAt(LinkList L,int i)
    // 在带头结点的单链表L中,删除第i个元素,i的取值范围[1,n]
    {
    	int j = 0;
    	LNode* p, *q;
    	p = L;
    	q = p;
    	while (p && j < i)
    	{
    		q = p;
    		p = p->next;
    		j++;
    	}
    	if (p)
    	{
    		q->next = p->next;
    		free(p);//要释放掉空间
    	}
    }
    
    void LL_DelValue(LinkList L, ElemType e)
    // 删除第一个值为e的数据元素
    {
    	LNode* p;
    	p = L->next;
    	int pos = 1;//pos为1即可调用删除第i个元素函数
    	while(p)
    	{
    		if (p->data == e)
    		{
    			LL_DelAt(L, pos);
    			break;
    		}
    		p = p->next;
    		pos++;
    	}
    }
    
    

    第三题

    void MergeList_L(LinkList LA,LinkList LB,LinkList &LC)
    //已知单链表LA和LB的元素按值非递减排列
    //归并LA和LB得到新的单链表LC,LC的元素也按值非递减排列。
    {
    	// 请在这里补充代码,完成本关任务
        /********** Begin *********/
     	LL_Initiate(LC);//初始化LC
    	LNode* p, * q, *m, *in;
    	p = LA->next;
    	q = LB->next;
    	m = LC;
    	in = (LNode*)malloc(sizeof(LNode));
    	while (p && q)//使用尾插法
    	{
    		in = (LNode*)malloc(sizeof(LNode));//建立一个临时节点存数据
    		if (p->data >= q->data)
    		{
    			in->data = q->data;//将LB现在所在节点的数据=>in这个节点
    			in->next = NULL;//指向NULL,不要让这个节点变成野指针,以免造成不必要的麻烦
    			m->next = in;/*m的指针指向这个临时节点,
    			此时可以看成in在m这个链表中*/
    			m = in;//更新位置
    			q = q->next;//q指针更新位置
    		}
    		else {
    			in->data = p->data;
    			in->next = NULL;
    			m->next = in;
    			m = in;
    			p = p->next;
    		}
    	}
    	while (p)
    	{
    		in = (LNode*)malloc(sizeof(LNode));
    		in->data = p->data;
    		in->next = NULL;
    		m->next = in;
    		m = in;
    		p = p->next;
    	}
    	while (q)
    	{
    		in = (LNode*)malloc(sizeof(LNode));
    		in->data = q->data;
    		in->next = NULL;
    		m->next = in;
    		m = in;
    		q = q->next;
    	}
    
    	/********** End **********/
    
    展开全文
  • C语言数据结构 链表的基本操作 链表的五个基本操作全部包含
  • 数据结构链表实验

    2012-10-16 17:09:26
    数据结构实验要求编写的链表实验,可以对链表进行创建 删除 清空 返回链表中元素的个数,插入元素 删除元素, 对链表保存
  • 实验报告 系部 计算机系 班级 学号 姓名 课程名称 数据结构 实验日期 2019-9-19 实验名称 链表 成绩 实验目的 1掌握单链表的存储结构的表示和实现方法 2掌握双向链表基本操作的算法实现 3掌握循环链表的实现 4 链表...
  • c语言版数据结构的实验,链表的主要操作,生成链表,清空链表,插入数据,删除数据,元素定位等功能
  • C++ 数据结构 链表

    2010-09-11 13:16:20
    主要写了三种链表(单链表 循环链表 双向链表)及其基本操作(操作已封装成类) 详细请看“心希盼 链表.doc ”
  • C#数据结构链表

    2014-10-24 21:38:39
    链表是一种物理存储单元上非连续、非顺序的存储结构数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运...
  • 数据结构链表合并

    2013-05-21 19:55:06
    用C++写的一个实现链表A与链表B的合并,并输出合并后的链表C。简单易懂,可做模板。
  • 数据结构课设,链表排序,升序,逆序,倒置
  • 可以更直观的展现数据结构原理,链表的动态演示,让我们更有效地学习链表数据结构中是如何插入删除等工作的。
  • C++ 数据结构链表的实现代码

    万次阅读 2017-01-18 12:31:12
    C++ 链表之前一直没怎么在意C++中的链表,但是突然一下...没办法,决定好好恶补一下该方面的知识,也为今后的数据结构大下个良好的基础,于是我总结出以下几点,有些地方可能不正确,还望大家不吝赐教,旨在共同进步。

    C++ 链表

    之前一直没怎么在意C++中的链表,但是突然一下子让自己写,就老是出错。没办法,决定好好恶补一下该方面的知识,也为今后的数据结构打下个良好的基础,于是我总结出以下几点,有些地方可能不正确,还望大家不吝赐教,旨在共同进步。

    总结:

    1、链表List的基本单元是节点Node,因此想要操作方便,就必须为每一步打好基础,Node的基本结构如下:

    class Node {
    public:
        int data;
        Node *next;
    
        Node(int da = 0, Node *p = NULL) {
            this->data = da;
            this->next = p;
        }
    };

    我们可以看出,Node的成员变量一共有两个,都是public,因为我们要对这两个变量进行操作,所以不能是private类型的。然后是一个构造函数,第二个参数默认值为NULL,也就是说如果我们创建新节点时只指定第一个参数,而不写第二个参数,那么它默认的就是NULL,以这种方式可以更灵活的使用Node,个人建议这么使用哦。

    2、第二步就是创建我们的链表了,同样我们这里先给出链表的代码,再进行一一的解释。

    class List{
    private:
      Node *head,*tail;
      int position;
    public:
      List(){head=tail=NULL;};
      ~List(){delete head;delete tail;};
      void print();
      void Insert(int da=0);
      void Delete(int da=0);
      void Search(int da=0);
    };

    我们这里面有两个数据类型,一个是Node。另一个是指代节点位置的成员变量(起不到什么作用,且不去管它吧)。使用head和tail来命名便是为了见名知意,使操作更加准确。然后是重要的六个函数,各自的功能不言而喻咯,其实最重要的是在每一个函数中我们都默认能操作head和tail两个成员变量,这样能简化我们的参数列表,使得函数更加优雅。
    下面是我的一个单链表的实现,包含创建链表,插入值,删除特定的值,查找特定值得在链表中的位置。

    #include <iostream>
    
    using namespace std;
    
    class Node {
    public:
        int data;
        Node *next;
    
        Node(int da = 0, Node *p = NULL) {
            this->data = da;
            this->next = p;
        }
    };
    
    class List {
    private:
        Node *head, *tail;
        int position;
    public:
        List() { head = tail = NULL; };
    
        ~List() {
            delete head;
            delete tail;
        };
    
        void print();
    
        void Insert(int da = 0);
    
        void Delete(int da = 0);
    
        void Search(int da = 0);
    
        int getValueAt(int position);
    
        void setValueAt(int position, int da);
    };
    
    int List::getValueAt(int position) {
        Node *p = head;
        if (p == NULL) {
            cout << "The List is Empty!" << endl;
        } else {
            int posi = 0;
            while (p != NULL && posi != position) {
                posi++;
                p = p->next;
            }
            if (p == NULL) {
                cout << "There is no value of this position in this List!" << endl;
            } else {
                cout << "In this Position,the value is" << p->data << endl;
            }
        }
        return p->data;
    }
    
    void List::setValueAt(int position, int da) {
        Node *p = head;
        if (p == NULL) {
            cout << "The List is Empty!" << endl;
        } else {
            int posi = 0;
            while (p != NULL && posi != position) {
                posi++;
                p = p->next;
            }
            if (p == NULL) {
                cout << "There is No Position in this List!" << endl;
            } else {
                p->data = da;
                cout << "The Value in this position has been Updated!" << endl;
            }
        }
    }
    
    void List::Search(int da) {
    
        Node *p = head;
        if (p == NULL) {
            cout << "Sorry, The List is Empty!" << endl;
            return;
        }
        int count = 0;
        while (p != NULL && p->data != da) {
            p = p->next;
            count++;
        }
        cout << "the value you want to search is at position %d" << count << endl;
    }
    
    void List::Delete(int da) {
        Node *p = head, *q = head;
        if (p == NULL) {
            cout << "Sorry, The List is Empty!" << endl;
            return;
        }
        while (p != NULL && p->data != da) {
            q = p;
            p = p->next;
        }
        q->next = p->next;
        cout << "The Deletion Operation had been finished!" << endl;
    }
    
    void List::Insert(int da) {
        if (head == NULL) {
            head = tail = new Node(da);
            head->next = NULL;
            tail->next = NULL;
        } else {
            Node *p = new Node(da);
            tail->next = p;
            tail = p;
            tail->next = NULL;
        }
    
    }
    
    void List::print() {
        Node *p = head;
        while (p != NULL) {
            cout << p->data << " \a";
            p = p->next;
        }
        cout << endl;
    }
    
    int main() {
        cout << "Hello World!" << endl;
        List l1;
        l1.Insert(1);
        l1.Insert(2);
        l1.Insert(3);
        l1.Insert(4);
        l1.Insert(5);
        l1.Insert(6);
        l1.Insert(7);
        l1.print();
        l1.Search(4);
        l1.Delete(6);
        l1.print();
        l1.getValueAt(3);
        l1.setValueAt(3, 9);
        l1.print();
        cout << "The End!" << endl;
        return 0;
    }

    运行结果:

    这里写图片描述

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 504,077
精华内容 201,630
关键字:

数据结构链表

数据结构 订阅