精华内容
下载资源
问答
  • 链表尾插法

    2018-11-18 19:18:57
    尾插法的简单例子,
  • 双向链表尾插法

    千次阅读 2019-03-29 00:39:42
    /* 初始化链表,尾插法 */ pNode *insert(pNode *head/* or *&head */, int n){//*&head:指针的引用,此时**head本身不能改变,指向头节点;改变的是指向的指针*head. pNode *p, *s;//p:游标 s:新申请节点 head = new ...

    参考

    #include <iostream>
    using namespace std;
    typedef struct Node pNode;
    struct Node{
        int data;
        pNode *prev,*next;
        Node(const int& d):data(d),prev(NULL),next(NULL){}
      };
    
    /* 初始化链表,尾插法 */
    pNode *insert(pNode *head/* or *&head */, int n){//*&head:指针的引用,此时**head本身不能改变,指向头节点;改变的是指向的指针*head.
      pNode *p, *s;//p:游标 s:新申请节点
      head = new Node(0);
      head->next = NULL;//head的prev和next均指向NULL
      head->prev = NULL;
      p = head;//p指向head
      for(int i = 0; i < n; i++){
        s = new Node(i);
        p->next = s;//游标p->next指向新申请节点
        s->prev = p;//s前驱指针指向p
        p = s;//游标p向后移动,p=s,p->next=s->next;
      }
      s->next = NULL;
      return head;
    }
    
    void print(pNode *head){
      while(head->next){
        //cout <<"head->next: "<< head->next<<endl;
        head = head->next;
        cout << head->data << " ";
      }
      cout << endl;
    }
    
    int main(){
      pNode *head, *new_head;
      new_head = insert(head, 5);//初始化链表并赋值,返回尾节点last
      print(new_head);
      return 0;
    }
    

     

    展开全文
  • C语言实现链表尾插法

    2021-03-31 10:04:09
    01 构建链表 02 初始化链表 03 输出链表 */ typedef struct stu{ int num; float score; struct stu *next; }STU,*PSTU; PSTU create(){ PSTU head, p1, p2; p2 = p1 = (PSTU)malloc(sizeof(STU)); //...
    #include<stdio.h>
    #include<stdlib.h>
    /*
    01 构建链表
    02 初始化链表  
    03 输出链表 
    
    */
    
    typedef struct stu{
    	int num;
    	float score;
    	 struct stu *next;
    }STU,*PSTU;
    
    PSTU create(){
    	PSTU head, p1, p2;
    	p2 = p1 = (PSTU)malloc(sizeof(STU));
        //head = NULL;
    
    	printf("请输入节点编号:\n");
    	scanf("%d",&p1->num) ;
    	int n=0;
    	while (p1->num != 0){
    		    n++;
    			printf("请输入节点num为%d的分数:\n",p1->num);
    	        scanf("%f",&p1->score) ;
    	        
    	        if(n==1)
    	        	head = p1;
    	        else {
    	
    	           p2->next = p1; //指向尾节点 
    	          
    			   	}
    			p2 = p1; //保持 p2一直是尾节点, p1是新加入节点 
    	        p1 = (PSTU)malloc(sizeof(STU));
    	        printf("请输入节点编号:\n");
    	        scanf("%d",&p1->num) ;
    	        
    	}
    	p2->next = NULL;
    	return head;
    }
    
    void print(PSTU p){
    	PSTU pstu;
    	pstu = p;
    	do{
    	printf("stu number: %d , score:%f\n",pstu->num, pstu->score);
               pstu =	pstu->next; //head->next = head
    }while(pstu != NULL);
    
    
    }
    
    int main(){
    
    PSTU pstu;
    
    pstu = create();
    print(pstu);
    
    return 0;
    } 

    展开全文
  • java 双向链表 尾插法

    2018-07-25 15:54:12
    双向链表:  import java.util.Random; public class DoubleLink { static DoubleLink link=creat(10); int date; DoubleLink prev,next; public static DoubleLink creat(int len){ Random...

    双向链表: 

    import java.util.Random;
    
    public class DoubleLink {
        static DoubleLink link=creat(10);
        int date;
        DoubleLink prev,next;
        public static DoubleLink creat(int len){
            Random r=new Random();
            DoubleLink header,newnode,tailer;
            header=tailer=null;
            for (int i = 0; i < len; i++) {
                int temp=r.nextInt(100);
                newnode=new DoubleLink();
                newnode.date=temp;
    //第一次赋值
                if(header==null){
    //头插法
                    header=tailer=newnode;
                }else {
    //尾(头)的下一位赋值 *
                    tailer.next=newnode;
    //下一位向前赋值 *
                    newnode.prev=tailer;
    //尾向后移动 *
                    tailer=newnode;
                }
            }
            return header;
        }
        public static DoubleLink search(String d){
            if(d.equals("up")){
                link=link.prev;
            }
            if (d.equals("down")){
                link=link.next;
            }
            return link;
        }
    }
    class test2{
        public static void main(String[] args) {
            DoubleLink l1=DoubleLink.search("down");
            DoubleLink l2=DoubleLink.search("down");
            DoubleLink l3=DoubleLink.search("up");
            System.out.println(l1.date+" "+l2.date+" "+l3.date);
        }
    }

     运行结果:

    46 3 46
    
    Process finished with exit code 0
    

     

    展开全文
  • 单向链表尾插法和头插法分别实现队列和栈

    千次阅读 多人点赞 2021-01-16 15:37:15
    1. 链表是什么?   链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每...

    1. 链表是什么?

      链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。

      画一张易于理解的简图如下,矩形代表存放的是数据,椭圆代表存放的是指针,链表的头必须是一个指针。

      使用链表结构可以克服数组需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序,数据的存取往往要在不同的排列顺序中转换。链表允许插入和移除表上任意位置上的节点,但是不允许随机存取。

      上面的图说明了链表的原理,下面是链表的存储方式,链表在内存中是非连续、非顺序的,就是说链表结点在内存中的存放并不是一个接一个,按顺序存放的。
    在这里插入图片描述
      这里我们可以发现,如果想要访问链表中某一结点的话,必须从head开始查找,并不像数组那样方便。

    2. 队列和栈

       队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表;
      栈是限定只能在表的一端进行插入和删除操作的线性表。
      简而言之队列就是数据先进先出(first in first out,FIFO);而栈则是先进后出(first in last out,FILO)

    3. 头插法和尾插法

      头插法和尾插法顾名思义,就是在链表加入新结点的时候是在头部插入还是在尾部插入。
      简易的示意图如下。黑色箭头是插入新结点之前的链表顺序,红线是插入新结点后的链表顺序。
    在这里插入图片描述
      可以看到尾插法不改变链表的原本顺序,在遍历链表的时候,正好就对应了队列的先进先出的特性;头插法会改变链表原本的顺序,在遍历链表的时候也是正好对应了栈的先进后出的特性。
      所以我们就用头插法的链表来实现栈;尾插法的链表来实现队列。理论存在,实践开始!

    4.实践创建栈和队列(各部分代码)

      4.1 定义一个链表的结构体

    		typedef struct node_s			//定义链表的结构
    		{
    				int				data; 	//数据域
    				struct node_s	*next	//指针域
    		}node_t;
    

      4.2 在main函数中定义链表的一系类指针

    		node_t  	*head = NULL;	//初始化头指针为空指针
    		node_t		*new_node;		//创建一个新结点的指针
    		node_t		*tail;			//创建一个链表的尾指针
    		node_t		*front;			//创建一个链表的头指针
    		
    		int 	count;			//计数器
    

      4.3 for循环实现尾插法建立链表

    		for(count = 0; count < 10; count++)			//用一个for循环来循环创建新的结点。
    		{
    			new_node = malloc(sizeof(node_t));//malloc申请一块内存给新结点并存在指针中
    			memset(new_node, 0, sizeof(*new_node));//清理新结点内存
    			new_node->next = NULL;	//新结点的指针域设为空
    			new_node->data = i+1;	//新结点的数据域放入数值
    			/*到这里新结点的建立就完成了,下面是尾插法的逻辑实现*/
    			
    			if( head == NULL)
    			{
    					head = new_node;//若头指针为空,则是第一个结点,直接用头指针指向
    			}
    			else
    			{
    				tail->next = new_node;//否则尾结点的指针域指向新结点
    			}
    			tail = new_node;	//尾指针指向新插入的结点
    		}
    

      4.4 for循环实现头插法建立链表

    		for(i = 0; i < 10; i++)			//用一个for循环来循环创建新的结点。
    		{
    			new_node = malloc(sizeof(node_t));//malloc申请一块内存给新结点并存在指针中
    			memset(new_node, 0, sizeof(*new_node));//清理新结点内存
    			new_node->next = NULL;	//新结点的指针域设为空
    			new_node->data = i+1;	//新结点的数据域放入数值
    			/*到这里新结点的建立就完成了,下面是头插法的逻辑实现*/
    			
    			if( head == NULL)
    			{
    				head = new_node;//若头指针为空,则是第一个结点,直接用头指针指向它
    			}
    			else
    			{
    				front = head;				//用front保留住上一个链表的地址
    				new_node->next = front;		//新链表的尾部指向上一个链表的头
    				head = new_node;			//head指向新建链表的头
    			}
    			
    		}
    

      4.5 for循环实现遍历链表

    		for(prt = head; prt != NULL; prt = prt->next)	//循环实现遍历
    		{
    			printf("%d\n", prt->data);  //打印每个节点的数据
    		}
    

    5.实践创建栈和队列(完整代码)

      整合上面各部分的代码,包含malloc、memset和printf的头文件,再用上条件编译,完整的代码如下:

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #define INSERT_BEHIND		//定义了这行就用尾插擦,注释这行就用头插法
    
    typedef struct node_s		//定义链表结构
    {
    	int	 	data;				//链表的数据域	
    	struct node_s  *next;		//链表的指针域	
    	
    } node_t;						//重定义结构体node_s为node_t
    
    int main (int argc, char **argv)
    {
    	node_t		*head = NULL;		//初始化链表的头指向nowhere
    	node_t		*new_node;			//新结点的指针
    	node_t		*tail;				//链表的尾指针
    	node_t		*front;				//链表的头指针	
    
    	int 		MagnetoF;		// 计数器(author of this passage: MagnetoF)
    	
    	
    #ifdef	INSERT_BEHIND		//条件编译:定义了INSTER_BEHIND就使用尾插法实现队列的数据结构
    	for( MagnetoF = 0; MagnetoF < 8; MagnetoF++)		//循环创建链表
    	{
    		new_node = malloc(sizeof(node_t) );		//创建一块内存,并用new_node指针标记
    	
    		memset(new_node, 0, sizeof(*new_node) );	//清空申请的内存
    
    		new_node->next = NULL;				//新链表的尾部指向nowhere
    		
    		new_node->data = MagnetoF+1;			//把数据域放入相应的值
    
    		if(head == NULL)
    		{	
    			head = new_node;			//若头指针为空,则是第一个结点,头指针指向新结点
    		}
    		else
    		{	
    			tail->next = new_node;		//非首个结点,尾结点的指针域指向新结点
    		}
    		tail =  new_node;			//尾指针指向新的结点
    
    	}
    #else 		//未定义INSERT_BEHIND时,使用头插法
    	for( MagnetoF = 0; MagnetoF < 8; MagnetoF++)		//这里创建新链表的for循环和尾插法一样
    	{
    		new_node = malloc(sizeof(node_t) );		
    	
    		memset(new_node, 0, sizeof(*new_node) );	
    
    		new_node->next = NULL;				
    		
    		new_node->data = MagnetoF+1;
    	
    	
    		if(head == NULL)		//这里开始是头插法的关键
    		{
    			head = new_node;
    		}
    		else
    		{
    			front = head;			//用front保留住上一个链表的地址
    			new_node->next = front;		//新链表的尾部指向上一个链表的头
    			head = new_node;		//head指向新建链表的头
    		}
    
    	}
    #endif
    		node_t		*prt;		
    
    		for(prt = head; prt != NULL; prt = prt->next)	//循环实现遍历
    			printf("%d\n", prt->data);
    		
    	
    	
    	return 0;
    	
    
    }
    
    

      在Ubuntu18.04下用gcc编译分别生成“list_FIFO”(尾插法实现队列)和“list_FILO”(头插法实现栈)。两者运行的结果如下:
    在这里插入图片描述

    展开全文
  • ![图片](https://img-ask.csdn.net/upload/201703/05/1488682196_932629.jpg)![图片](https://img-ask.csdn.net/upload/201703/05/1488682440_11686.jpg)![图片]...
  • 原理 首先了解尾插法之前先了解原理,相信各位到来的嘉宾都会些基础了吧! 这里我就或
  • 单向链表 尾插法

    2020-04-21 13:52:37
    } //将新节点插入到链表末尾(尾插法) int tail_ins(struct node head,struct node new) { struct node* p=head; while(p->next) p = p->next; //将新节点插入到链表末尾 p->next = new; return 0; } //链表遍历 ...
  • 关于java创建新链表尾插法的代码展示,将输入的数一个一个插到链表尾端 节点定义及尾插法添加 package LeetCode; import java.util.Scanner; public class ListNode { public int val; public ListNode next; ...
  • 动态链表尾插法

    2020-11-11 20:37:50
    动态链表 动态链表 #include #include<malloc.h> #include<time.h> using namespace std; static int length=0; typedef struct List{ int data; List* next; }List; void listInit(List *l) { l->...
  • 链表尾插法

    2021-03-05 20:21:38
    有头链表尾插法: 首先要了解尾插的概念:什么是尾插? 当next指针是空的时候就是链表尾部 #include<stdio.h> #include<stdlib.h> //创建数据 struct Node { int data; struct Node* next; } //...
  • 链表尾插法

    2021-07-19 22:28:34
    ②为新节点的数据域赋值 ③把新节点插到链表末尾(尾指针指向的节点,也就是链表末尾,指向新节点,即尾指针存放的节点的指针域存放新节点的地址) ④新节点作为链表末尾(把尾指针指向新节点,即尾指针存放新节点的...
  • C语言:链表尾插法

    千次阅读 2018-06-20 16:11:50
    尾插法 #include<iostream> using namespace std; typedef struct LNode { int data; struct LNode *next; } LinkNode; //尾插法 void CreateListR(LinkNode * &L, int a[], int n) { Lin...
  • C++实现链表尾插法

    千次阅读 2019-06-29 10:01:49
    将数组的所有元素使用尾插法插入到一个链表中,最终的序列与插入的序列是一致的 具体节点的插入如下图: 2. 下面是具体的C语言代码: #include<stdio.h> #include<malloc.h> typedef struct node{...
  • 双向链表尾插法同单链表的尾插法一样,通过将新结点逐个插入链表的尾部来创建链表,将链表尾部的结点的指针域指向后缀,不同的是新结点不仅需要将链表尾部结点的后缀指针域指向新结点,还需要将新结点的前缀指向...
  • 链表存储结构: 要建立双链表,首先要明白双链表的存储结构定义: typedef struct DLinkList{ //存储结构定义 int data; DLinkList * prior; DLinkList * next; } 思想: 该方法是将新节点插入双链表的表尾...
  • 双向链表 头插法 尾插法

    千次阅读 2019-04-23 10:40:24
    双向链表 头插欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • 该方法是将节点插入在当前循环双链表的表尾上,为此增加一个尾指针r ,并始终指向当前链表的尾节点,最后让r->next 指向头结点。头结点的prior 指向尾节点。 注意:这里头结点,尾节点 要相互指向 才是循环双链表 ...
  • 有关单链表的创建,就地逆置,头插法,尾插法,输出等
  • 不带头节点的链表尾插法C++实现

    千次阅读 2014-11-07 11:20:31
    #include using namespace std;...//链表尾插法 struct SNode { DATA data; SNode* pNext; }; struct SList { SNode* m_pHead; SNode* end_pHead; SList() { m_pHe
  • 尾插法建立链表详解

    千次阅读 多人点赞 2020-07-10 10:42:58
    尾插法,顾名思义,就是把新加入的节点插入到上一个节点的尾部(头插法是把新加入的节点插入到上一个节点的头部),next存储下一个节点位置的地址,开始时,初始化定义头节点 head -> next = NULL; 表示头节点...
  • 链表尾插法及遍历

    2020-07-04 22:22:06
    //创建一个非循环单链表,并将该链表的头结点的地址赋给pHead traverse_list(pHead); return 0; } PNODE create_list(void) { int len; int i; int val; //用来临时存放用户所输入的节点的值 //分配了一个不...
  • 尾插法循环链表

    2021-08-21 16:27:07
    /*插入到链表尾部,定位新的尾指针*/ newP->next = L->Tail->next; L->Tail->next = newP; /*鸠占鹊巢*/ L->Tail = newP; return 0; } int main() { pList L = (pList)malloc(sizeof(List)) ; /*为链表分配内存*/ ...
  • struct node { int id; char name[32]; node* next; node* prior; }; node* head; int len; void creat() { head=new node; head->prior=NULL; head->next=NULL; node* r=head;
  • 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。 /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ ...
  • 链表--尾插法构造(c语言)

    千次阅读 2018-09-09 14:58:09
    void create_tail_DLinklist(DNode *&head)//采用尾插法构建双链表 {  head = (DNode*)malloc(sizeof(DNode) );  head->data = 0 ;  head->prior= NULL ;  head->next = NULL ;//创建头结点  DNode * p...
  • 链表之静态尾插法

    2020-07-16 08:00:23
    静态链表尾插法 尾插法 就是在相关数据的尾巴插入。 比如有1,2,3,4,5,想在5的后面插入100. 1.找到5 2.让新成员下一个 = 5的下一个; 3.5的下一个 = 新成员; while(p != NULL) { if(p->data == data) { new...
  • #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedefintElemType; //定义节点类型 typedefstructLNode ...LinkListCreateLinkList_H()//单链表的建立(尾插法建立) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,688
精华内容 9,475
关键字:

链表尾插法