精华内容
下载资源
问答
  • 头插法 头插法是用结构体数组来实现的。 具体的思路是:在建立邻接表时,记录的不是点而是边,对于每一个点所对应的邻接表都是以栈的形式存储的,也就是说先添加的边在遍历时后取出,除此以外,所有的边用一个结构体...
  • 头插法和尾插法

    2020-12-08 09:41:21
    头插法 void HeadCreatList(List *L) //头插法建立链表 { List *s; //不用像尾插法一样生成一个终端节点。 L->next = NULL; for (int i = 0; i < 10; i++) { s = (struct List*) malloc(sizeof(struct List...
    头插法
    

    在这里插入图片描述

    void HeadCreatList(List *L) //头插法建立链表
    {
    List *s; //不用像尾插法一样生成一个终端节点。
    L->next = NULL;
    for (int i = 0; i < 10; i++) {
            s = (struct List*) malloc(sizeof(struct List));//s指向新申请的节点
            s->data = i;//用新节点的数据域来接受i
            s->next = L->next; //将L指向的地址赋值给S;//头插法与尾插法的不同之处主要在此,
            //s所指的新节点的指针域next指向L中的开始节点
            L->next = s; //头指针的指针域next指向s节点,使得s成为开始节点。
        }
    }
    

    尾插法
    

    在这里插入图片描述

    void TailCreatList(List *L) //尾插法建立链表
    {
    List *s, *r;//s用来指向新生成的节点。r始终指向L的终端节点。
    r = L; //r指向了头节点,此时的头节点是终端节点。
    for (int i = 0; i < 10; i++) {
            s = (struct List*) malloc(sizeof(struct List));//s指向新申请的节点
            s->data = i; //用新节点的数据域来接受i
            r->next = s; //用r来接纳新节点
            r = s; //r指向终端节点
        }
        r->next = NULL; //元素已经全部装入链表L中
        //L的终端节点指针域为NULL,L建立完成
    }
    
    展开全文
  • 头插法和尾插法总结(动图版)

    千次阅读 多人点赞 2021-02-03 22:41:29
    头插法:利用头指针控制链表节点的增加。 核心: newNode->next = head->next; head->next = newNode; //头插法创建链表 Link headCreateLink(int n){ //头指针初始化部分 Link head,newNode; head =...

    代码使用结构体:

    typedef struct Node{
    	int value;
    	struct Node* next;
    }*Link;
    

    头插法:利用头指针控制链表节点的增加。

    核心:
    newNode->next = head->next;
    head->next = newNode;

    在这里插入图片描述

    //头插法创建链表
    Link headCreateLink(int n){
        //头指针初始化部分
    	Link head,newNode;
    	head = (Link)malloc(sizeof(struct Node));
    	head->next = NULL;
        
    	while(n--){
    		newNode = (Link)malloc(sizeof(struct Node));
    		scanf("%d",&newNode->value);
            // 主要核心,新节点指向头指针的下一节点,头指针指向新节点。
    		newNode->next = head->next;
    		head->next = newNode;
            
    	}
        
    	return head;
    }
    

    尾插法:需要借助一个辅助指针rear,指向当前链表最后一个节点,每次处理辅助指针指向的节点和新增的节点的关系即可。

    核心:
    newNode->next = rear->next;
    rear->next = newNode;
    rear = rear->next;

    在这里插入图片描述

    //尾插法创建链表
    Link rearCreateLink(int n){
        //头指针初始化以及rear指针初始化指向头指针。
    	Link head,rear,newNode;
    	head = (Link)malloc(sizeof(struct Node));
    	head->next = NULL;
    	rear = head;
        
    	while(n--){
    		newNode = (Link)malloc(sizeof(struct Node));
    		scanf("%d",&newNode->value);
            // 主要核心,新节点指向rear的下一节点,rear的下一节点指向新节点(顺序切记不可搞反),rear指向新节点。
    		newNode->next = rear->next;
    		rear->next = newNode;
    		rear = rear->next;
    	} 
    	return head;
    }
    

    测试时完整代码(可忽略)

    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct Node{
    	int value;
    	struct Node* next;
    }*Link;
    
    Link headCreateLink(int n);
    Link rearCreateLink(int n);
    void print(Link head);
    int main(){
    	Link L1 = headCreateLink(5);
    	Link L2 = rearCreateLink(5);
    	printf("头插法:");
    	print(L1);
    	printf("尾插法:");
    	print(L2);
    	return 0;
    }
    Link headCreateLink(int n){
    	Link head,newNode;
    	head = (Link)malloc(sizeof(struct Node));
    	head->next = NULL;
    	while(n--){
    		newNode = (Link)malloc(sizeof(struct Node));
    		scanf("%d",&newNode->value);
    		newNode->next = head->next;
    		head->next = newNode;
    	}
    	return head;
    }
    Link rearCreateLink(int n){
    	Link head,rear,newNode;
    	head = (Link)malloc(sizeof(struct Node));
    	head->next = NULL;
    	rear = head;
    	while(n--){
    		newNode = (Link)malloc(sizeof(struct Node));
    		scanf("%d",&newNode->value);
    		newNode->next = rear->next;
    		rear->next = newNode;
    		rear = rear->next;
    	} 
    	return head;
    }
    void print(Link head){
    	Link link;
    	if(head == NULL || head->next == NULL){
    		printf("此链表为空!\n");
    		return ;
    	}
    	link = head->next;
    	while(link!=NULL){
    		printf(" %d ",link->value);
    		link = link->next;
    	}
    	printf("\n");
    }
    

    测试结果:
    在这里插入图片描述

    展开全文
  • 因而,下面代码主要实现单链表的创建(头插法和尾插法),增加,删除,清空以及遍历功能。 #include <iostream> #include <string> using namespace std; typedef struct{ int num; string name; }...

    单链表头插法和尾插法的实现(带有头结点)

    单链表的功能特点主要用于频繁增删数据,而不适宜查找。因而,下面代码主要实现单链表的创建(头插法和尾插法),增加,删除,清空以及遍历功能。

    #include <iostream>
    #include <string>
    using namespace std;
    
    typedef struct{
    	int num;
    	string name;
    }ElemType;
    
    typedef struct Node{
    	ElemType data;
    	Node* next;
    }Node,*LList;
    
    struct LinkList{
    	LList LL;
    	int length;
    };
    
    void InitLinkList(LinkList &L){		//初始化
    	L.LL = new Node();
    	L.LL->next = NULL;
    	L.length = 0;
    }
    
    int CreateLinkList_head(LinkList &L,int n){		//头插法
    	if(n > 0){
    		cout << "请输入学生的学号和姓名:" << endl;
    		for(int i = 0;i < n;i++){
    			Node* p = new Node();
    			cin >> p->data.num >> p->data.name;
    			p->next = L.LL->next;
    			L.LL->next = p;
    			L.length++;
    		}
    		return 1;
    	}
    	return 0;
    }
    
    int CreateLinkList_tail(LinkList &L,int n){		//尾插法
    	if(n > 0){
    		cout << "请输入学生的学号和姓名:" << endl;
    		Node* temp = L.LL;
    		for(int i = 0;i < n;i++){
    			Node* p = new Node();
    			cin >> p->data.num >> p->data.name;
    			p->next = NULL;
    			temp->next = p;
    			temp = p;
    			L.length++;
    		}
    		return 1;
    	}
    	return 0;
    }
    
    int LinkList_Length(LinkList L){		//链表长度
    	return L.length;
    }
    
    void Insert_LinkList(LinkList &L,int i){		//在i位置插入数据项
    	if(i > 0 && i <= L.length+1){
    		Node* p = L.LL->next;
    		if(i == 1){		//分2种情况:在首元节点插入和其他节点插入
    			Node* q = new Node();
    			cout << "请输入学生的学号和姓名:" << endl;
    			cin >> q->data.num >> q->data.name;
    			q->next = L.LL->next;
    			L.LL->next = q;
    			L.length++;
    			cout << "信息插入成功!" << endl;
    		}
    		else{
    			int j = 1;
    			while(j < i-1){
    				p = p->next;
    				j++;
    			}
    			Node* q = new Node();
    			cout << "请输入学生的学号和姓名:" << endl;
    			cin >> q->data.num >> q->data.name;
    			q->next = p->next;
    			p->next = q;
    			L.length++;
    			cout << "信息插入成功!" << endl;
    		}
    	}
    	else
    		cout << "信息插入失败!" << endl;
    }
    
    void Delete_LinkList(LinkList &L,int i){		//删除i位置的数据项
    	if(i > 0 && i <= L.length){
    		if(i == 1){		//分2种情况:在首元节点删除和其他节点删除
    			Node *p = L.LL->next;
    			L.LL->next = p->next;
    			delete p;
    			L.length--;
    			cout << "信息删除成功!" << endl;
    		}
    		else{
    			Node* p = L.LL->next;
    			int j = 1;
    			while(j < i-1){
    				p = p->next;
    				j++;
    			}
    			Node* q = p->next;
    			p->next = q->next;
    			delete q;
    			L.length--;
    			cout << "信息删除成功!" << endl;
    		}
    	}
    	else
    		cout << "信息删除失败!" << endl;
    }
    
    void Print_LinkList(LinkList L){		//遍历链表
    	Node* p = L.LL->next;
    	int i = 1;
    	while(p){
    		cout << "第" << i << "名学生信息如下:" << endl;
    		cout << "学号为:" << p->data.num << endl;
    		cout << "姓名为:" << p->data.name << endl;
    		p = p->next;
    		i++;
    	}
    }
    
    void Clear_LinkList(LinkList &L){		//清空链表
    	L.LL->next = NULL;
    	L.length = 0;
    	cout << "链表已清空!" << endl;
    }
    
    int main(){
    	LinkList L;
    	InitLinkList(L);
    	if(CreateLinkList_head(L,2)){
    		cout << "链表(头插法)创建成功!" << endl;
    	}
    	Print_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	Clear_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	cout << "-----------------------------------------------------------------" << endl;
    	if(CreateLinkList_tail(L,2)){
    		cout << "链表(尾插法)创建成功!" << endl;
    	}
    	Print_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	cout << "-----------------------------------------------------------------" << endl;
    	Insert_LinkList(L,3);
    	Print_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	cout << "-----------------------------------------------------------------" << endl;
    	Delete_LinkList(L,3);
    	Print_LinkList(L);
    	cout << "链表长度为:" << LinkList_Length(L) << endl;
    	system("pause");
    	return 0;
    }
    

    输入输出如下图所示。在这里插入图片描述

    展开全文
  • 相关代码: #include<...//头插法建立链表 带有head头结点的情况。 Node *create1(int n){ Node *head ,*s; int i; head=(Node *)malloc(sizeof(Node)); //head节点申请了一个内存空间。 h..
    • 相关代码:

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct Node {
    	int data;
    	struct Node *next;
    }Node;
    
    //头插法建立链表      带有head头结点的情况。
    Node *create1(int n){
    	Node *head ,*s;
    	int i;
    	head=(Node *)malloc(sizeof(Node));    //head节点申请了一个内存空间。
    	head->next=NULL;
    	for(i=1;i<=n;i++){
    		s=(Node *)malloc(sizeof(Node));
    		printf("第%d个元素: ",i);
    		scanf("%d",&s->data);
    		s->next= head->next;    //最开始插入第一个节点的时候,s->next=NULL. head节点又指向s。从而第一个节点插入成功。
    		head->next=s;
    	}
    	return head;
    }
    
    //不带head节点的头插法。
    Node *create2(int n){
    	Node *s,*p;
    	int i;
    	p=NULL;
    	for(i=1;i<=n;i++){
    		s=(Node *)malloc(sizeof(Node));
    		printf("第%d个元素: ",i);
    		scanf("%d",&s->data);
    		s->next=p;
    		p=s;
    	}
    	return p;
    }
    
    //尾插法,带有head节点的方法。
    Node * create3 (int n){
    	Node *head,*s,*r;
    	int i;
    	head =(Node *)malloc(sizeof(Node));
    	head->next=NULL;
    	r=head;
    	for(i=1;i<=n;i++){
    		s = (Node *)malloc(sizeof(Node));
    		printf("第%d个元素:",i);
    		scanf("%d",&s->data);
    		r->next=s;
    		r=s;
    	}
    	return head;
    }
    //定义一个打印链表中元素的方法。
    void print(Node *head){
    	Node *p = head->next;     //p指向的是第一个节点。
    	while(p!=NULL){
    		printf("%d ",p->data);
    		p=p->next;
    	}
    }
    void main(){
    	
    	print(create3(3));
    }
    

    展开全文
  • } } 用用头插法和尾插法完成链表的初始化 头插法实现相对比较简单 尾插法实现因为head不能变,所以需要一个辅助节点tem; 画图会比较容易理解。 import leetcode.dataType.ListNode; public class LeetCode_206 { ...
  • 单链表之头插法和尾插法详解(C语言版)

    千次阅读 多人点赞 2021-04-20 23:50:50
    用图来详细讲解单链表的头插法和尾插法,以及它们之间的对比
  • java的头插法和尾插法

    2021-05-11 10:50:10
    header:头部 tailer:尾部 头插法头插法的实现相对简单 思路是将新形成的节点的下一个...尾插法尾插法相对于头插法有些许不同 因为要返回头 头不能动 所以需要一个tailer来记录最后一个值 tailer右移 ...
  • 头插法的初衷是设计者遵循一个新加进来的元素可能被使用的频率更高,这其实是一个伪命题,因为在hashmap扩容的时候,链表也是会发生颠倒的,因为是先从头节点开始转移掉新的hash表中。 头插法还有一个致命的缺点,...
  • } } 用用头插法和尾插法完成链表的初始化 头插法实现相对比较简单 尾插法实现因为head不能变,所以需要一个辅助节点tem; 画图会比较容易理解。 public class LeetCode_206 { public static void main(String[] args...
  • 头插法:readlisthead 尾插法:readlisttail #include<stdio.h> #include<stdlib.h> struct ListNode { int data; ListNode* next; }; ListNode* readlisthead() { struct ListNode head,tail,p; head =...
  • 数据结构——头插法和尾插法

    千次阅读 2020-03-15 21:08:58
    头插法和尾插法 1.节点的定义 2.采用头节点的好处 3.采用头插法建立链表 该方法从空表开始,生成新节点,并将读取到的数据存放到新节点的数据域中,并将新节点插入到当前链表的表头,即头节点之后。 采用头插法...
  • 单链表的头插法和尾插法(C语言实现) #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 typedef int Elemtype; typedef int Status; typedef struct LNode{ Elemtype data; ...
  • 头插法:生成的链表我输入的数据顺序是相反的,所以又称逆序建表法。 例如:e d c b a 建成的链表就是            head->a->b->c->d->e 算法步骤: ①创建一个...
  • 单链表 单链表(Single Linked List): 单链表是一种链式存取的数据结构,用一组地址任意(可能连续,也可能...指针head:单链表中每个结点的存储地址是存放在其前趋结点next域中,而开始结点无前趋,故应设指针h
  • 头插法和尾插法图文并茂

    万次阅读 多人点赞 2018-06-03 10:15:43
    #include "stdio.h" #include "stdlib.h" typedef struct List { int data; //数据域 ... void TailCreatList(List *L) //尾插法建立链表 { List *s, *r;//s用来指向新生成的节点。r始终指向...
  • 用Python实现数据结构的头插法和尾插法 1.链表结构 # -*- coding:utf-8 -*- import random as rd class Node(): def __init__(self, value, next=None): self.value = value self.next = next 2.头插法 #头插...
  • 创建链表(头插法) void CreateLlist(LNode**head) { *head = (LNode*)malloc(sizeof(LNode)); (*head)->next = NULL; int n; printf("请输入元素个数"); scanf_s("%d", &n); int x; LNode* p; for (int i...
  • 复习C语言 链表的头插法和尾插法

    千次阅读 2019-03-14 21:29:25
    对于链表的建立,我们常用的方法有两种,一种是头插法:代码如下 LinkList headInsert(LinkList L,int length){ L = (Node *)malloc(sizeof(Node)); L->next = NULL; int i = 0,temp; while(i){ Node * p =...
  • 数据结构-头插法和尾插法

    万次阅读 多人点赞 2019-05-01 20:41:50
    头插法 void HeadCreatList(List *L) //头插法建立链表 { List *s; //不用像尾插法一样生成一个终端节点。 L->next = NULL; for (int i = 0; i < 10; i++) { s = (struct List*) malloc(sizeof(struct ...
  • 单链表头插法和尾插法C/C++代码实现

    千次阅读 2020-05-31 17:22:30
    1,头插法/前插法: 通过将新结点逐个插入链表的头部(头结点之后)来创建链表,每次申请一个新结点,读入相应的数据元素值,然后将新结点插入到头结点之后。 需要注意的是:头插法是逆序的,先插入的反而在后面。 ...
  • 2.单链表的插入操作(头插法和尾插法) (1)头插法(带头结点) //头插法(带头结点) LinkList List_HeadInsert(LinkList &L){ LNode *s; int x; L = (LinkList)malloc(sizeof(LNode)); //创建头结点 L
  • 线性表可分为顺序存储结构链式存储结构 顺序存储结构的创建,其实就是一个数组的初始化,即声明一个类型大小的数组并赋值的过程。而单链表顺序存储结构就不一样,它的每个数据的存储位置不需要像数组那样集中...
  • 这里的讲解实例用的是哈希表的链地址法 ...spm=1001.2101.3001.4242 哈希表的剩余代码可以去原作者博客参考,原作者讲的挺好,不过有一点小瑕疵,需要看下面的评论 头插法 int harsh_table_insert_node
  • #include <stdio.h> #include<stdlib.h> typedef struct LNode { int data; struct LNode *next; }LNode; void createlistR(LNode *&c,int a[],int n) { LNode *s,*r; int i;...
  • //删除(仅保留一个表头结点) } } //前插法建立单链表 public void inputFront(ListNode5 engTag){ //endTag是约定的输入序列结束的标志,如果输入序列是正整数,engTag可以是0或负数 //如果输入序列是...

空空如也

空空如也

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

头插法和尾插法