精华内容
下载资源
问答
  • 有关单链表的创建,就地逆置,头插法尾插法,输出等
  • 双向链表 头插法 尾插法

    千次阅读 2019-04-23 10:40:24
    双向链表 头插法欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
    #include"ll.h"
    #define CHECK(p)  if(NULL==p) return NULL
    #define  ERR   -1
    #define  succes 0
    int *jjd1();int *jjd();
    int foreach (lin *pheader);
    typedef struct lin{
        int num;
        struct lin *pri;
        struct lin *pnext;
    
    }lin;//结构体
    int main(void)
    {   lin *pheader=NULL;
       // pheader=jjd1();//尾插法
        pheader=jjd();//头插法
        foreach (pheader);//遍历
        return 0;
    }
    int *jjd1(){
        lin *pheader=( lin *)malloc(sizeof( lin));
        CHECK(pheader);
        pheader->pri=NULL;pheader->pnext=NULL;
        int val=0;
        lin *pt= pheader;
        while(1){
            printf("shuru");
            scanf("%d",&val);
            if(ERR==val){break;}
            lin *pnode=( lin *)malloc(sizeof( lin));
            pnode->pri=NULL;pnode->pnext=NULL;
            pnode->num=val;
            pnode->pri=pt;
            pt->pnext=pnode;
            pt=pnode;
            }return pheader;//尾插法
    }
    int *jjd(){
        lin *pheader=( lin *)malloc(sizeof( lin));
        CHECK(pheader);
        pheader->pri=NULL;pheader->pnext=NULL;
        int val=0;
        lin *pm = (lin *)malloc(sizeof(lin));
        memset(pm, 0, sizeof(lin));
        pm->pri = NULL;
        pm->pnext = NULL;
         printf("shuru");
        scanf("%d",&val);
        pm->num=val;
        pheader->pnext=pm;
        pm->pri=pheader;
        //printf("%d",pm->num);
          while(1){
            printf("shuru");
            scanf("%d",&val);
            if(ERR==val){break;}
                 lin * pt = (lin *)malloc(sizeof(lin));
                    pt->pri = NULL;
                    pt->pnext = NULL;
                    pt->num=val;
                    pheader->pnext=pt;
                    pm->pri = pt;
                    pt->pnext =pm;
                    pt->pri =pheader;/*printf("%d",pt->num);*/
                    pm=pt;
      }return pheader;
    }//头插法
    int foreach (lin *pheader){
        CHECK(pheader);
        lin *pc=pheader->pnext;
        while(pc!=NULL){
        printf("%d\n",pc->num);
        pc=pc->pnext;}
        return succes;
    }
    
    
    展开全文
  • 带头节点的单链表的头插法尾插法及删除节点操作 链表的操作对于初学者来说理解非常有难度,初学的同学们应该在学习链表的过程中多再练习本上画图,写一行代码就画出代码执行后链表各节点图的变化,方便理解。我也是...

    带头节点的单链表的头插法尾插法及删除节点操作

    链表的操作对于初学者来说理解非常有难度,初学的同学们应该在学习链表的过程中多再练习本上画图,写一行代码就画出代码执行后链表各节点图的变化,方便理解。我也是刚学c语言不久,也是第一次写博客,如果有什么不对的地方,还望 大家多~多指教。


    首先先看一下单个节点的结构:

    typedef struct node{
    	int data;  //数据域 
    	struct node*next;  //指针域 
    }Node;
    

    注意我用 typedef 将struct node 重新命名为Node,如果没有这个重命名所有Node 的地方全部要改为struct node.

    首先:注意区分头节点和头指针,头节点可有可无,头节点的存在是为了方便单链表的操作,本质是一个节点,它的数据域无意义一般存 0. 而头指针是必须要存在的,本质是一个指针.
    然后 :如果头节点存在,头指针就指向头节点,若头节点不存在,头指针就指向链表中第一个节点.


    1.创建一个带头节点的单链表:

    Node*create()  //创建链表带头节点 
    {
    	Node*head=NULL;
    	head=(Node*)malloc(sizeof(Node));
    	if(NULL==head)
    	{
    		printf("memory out of use\n"); //内存分配不足,一般不会出现
    		return NULL;
    	}
    	head->data=0;
    	head->next=NULL;
    	return head;
    }
    

    2.头插法增加节点:(自动忽视函数名 哈~)

    int hhh(Node*head,int num)  //头插法增加链表节点 num为插入新节点的数据
    {
    	Node*p=head->next,*pr=NULL;    //pr为新节点并初始化 
    	pr=(Node*)malloc(sizeof(Node));
    	if(NULL==pr) 
    	{
    		printf("memory out of use\n");  
    		return NULL;
    	}
    	pr->data=num;
    	pr->next=p;
    	head->next=pr;
    	return 0;
    }
    

    在这里插入图片描述


    3.尾插法增加新节点:(自动忽视函数名 哈~)

    int hh(Node*head,int num)   //尾插法增加链表节点 
    {
    	Node*p=head,*pr=NULL; //pr为新节点并初始化 
    	pr=(Node*)malloc(sizeof(Node));
    	if(NULL==pr)
    	{
    		printf("memory out of use\n");
    		return NULL;
    	}
    	pr->data=num;
    	if(NULL==head->next)  //判断是否为空链表 
    	{                       // 若为空链表 则将新的节点插在头节点后 
    		head->next=pr;
    		pr->next=NULL;
    	}
    else	{                    //若不是空链表,则遍历链表找到最后的节点 p 
    while(p->next!=NULL)
    	     {
    		p=p->next;
         	}
    	p->next=pr;   //插入新的节点 
    	pr->next=NULL;
       }
    }
    

    在这里插入图片描述


    3.打印链表:

    void display(Node*head)  //打印链表 
    {
    	Node*pr=head->next;
    	while(pr){
    		printf("%d ",pr->data);
    		pr=pr->next;
    	}
    }
    

    4.删除指定数据的节点:

    int del(Node*head,int num) //按值查找删除节点 
    {
    	Node*p=head,*pr=NULL;
    	if(NULL==head)         //如果链表为空 
    	{
    		printf("empty list\n");   
    		return -1;
    	 }
    	 while(p->next->data!=num)  //遍历单链表找到要删除节点的前一个节点 
    	 {
    	 	p=p->next;
    	 }
    	 if(NULL==p)    //如果没有找到 
    	 {
    	 	printf("no find the node\n");
    	 	return -1;
    	 }
    	 pr=p->next;   //pr为临时指针指向要删除的节点  保证下一步删除时后面的链表能够知道 
    	 p->next=p->next->next;  //要删除节点的前一个节点指向后一个节点 
    	 free(pr);  // 释放 pr 
    	  return 0;
     } 
    

    图画的有点丑哈~


    5.主函数:

    int main()
    {
    	Node*head=create();
    	for(int i=1;i<=3;i++)  //头插法单链表赋数据值 亦可以自己循环输入 
    	{
    		hhh(head,i);
    	}
    	del(head,2);     //删除指定值的节点,值可以自己控制 
    	display(head);   //打印头插法建立的单链表   
      printf("\n");
      for(int i=1;i<=3;i++)  //尾插法单链表赋数据值 亦可以自己循环输入 
    	{
    		hh(head,i);
    	}
    	del(head,2);          //删除指定值的节点,值可以自己控制 
    	display(head);   //打印尾插法建立的单链表 
    return 0; 
    }
    

    注意我只建立了一条单链表,为了能一次展示出来把代码都放在一起了,但是这样运行第二次单链表的操作的前提肯定包含了前一次操作的结果,大家写的时候要分开,或者直接建立两个单链表。


    补充两节点的交换(只有关键交换的代码…)

    	pr->next=p->next;
    	p->next=pr->next->next;
    	pr->next->next=p;  //注意顺序 
    	
    	p=p->next;   //后移 
    	pr=pr->next;
    	
    

    图有点丑哈~

    就这么多了,图画的有点丑哈~哈.

    展开全文
  • 单链表的创建分为头插法尾插法头插法是不断地向头结点插入新的结点。这样会使你所插入的结点值呈现逆序,所以头插法也可以实现单链表的逆置。尾插法是不断地向插入的新元素之后再插入新的元素。需要注意的是头插...

    单链表的创建分为头插法和尾插法,头插法是不断地向头结点插入新的结点。这样会使你所插入的结点值呈现逆序,所以头插法也可以实现单链表的逆置。尾插法是不断地向插入的新元素之后再插入新的元素。需要注意的是头插法必须初始化头结点,使得头结点的指针域指向NULL,即p->next=NULL,详细请看代码:

    #include

    #include

    #include

    /* run this program using the console pauser or add your own getch, system("pause") or input loop */

    //单链表定义(结构体)

    typedef struct LNode{

    int data;//数据域

    struct LNode *next;//指针域

    }LNode,*LinkList;

    //初始化单链表(不带头结点)

    /*

    bool InitList(LinkList &L){

    L = NULL;//将单链表初始化为空表

    return true;

    }

    */

    //初始化单链表(带头结点)

    bool InitList(LinkList &L){

    L = (LNode *)malloc(sizeof(LNode));//分配一个头结点,并且用L指针变量指向这个头结点

    if(L==NULL){

    return false;//内存不足分配失败

    }

    L->next = NULL;//头结点之后暂时还没有结点

    return true;

    }

    //尾插法建立单链表

    LinkList List_TailInsert(LinkList &L){

    int x;

    LNode *s,*r = L;//声明新结点和尾指针

    scanf("%d",&x);

    while(x!=9999){

    s = (LNode *)malloc(sizeof(LNode));

    s->data = x;

    r->next = s;//将r结点与s结点连接

    r = s;//尾指针指向s

    scanf("%d",&x);

    }

    r->next = NULL;

    return L;

    }

    //头插法建立单链表

    LinkList List_HeadInsert(LinkList &L){

    int x;

    LNode *s;

    scanf("%d",&x);

    while(x!=9999){

    s = (LNode *)malloc(sizeof(LNode));

    s->data = x;//与后插操作类似,与后插不同的是每次在头结点插入

    s->next = L->next;

    L->next = s;

    scanf("%d",&x);

    }

    return L;

    }

    /*

    LNode *p = (LNode*)malloc(sizeof(LNode));//为结点申请内存空间,并且用指针p指向起始地址

    */

    //查找第i个结点(带头节点p指向第一个节点,不是头结点)

    /*

    LNode * GetElem(LinkList L,int i){

    int j = 1;

    LNode *p = L->next;

    if(i==0){

    return L;

    }

    if(i<1){

    return NULL;

    }

    while(p!=NULL&&j

    p = p->next;

    j++;

    }

    return p;

    }

    */

    //按位查找(带头节点)

    LNode *GetElem(LinkList L,int i){

    if(i<1){

    return NULL;

    }

    LNode *p = (LNode *)malloc(sizeof(LNode));

    int j=0;

    p = L;

    while(p!=NULL&&j

    p = p->next;

    j++;

    }

    return p;

    }

    //按值查找(带头节点)

    LNode *LocateElem(LinkList L,int e){

    LNode *p = (LNode *)malloc(sizeof(LNode));

    p = L->next;//使指针p指向第一个结点

    while(p!=NULL && p->data!=e){

    p = p->next;

    }

    return p;//找到返回结点指针,否则返回NULL

    }

    //求单链表的长度

    int length(LinkList L){

    int len = 0;

    // LNode *p = (LNode *)malloc(sizeof(LNode));

    LNode *p = L;

    while(p->next!=NULL){

    p = p->next;

    len++;

    }

    return len;

    }

    //按位序插入单链表(带头节点)

    bool ListInsert(LinkList &L,int i,int e){

    if(i<1){

    return false;

    }

    //GetElem(L,i-1);

    LNode *p;//指向当前表结点的指针

    int j = 0;//当前p指向的是第几个结点

    p = L;//L指向头结点,p也指向头结点.头结点不存任何数据

    if(p!=NULL&&j

    p = p->next;

    j++;

    }

    if(p==NULL){//i值不合法(可能超出单链表的长度)

    return false;

    }

    LNode *s = (LNode*)malloc(sizeof(LNode));

    s->data = e;//将结点的值存入s结点中

    s->next = p->next;//将s结点连接到p的下一个结点上

    p->next = s;//将p结点连接到s结点上 (上下两句位置不可换)

    //return InsertNextNode(p,e);

    }

    //指定结点后插操作

    bool InsertNextNode(LNode *p,int e){

    if(p==NULL){//当前p指针指向的结点正常指向下一个结点

    return false;

    }

    LNode *s = (LNode *)malloc(sizeof(LNode));

    if(s==NULL){//内存不足

    return false;

    }

    s->data = e;//存放数据

    s->next = p->next;

    p->next = s;//将s连接

    return true;

    }

    //指定结点前插操作

    bool InsertPriorNode(LNode *p,int e){

    if(p==NULL){

    return false;

    }

    LNode *s = (LNode *)malloc(sizeof(LNode));

    if(s==NULL){

    return false;

    }

    s->next = p->next;//连接结点

    p->next = s;

    s->data = p->data;//交换数据

    p->data = e;

    }

    //按位序删除单链表(带头节点)

    bool ListInsert(LinkList &L,int i,int &e){

    if(i<1){

    return false;

    }

    //GetElem(L,i-1);

    LNode *p;//指向当前表结点的指针

    int j = 0;//当前p指向的是第几个结点

    p = L;//L指向头结点,p也指向头结点.头结点不存任何数据

    if(p!=NULL&&j

    p = p->next;

    j++;

    }

    if(p==NULL){//i值不合法(可能超出单链表的长度)

    return false;

    }

    if(p->next==NULL){//i-1结点后无结点

    return false;

    }

    LNode *q = p->next;//q指向将要删除的结点

    e = q->data;//用e返回删除的元素值

    p->next = q->next;//把p与删除后的下一个结点连接

    free(q);//释放q结点的内存空间

    return true;

    }

    //输出函数

    void p(LinkList L){

    LNode *g;

    g = L->next;

    while(g!=NULL){

    printf("%d\t",g->data);

    g = g->next;

    }

    }

    int main(int argc, char** argv) {

    LinkList L;//声明单链表

    InitList(L);//初始化单链表

    List_TailInsert(L);//尾插法

    p(L);

    printf("\n");

    List_HeadInsert(L);//头插法

    // int l = length(L);

    // printf("%d\n",l);

    // for(int i=1;i<=l;i++){

    // LNode *g = GetElem(L,i);

    // printf("%d\t",g->data);

    // }

    p(L);

    return 0;

    }

    展开全文
  • 在上次实验课之后,有同学问我头插法尾插法到底是干什么的有什么用处,因为到饭点了,赶着吃饭 难以描述的原因,说晚点解释,一拖拖了几天。人的本质就是鸽子精,而我是老鸽子精 头插法 头插法就是从头插入(没问题...

    在上次实验课之后,有同学问我头插法和尾插法到底是干什么的有什么用处,因为到饭点了,赶着吃饭 难以描述的原因,说晚点解释,一拖拖了几天。人的本质就是鸽子精,而我是老鸽子精
    在这里插入图片描述
    原代码传送

    头插法

    头插法就是从头插入(没问题啊) :从头节点插入新节点,头节点的next不断更新指向插入元素地址,然后想要保存整条链就只要新元素等于头节点的next就行(保存了原来插入的元素)。(代码如下图)

    在遍历的时候从最后插入的元素向第一个插入的元素访问,效果和栈类似,先进后出,可以用做链栈,在C++的stl库中封装的stack头文件效果和这个类似。在这里插入图片描述
    在这里插入图片描述

    void GeateHeadList(List*& L, int a[], int n)
    {
        List* p;
        for (int i = 0; i < n; i++) {
            p = (List*)malloc(sizeof(List));
            p->data = a[i];
            p->next = L->next;
            L->next = p;
        }
    }
    

    尾插法

    尾插法就是从链的尾端插入元素,上一个元素的next指向新插入元素的地址,头节点始终指向第一个插入的元素,所以在遍历的时候也是从第一个插入的元素开始查询(一定要记得的在插入完最后一个元素后它的next一定要制空“NULL”),访问起来就像排队吃饭,先到先得,插队该打,可以用来写链队 。(代码如下图)

    在C++的stl库中封装的queue头文件中queue类型(queue头文件中还有多种类型队列)效果和这个类似。
    在这里插入图片描述
    (pre始终指向L的最后一个元素的位置)
    在这里插入图片描述

    void GeateTailList(List*& L, int a[], int n)
    {
        List *p, *pre = L;
        for (int i = 0; i < n; i++) {
            p = (List*)malloc(sizeof(List));
            p->data = a[i];
            pre->next = p;
            pre = p;
        }
        pre->next = NULL;
    }
    
    展开全文
  • 头插法只需要把刚刚新建的节点赋给头节点就行了 下次新建节点next可以直接指向头节点 尾插法 需要记录上次的节点 使next指向新建的节点 节点类 public class LinkNode { int val; LinkNode next; @Override ...
  • 单链表的基本操作,单链表头插法尾插法、创建、插入、删除、遍历
  • 头插法输入单链表(带有头结点) //1.链表的创建 (带头结点的头插法) LinkList List_HeadInsert(LinkList &L) { LNode *s; int x; L = (LinkList)malloc(sizeof(LNode)); L->next = NULL; scanf("%d", &...
  • 头插法尾插法创建链表 头插法尾插法创建链表一直是大家初学算法时搞不明白的事情,现在我将其总结了一下,发个博客记录一下 尾插法 尾插法就是定义一个头结点之后,挨个往后创建链表。 最关键的两步就是 head->...
  • 单链表的插入操作,包括头插尾插,两种的时间复杂度都为O(n)。 /* 单链表插入操作(头插+尾插) */ #include<iostream> #include<malloc.h> #include<stdlib.h> using namespace std; //定义...
  • 头插法的标准程序 尾插法的标准程序 有序(升序)链表的插入
  • 一个链表的建立搞了我几天,一度让我放弃数据结构,对于指针和函数才发现是真的...头插法 #include<stdio.h> #include<stdlib.h> #include<iostream> #include<time.h> //引入随机数...
  • 头插new->next=head->next head->next=new head->next现在假设为NULL new->next=head->next的意思是头节点的下一个指向head节点的下一个 所以现在new的next为NULL head->next=new的意思是把新...
  • 1、单链表的建立:头插法尾插法 初始化一个单链表 每次取一个数据元素,插入到表尾/表头 typedef struct LNode{ //定义单链表结点类型 ElemType data; //每个结点存放一个数据类型 struct LNode *next; //...
  • #include<stdio.h> #include<stdlib.h> //!!! struct Node{ int data; struct Node *next; }; //!!! typedef struct Node node;...int main() //头插法 { L head,p,q; head=(node*)m
  • 头插法建立单链表 头插法会使输入的数据插入到链表的表头,输出数据时的数据与读入的数据时相反的,如,以1 2 3 4 5 6 7 8 9建立链表,输出的结果是9 8 7 6 5 4 3 2 1 。第一个元素会始终在链表的尾部 1.建立一个空...
  • C/C++ 链 表 头插法 尾插法

    千次阅读 2019-03-12 10:30:10
    void Addhead(int d)//头插法 {  Node*p=(Node*)(malloc(sizeof(Node)));  p->data=d;  p->next=Phead;//{ 将现有头的NULL赋值给该新申请的next,使之为空即使该数据成为尾结点(仅仅对插入的第一个数而言)}...
  • 单链表头插法尾插法

    2018-08-07 19:59:51
    主函数如下:只需将主函数中for循环中的函数调用名字更改就可调用头插法尾插法函数并实现功能。 #include #include "LinkList2.h" void print(Element e) { printf("%d ", e); } int main() { int ret; ...
  • 参考: http://www.cnblogs.com/foreverking/articles/2341399.html 1 typedef int Datatype; typedef struct node{ Datatype data; struct node * next; }Node ,* LinkList;... //头插法 ...
  • 创建单链表,采用头插法创建单链表,尾插法创建单链表和遍历单链表并且输出单链表 public class LinkList { Node head; public LinkList(){ head = null; } /** * @author jcm * @see 头插法创建单链表 ...
  • } head:链表头节点 insert_data :被后插节点的值 new:新节点 头插法 struct Test *insertfromhead(struct Test *head) { struct Test *new = NULL; while(1){ new =( struct Test *)malloc(sizeof(struct ...

空空如也

空空如也

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

头插法尾插法