精华内容
下载资源
问答
  • 创建单链表的两种方法

    千次阅读 多人点赞 2017-12-17 10:10:41
    *创建单链表的方法* 头插法创建单链表 个人感觉尾插法更容易理解= =头插法看了好久才看懂(mock上的课不错,这里的代码就来自上面的老师的课件,大部分注释是我自己的理解)#include using namespace std; struct...

    *创建单链表的方法*
    头插法创建单链表
    个人感觉尾插法更容易理解= =头插法看了好久才看懂(mock上的课不错,这里的代码就来自上面的老师的课件,大部分注释是我自己的理解)

    #include <iostream>
    using namespace std;
    struct LNode{
        int data;//数据域
        LNode*next;//指针域
    };//定义一个结点类型的结构体
    typedef LNode* LinkList;//用typedef来给LNode的指针类型定义一个新的名字LinkList
    void input(int *ep)//形参是和数据域类型相同的指针,用来指向结点的数据域
    {cout<<"请输入要储存的整数:";
        cin>>*ep;}
    void CreateListF(LinkList *L,int n,void(*input)(int *ep))//第一个形参是头结点的指针的指针,n是需要创建的结点的个数,函数的指针(这个我还不是很清楚)
    { LinkList s;//创建一个指向结点的指针
        *L=new LNode;//创建头结点
        (*L)->next=NULL;//让头结点中的指针域初始为空值
        for(;n>0;n--)//创建结点
        { s=new LNode; //创建一个新结点
            input(&s->data);//输入该结点数据域所要储存的数据
            s->next=(*L)->next;//(第一次循环)将空值给开始结点的指针域;(第二次循环)让第二个结点的数据域中储存开始结点的地址,也就是现在头节点的next和第二个结点的next都储存着开始结点的地址(都指向开始结点);
            (*L)->next=s;//(第一次循环)让头结点的的指针域中存储开始结点的地址;(第二次循环)让头结点的next中储存第二个结点的地址;
        }
    
    }
    
    int main()
    { LinkList L;
        int n;
        cout<<"请输入要创建结点的个数:";
        cin>>n;
        CreateListF(&L,n,input);
        return 0;
    
    
    
    
    
    }

    尾插法创建单链表
    这个比较容易理解qwq

    #include <iostream>
    using namespace std;
    struct LNode{
        int data;
        LNode* next;
    };
    typedef LNode* LinkList;
    void input(int *ep)
    {cout<<"请输入链表中的内容:";
        cin>>*ep;
    }
    void CreateListR(LinkList *L,int n,void(*input)(int*))
    { LinkList p,s;//创建两个结点型的指针;其中s用来创建结点,p用来实现循环
        p=*L=new LNode;//让p和*L都指向头结点
        for(;n>0;n--)//创建n个结点
        {s=new LNode;//创建一个新的结点
            input(&s->data);//输入数据
            p->next=s;//(第一次循环)让头结点的next指向开始结点;(第二次循环)让开始结点的next指向第二个结点,也就是新建立的结点
            p=s;//(第一次循环)让p和s一样指向开始结点;(第二次循环)让p和s一样指向新建立的结点,实现循环;
        }
        p->next=NULL;//最后尾结点的指针域要为0;
    }
    int main()
    {LinkList L;
        int n;
        cout<<"请输入要创建的结点的个数:";
        cin>>n;
        CreateListR(&L,n,input);
        return 0;
    }
    
    展开全文
  • 接下来的教程可能会非常难以理解,因此我用了差不多整整一天时间来理解别人写的C语言循环创建单链表的原理。所以如果你一时读不懂,不要担心,你可以在纸上演算,慢慢体会,这需要一个过程。 然后此篇文章与其他...

    如果你掌握以下知识,可能会对理解此片文章有所帮助:

    1.C语言的基本语法,及指针的简单使用

    2.完全理解教程二的原理

    写在前面的话:

    接下来的教程可能会非常难以理解,因此我用了差不多整整一天时间来理解别人写的C语言循环创建单链表的原理。所以如果你一时读不懂,不要担心,你可以在纸上演算,慢慢体会,这需要一个过程。

    然后此篇文章与其他单链表文章不同的是,省略了单链表的操作,专注于循环创建链表的工作。对于链表的基本操作,可能会在下篇文章叙述。

    C语言语法不太熟练也没关系,我上一次用C是在一年前,也是写数据结构。语法都快忘光了,用到再查。

    在上一个教程你已经学会了如何手动写代码使节点相连,但这种重复的工作何不交给计算机完成呢?

    //分割线//

    1.和之前一样,我们先声明一个节点单元,把main函数写上

    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct node_s{
    	int data;
    	struct node_s *next;
    }node;
    
    int main()
    {
    	
    	
    } 
    
    

    2.创建一个头节点,有了这个头节点,就可以“抓”住整个链表,以至于顺藤摸瓜控制整个单链表

    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct node_s{
    	int data;
    	struct node_s *next;
    }node;
    
    int main()
    {
    	node* head;	//在语法上,这语句代表声明一个指向node结构体类型的指针head。在编程目的上,我们创造了一个head节点 
    	
    	head = (node*)malloc(sizeof(node));		//为head(头节点)节点分配内存地址 
    	
    } 
    

    3.再创建一个节点,把它与头节点相连

    	node *s_node; 						//创建一个节点 
    		
    	s_node = (node*)malloc(sizeof(node));		//为节点分配地址 
    	
    	head->next = s_node;			//先将头节点和第一个节点相连 
    

    4.声明一个辅助指针f ,使它指向s_node

    int main()
    {
    	node* head;	//在语法上,这语句代表声明一个指向node结构体类型的指针head。在编程目的上,我们创造了一个head节点 
    	
    	head = (node*)malloc(sizeof(node));		//为head(头节点)节点分配内存地址
    	
    	node *s_node; 						//创建一个节点 
    		
    	s_node = (node*)malloc(sizeof(node));		//为节点分配地址 
    	
    	head->next = s_node;			//先将头节点和第一个节点相连 
    	
    	node *f;		//声明一个辅助指针,接下来,它指向的地方可能随时发生变化 
    	
    	f = s_node;		//让它指向刚刚创建的s_node节点,保存着s_node地址,如果不这样做,在接下来的第二条语句,s_node将会被刷新
    

    5.创建循环

    int main()
    {
    	node* head;	
    	
    	head = (node*)malloc(sizeof(node));		
    	
    	node *s_node; 					
    		
    	s_node = (node*)malloc(sizeof(node));		
    	
    	head->next = s_node;			
    	
    	node *f;		
    	
    	f = s_node;		
    	
    	for(int i=0 ; i<(length-1) ; i++)	//0,1,2,3,4,5,6,7,8,9,循环创建length-1个子节点,length-1是因为已经有head节点了,没必要再创造10个节点。 
    	{									//这里创造9个,加head一个,那就是10个了。 
    		s_node = (node*)malloc(sizeof(node));		//分配内存单元,此时s_node指向的内存单元一直被刷新。 
    		
    		s_node->next = NULL; 	//初始化next的值而已,不然它会被填入奇奇怪怪的值。不用担心,NULL会被刷新,不会一直是NULL值。
    								//写这条语句也是无奈之举,后面遍历链表时: 
    								//		在while,next有值时,一直执行,为NULL值时,遍历结束。最后一个节点的NULL不会被刷新,所以到最后一个节点NULL判定生效
    								//在其他教程里,先创建头、尾节点,在头节点后面插入节点,比如这样:
    								//		{头节点}->{一直在此插入节点}->{node2}->{node3}->{node4}->{尾节点}
    								//		这样可以直接把尾节点的next赋值为NULL。一些教程把这样的创建方法叫做头插法。
    								//既然讲了头插法,那就讲一下尾插法:
    								// 		{头节点}->{node2}->{node3}->{node4}->{一直在此插入节点}->{尾节点}
    								//本教程不属于头插法,也不属于尾插法,属于“指针指示法”,这是我自己想的名字,不用太过纠结,它是这样插入的:
    								// 		{头节点}->{node2}->{node3}->{node4}->{一直在此插入节点}
    								//大部分教程都使用头插法和尾插法。目前提到的方式,效率、结果都一样,不必纠结。 
    								//无论头插还是尾插,它们都要创建尾节点,它们使用尾节点的next作为临时存储新生成节点的容器。。。
    								//如果你对上面这大段注释有疑惑,那就先忘掉它吧!
    		f->next = s_node; 
    		
    		f = s_node;
    		
    	}
    	
    	至此,单链表已经创建完成,下面是赋值然后测试结果/ 
    

    6.增加赋值与测试

    int main()
    {
    	node* head;	//在语法上,这语句代表声明一个指向node结构体类型的指针head。在编程目的上,我们创造了一个head节点 
    	
    	head = (node*)malloc(sizeof(node));		//为head(头节点)节点分配内存地址
    	
    	node *s_node; 						//创建一个节点 
    		
    	s_node = (node*)malloc(sizeof(node));		//为节点分配地址 
    	
    	head->next = s_node;			//先将头节点和第一个节点相连 
    	
    	node *f;		//声明一个辅助指针,接下来,它指向的地方可能随时发生变化 
    	
    	f = s_node;		//让它指向刚刚创建的s_node节点,保存着s_node地址,如果不这样做,在接下来的第二条语句,s_node将会被刷新 
    	
    	for(int i=0 ; i<(length-1) ; i++)	//0,1,2,3,4,5,6,7,8,9,循环创建length-1个子节点,length-1是因为已经有head节点了,没必要再创造10个节点。 
    	{									//这里创造9个,加head一个,那就是10个了。 
    		s_node = (node*)malloc(sizeof(node));		//分配内存单元,此时s_node指向的内存单元一直被刷新。 
    		
    		s_node->next = NULL; 
    		
    		f->next = s_node; 
    		
    		f = s_node;
    		
    	}
    	
    	至此,单链表已经创建完成,下面是赋值然后测试结果/ 
    	
    	int j = 0;		//计数器 
    	
    	f = head;
    	
    	while(f->next != NULL)		//遍历赋值 
    	{
    		f->data = j;
    		
    		j++;
    		
    		f = f->next;
    	}
    	
    	f = head;
    	
    	while(f->next != NULL)		//遍历输出值 
    	{
    		printf("--%d--",f->data);
    		
    		f = f->next;
    	}
    } 
    

    7.打印输出结果:

    在这里插入图片描述

    单链表教程应该就到这里了,因为再写的话可以写单链表的操作,但又不是很有必要。因为单链表可以实现链栈,直接去了解链栈的操作就可以,比较节约学习时间。

    超详细!创建链栈及其基本操作(C语言)

    如果觉得教程对你有所帮助,可以点赞支持φ(゜▽゜*)♪,非常感谢!

    展开全文
  • 创建单链表有两种方式:头插法与尾插法 尾插法是在链表的结尾增加新的节点 头插法是插入头节点后面,剩余节点前面 2 尾插法 步骤 需要新建一个尾节点tail,(初始head=tail) 创建新的节点new,连接到尾节点,...

    1 简述

    创建单链表有两种方式:头插法与尾插法

    尾插法是在链表的结尾增加新的节点

    头插法是插入头节点后面,剩余节点前面

    2 尾插法

    步骤

    1. 需要新建一个尾节点tail,(初始head=tail)
    2. 创建新的节点new,连接到尾节点,tail.next = new
    3. 尾节点后移,tail = new

    Q:为什么要加新的节点?

    A:因为head的节点不能动,增加新的节点让其移动,让其指向最后一个节点,便于连接tail.next=new

    返回创建好的列表一般返回head,如果让head后移,那最后返回head的结果只有最后一个节点

    3 头插法

    步骤

    1. new.next = head.next
    2. head.next=new

    这种做法实际上实现了逆序

    假如节点为: 1 2 3

    创建过程:

    • head -> 1
    • head ->2 ->1
    • head ->3 ->2 ->1

    返回头节点的结果是3 ->2 ->1,原来是 1 2 3,实现了逆序

    参考https://blog.csdn.net/joob000/article/details/81196165

    展开全文
  • 步骤 1、尾部插入法创建链表 2、自定义上一个节点、当前节点、下一个节点,遍历反转链表,主要是把当前节点的下一个节点设置为当前节点的上一个节点; public class ReverseLinkd { private static Node head; ...
    步骤
    • 1、尾部插入法创建链表
    • 2、自定义上一个节点、当前节点、下一个节点,遍历反转链表,主要是把当前节点的下一个节点设置为当前节点的上一个节点;
    public class ReverseLinkd {
    
        private static Node head;
        private static Node tail;
    
        public static void main(String[] args) {
            String[] dataArray = {"1", "2", "3", "4", "5", "6", "7"};
            for(int i = 0; i< dataArray.length; i++) {
                createLinked(dataArray[i]);
            }
            System.out.println("---------------原链表---------------");
            printAll(head);
    
            System.out.println("---------------反转后链表---------------");
            printAll(reverse(head));
    
        }
        //链表反转方法
        public static Node reverse(Node node) {
            if(node == null) {
                System.out.println("空链表");
                return null;
            } else if(node.next == null) {
                System.out.println("链表只有一个节点");
                return node;
            } else {
                Node pre = null;
                Node next = null;
                Node cur = node;
                while(cur != null) {
                    //记录下一个要操作的节点
                    next = cur.next;
                    //当前节点的下一个节点为当前节点的上一个节点,实现反转
                    cur.next = pre;
                    //上一个节点和当前节点全部后移
                    pre = cur;
                    cur = next;
                }
                return pre;
            }
        }
    
        //创建一个单链表,尾部插入法
        public static void createLinked(String nodeData) {
            Node node = new Node(nodeData);
            if(head == null) {
                head = node;
                tail = head;
            } else {
                tail.next = node;
                tail = node;
            }
        }
    
        //打印链表
        public static void printAll(Node node) {
            if(node == null) {
                System.out.println("空链表");
            } else {
                while(node != null) {
                    System.out.print(node.getData() + "-->");
                    node = node.next;
                }
            }
            System.out.println();
        }
    
    
        //定义单链表
        static class Node{
            public String data;
            public Node next;
    
            public Node(String data) {
                this.data = data;
            }
    
            public String getData() {
                return data;
            }
    
            public void setData(String data) {
                this.data = data;
            }
    
            public Node getNext() {
                return next;
            }
    
            public void setNext(Node next) {
                this.next = next;
            }
        }
    }
    
    展开全文
  • 头插法创建单链表

    千次阅读 2018-04-17 16:59:23
    1.对单链表的解释 链表与顺序表不同,它是一种动态管理的存储结构,链表中的每个结点占用的存储空间不是预先分配的,而是运行时系统根据需求生成的,因此建立单列表要从空表开始,每读入一个数据元素则申请一个...
  • 一、前插法创建单链表 算法步骤: (1)创建一个只有头结点的空链表。 (2)根据创建链表包括的元素n,循环n次以下操作: 生成新结点;——>输入元素值赋给新结点数据域;——>将新结点插入到头结点之后...
  • 单链表的原理就不细述了,不懂的可以看一下其他文章或者教学视频。这里简单回顾一下原理: ...用c语言创建动态单链表的核心要点: 1.怎么构造单链表的基本单元? 用结构体定义一个单链表的单元,结构体里可以“储...
  • 单链表创建及操作

    2020-03-15 17:17:57
    1、创建一个带头结点的单链表(头指针为head),且遍历此链表(输出链表中各结点的值); 2、查找单链表中的第i个结点,并输出结点元素的值; 3、在单链表中的第i个结点前插入一个结点值为e的正整数(从外部输入); 4...
  • 单链表创建以及操作 ...创建链表的步骤: 1.先创建出结构体变量 struct Node { int data; //数据域 struct Node* next; //指针域 }; 2.创建表头 struct Node* creatList() { //定义一个指针变量通过动态内存申请
  • 单链表

    千次阅读 多人点赞 2019-08-05 15:50:59
    带头结点和不带头结点的单链表 带头结点的单链表,头指针head指向头结点,头结点的值域不包含任何信息,从头结点之后的结点开始存储信息。 头指针head不等于NULL,head->next等于NULL时,链表为空。 ...
  • 单链表逆序

    2016-03-04 17:59:53
    单链表逆序 步骤: 1. 初始化单链表 2. 动态创建单链表(插入操作) 3. 逆序算法处理 4. 打印输出 5. 释放动态创建的单链表
  • 单链表创建方法 单链表是数据结构中比较基础的结构了。对单链表的的创建方法,比较容易想到的是头插法。但是当要求输入顺序与链表连接的顺序一致时,那么头插法就不是很友好了。因此了解单链表的尾插法也是很重要...
  • /*创建单链表*/ print(head);/*打印单链表*/ } /******************************************/ struct node*creat(struct node *head)/*返回的是与节点相同类型的指针*/ { struct node*p1,*p2; int i=1; //③利用...
  • 单链表-创建

    2020-05-30 15:33:07
    单链表创建 参考这位大神的文章 #include<stdio.h> #include<stdlib.h> typedef struct LNode{ struct LNode *next; int data; }LNode; LNode *HeadCreateList(int len) { LNode *L = (LNode*)...
  • 单链表创建

    2021-10-22 14:49:24
    单项链表的创建一、使用步骤1.单链表 一、使用步骤 1.单链表 代码如下(示例): package testlist; import java.security.PublicKey; import java.util.LinkedList; /** * 单链表实现 */ public class ...
  • 1.声明一结点和计数变量n。 2.初始化一个空链表。 3.声明一个带头节点的链表(即让Ld头节点的指针指向NULL) 4.循环: *生成一个新节点赋值给p。 *随机生成一个数字赋值给P的数据域。 *不断将p插入到头节点与新一...
  • 读取文件创建单链表.c

    千次阅读 2017-01-05 23:00:41
    # include # include FILE *fp ; typedef struct student {  int id ;  int age ;   int score ;  char name[20];  struct student *next ;.../*编译时可用 gcc -DDEBUG -o *** ***.c 查看详细步骤*/
  • 创建及输出动态单链表1.尾插法无头单链表❤2.尾插法有头单链表3.头插法无头单链表4.头插法有头单链表 一、链表是什么? 官方解释: 链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。...
  • 关于单链表创建

    2019-10-02 20:33:07
    //创建单链表 void CreatList(int len) { ElemType a; //a表示输入的值 //构建第一个结点的结点 node *head = new node; node *p = head; //p表示当前链表的最后一个结点 cout 请输入第一个值" ; cin >> a; p...
  • 尾插法建立单链表

    2021-09-20 09:53:13
    关键步骤: 1先在内存中把新结点找出来,然后给新结点的数据域赋值,然后它的指针域为空 再把新结点接在尾结点的后头,也就是要给尾结点的指针域赋值r->next=p; 然后新插入的结点就是新的尾结点了,所以...
  • 数据结构C语言第二版:单链表的建立:尾插法,前插法,任意位置插入法 文章目录单链表的建立方式一、尾插法二、前插法1.引入库总结 单链表的建立方式 提示:这里可以添加本文要记录的大概内容: 例如:随着人工...
  • 数据结构c语言循环单链表单链表的基础上增加了循环,和单链表几乎是一样的,只是对链表头结点的定义和对链表结尾的判断,从NULL变成了指向头结点L。别的定义和单链表一样。 代码如下: #include <stdio.h> ...
  • 单链表的初始化、取值、查找、插入、删除、遍历、前插法(头插法)创建、后插法(尾插法)创建、就地逆置】实验报告+完整代码
  • 2->1的步骤和0->1的原理一样。另外考虑到本链表有头指针,因此指针反转前要判断cur是否是head。如是,则nxt->next=NULL。 当遍历到链表尾时nxt为NULL,则退出循环,将head指向cur。至此完成单链表反转。 ...
  • 单链表整表创建的两种方法(头插法和尾插法)

    万次阅读 多人点赞 2018-05-06 15:53:34
    线性表可分为顺序存储结构和链式存储结构 顺序存储结构的创建,其实就是一个数组的初始化,即声明一个类型和大小的数组并赋值的过程。...所以,创建单链表的过程就是一个动态生成链表的过程。即从“空表”的...
  • 单链表基本操作(1)

    千次阅读 2016-12-08 16:39:41
    单链表基本操作创建 创建 头插入加载 尾插入加载 创建空链表创建一个单链表,且为空表,并且返回链表 创建结构类型,在CS.c文件中 typedef struct node{ int data; struct node *next; }LINKLIST; 在Link.h写出方法...
  • 数据结构-单链表基本操作-C语言代码

    万次阅读 多人点赞 2020-01-22 19:51:58
    单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码,具体思路讲解请看这篇博客:数据结构-线性结构-单链表 1.头插法建立单链表 #include<...
  • 数据结构 建立单链表存储数据序列作业

    千次阅读 多人点赞 2020-05-27 13:37:54
    (1)头插法或尾插法建立单链表,并输出单链表中所有元素; (2)输出单链表中的最大值和最小值; (3)键盘输入一个值x,输出链表中第一个值为x的元素的位序; (4)键盘输入一位序值b,在第b个元素之前插入值为500...
  • 单链表的建立及操作

    2020-03-10 20:36:49
    单链表的建立及操作 一、逆序建表 1.单链表的建立 单链表的实质是一个结点的序列,建立单链表实质上就是逐个生成每一个结点,并把结点插入链表的过程。 单链表的建立是一个结点插入的过程,只不过需要插入的不是一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,804
精华内容 3,521
关键字:

创建单链表的步骤