精华内容
下载资源
问答
  • 2021-05-24 09:22:44

    C语言 创建一个链表

    C语言 创建一个链表, 并将数据倒序输出代码如下:#include#include#include#define ok 1#define Elemtype inttypedef int status;typedef struct sql{Elemtype length;Elemtype data;struct sql *next;}SQL;SQL L;SQL *head;status create_head() //创建头结点{head=(SQL *)malloc(sizeof(struct sql));head->next=NULL;if(head) return ok;}status create_sql() //创建链表,并输入数据{int a,i;SQL *p,*q;p=head;printf("\n请输入链表的长度:");scanf("%d",&a);L.length=a;

    for(i=1;i<=L.length;i++){q=(SQL *)malloc(sizeof(SQL));if(q){printf("第%d个节点创建成功,请输入数据:",i);scanf("%d",&q->data);p->next=q;p=q;q->next=NULL;}else {printf("节点未创建成功,程序正在退

    出");exit(0);}}return ok;}status output() //输出链表的数据{SQL *p;p=head->next;while(p){printf("%4d",p->data);p=p->next;}return ok;}status daoxu() //将链表的数据倒序{SQL *k,*p,*q; int flag,i; //flag 标志位记录当前 *q 所在的节点 flag=0 为q指

    向头结点p=head->next;for(i=1;inext;}else {printf("链表为空!");exit(0);}}k=p; //*k 保存了最后一个节点的地址 flag=--i;while(flag){p->next=q;p=q;q=head;--flag;for(i=flag;i>0;i--)q=q->next;}p->next=NULL;q->next=k;return ok;}void main(){int i;i=create_head();if(i)printf("头结点创建成功\n");i=create_sql();if(i)printf("链表创建成功,数据成功输入。");printf("\n原链表:\n");output();daoxu();printf("\n倒序后链表:\n");output();printf("\n");}

    更多相关内容
  • c代码-将两个升序链表合并为一个新的 升序 链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。
  • 将两个升序链表合并为一个新的升序链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->3->5, 2->4->6 输出:1->2->3->4->5->6 #include <stdio....

    将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

    示例:
    输入:1->3->5, 2->4->6
    输出:1->2->3->4->5->6

     

    #include <stdio.h>
    #include <string.h>
    
    #include <assert.h>
    typedef struct Node
    {
        int data;//数据域,用来存放数据域;
        struct Node* pNext;//定义一个结构体指针,指向下一次个与当前节点数据类型相同的节点
    }NODE, * PNODE,**PPNODE;  
    //NODE等价于 struct Node; PNODE等价于struct Node *; 此处用大写是为了与变量区分,可以让人容易变出是个数据类型
    
    /*创建一个新节点*/
    PNODE Buynewnode(int x)
    {
        PNODE node = (PNODE)malloc(sizeof(NODE));
        assert(node);/*防止申请空间失败*/
        node->data = x;
        node->pNext = NULL;
        return node;
    }
    /*尾插*/
    void ListPushback(PPNODE head ,int x)
    {
        if (*head == NULL) /*如果插入时是一个空链表*/
        {
            *head = Buynewnode(x);
        }
        else
        {
            PNODE node = *head;
            while (node->pNext != NULL)
                node = node->pNext;
            node->pNext = Buynewnode(x);
    
        }
    }
    void printList(PNODE head)
    {
        if (head == NULL)
        {
            return;
        }
        PNODE p = head;
        for (; p; p = p->pNext)
            printf("%5d", p->data);
        printf("\n");
    
    }
    PNODE mergeTwoLists(PNODE list1, PNODE list2)
    {
        PNODE head = NULL;
        PNODE pre = NULL;
        if (list1 == NULL)return list2;
        if (list2 == NULL)return list1;
        while (list1 != NULL || list2 != NULL)
        {
            if (list1 != NULL && list2 != NULL)
            {
                if (list1->data <= list2->data)
                {
                    if (head == NULL)
                        pre = head = list1;
                    else
                    {
                        pre = pre->pNext = list1;
                    }
                    list1 = list1->pNext;
                }
                else
                {
                    if (head == NULL)
                        pre = head = list2;
                    else
                    {
                        pre = pre->pNext = list2;
                    }
                    list2 = list2->pNext;
                }
            }
            else if (list1 == NULL)
            {
                pre->pNext = list2;
                list2 = NULL; /*循环跳出条件*/
            }
            else
            {
                pre->pNext = list1;
                list1 = NULL;  /*循环跳出条件*/
            }
        }
        return head;
    
    }
    
    
    int main()
    {
        PNODE list1 = NULL;
        PNODE list2 = NULL;
        ListPushback(&list1,1);
        ListPushback(&list1, 3);
        ListPushback(&list1, 5);
        printList(list1);
        ListPushback(&list2, 2);
        ListPushback(&list2, 4);
        ListPushback(&list2, 6);
        printList(list2);
        PNODE p  = mergeTwoLists(list1, list2);
     
        for (; p; p = p->pNext)
            printf("%5d", p->data);
        printf("\n");
        return 0;
    }
    

    展开全文
  • 将两个升序链表合并为一个新的 升序 链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。 思路分析: 1.先创建一个哑节点demmy,再定义一个临时变量temp,用于遍历链表,temp = demmy; 2.执行判断语句...

    将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
    在这里插入图片描述
    在这里插入图片描述
    思路分析:
    1.先创建一个哑节点demmy,再定义一个临时变量temp,用于遍历链表,temp = demmy;
    2.执行判断语句(比较已有的两个链表,若对应值小的,放在前面,临时变量temp指针指向对应的链表):
    while(l1 != null && l2 != null){
    if(l1.val < l2.val){
    temp.next = l1;
    l1 = l1.next;
    }else{
    temp.next = l2;
    l2 = l2.next;
    }
    temp = temp.next;
    3.若出现原来的两个链表长短不一,短的链表处理结束后,将剩下的那一个链表直接加到新链表的后面。
    temp.next = (l1 != null) ? l1, l2;
    return demmy.next;

    展开全文
  • 链表学习(链表创建,插入,删除,查找,遍历)

    链表学习

    1.链表的创建:
    创建一个 头结点 并返回 空的节点

    Linked* Create()
    {
        Linked* head = (Linked*)malloc(sizeof(Linked));
        head -> next = NULL;
        return head;   
    }
    

    2.链表的删除:

    删除标志节点后的下一个节点

    void DeleteAfter(Linked* node)
    {
        Linked* nextnode=node->next; 
    	node -> next = nextnode -> next;
    	free(nextnode);//释放删除节点的内存
    }
    

    3.查找节点

    查找链表中索引为 index 的元素,注意当 index 为 0 的时候返回的是头节点的下一个节点;

    Linked* GetByIndex(Linked *head,int index)
    {
        head=head->next;
    
        if(index==0)
        {
            return head;
        }
        else
        {
            while(index--)
            {
                head=head->next;
            }
            return head;//查找索引节点
        }	
        
    }
    

    4.插入节点

    在指定节点后面插入一个新节点,并赋值;

    void InsertAfter(Linked* node,int num,float sc)
    {
        Linked* newNode = (Linked*)malloc(sizeof(Linked));
        newNode->key=num;
        newNode->num=sc;
        newNode->next=node->next;
        node->next=newNode;
    }
    

    5.遍历节点

    逐个遍历:

    void PrintAll(Linked* head)
    {
       
        Linked* p=head->next;
    
        while(p)//当 p = NULL 的时候结束 
        {
            cout << p->key<<" "<<p->num<<endl;
            p=p->next;
        }
        
    }
    

    主程序:

    #include <iostream>
    using namespace std;
    
    
    struct Linked
    {
        /********* Begin *********/
        //结构体的成员变量
        int  key;
        float num;
        Linked* next;
    
        /********* End *********/
    };
    
    Linked* Create()
    {
        /********* Begin *********/
        //创建并返回一个新链表
    
        Linked* head = (Linked*)malloc(sizeof(Linked));
        head -> next = NULL;
        return head;
        
        
        /********* End *********/
    }
    
    void InsertAfter(Linked* node,int num,float sc)
    {
        /********* Begin *********/
        //在指定节点后插入一个新节点,内容由 num,sc 参数指定
        Linked* newNode = (Linked*)malloc(sizeof(Linked));
        newNode->key=num;
        newNode->num=sc;
        newNode->next=node->next;
        node->next=newNode;
        /********* End *********/
    }
    
    void DeleteAfter(Linked* node)
    {
    	/********* Begin *********/
        //删除此节点之后的一个节点
        
        Linked* nextnode=node->next; 
    	node -> next = nextnode -> next;
    	free(nextnode);
    	  
    	/********* End *********/
    }
    
    Linked* GetByIndex(Linked *head,int index)
    {
    	/********* Begin *********/
        //返回指定索引处的节点
        head=head->next;
    
        if(index==0)
        {
            return head;
        }
        else
        {
            while(index--)
            {
                head=head->next;
            }
            return head;
        }
    	/********* End *********/	
        
    }
    
    void PrintAll(Linked* head)
    {
       
        Linked* p=head->next;
    
        while(p)//当 p = NULL 的时候结束 
        {
            cout << p->key<<" "<<p->num<<endl;
            p=p->next;
        }
        
    }
    
    int main()
    {
    	int num;
    	float score;
    	cin >> num >> score ;
        Linked* lk = Create();//创建头节点 
        InsertAfter(lk,num,score);//插入第一组数据 
        
    	cin >> num >> score ;
        InsertAfter(GetByIndex(lk,0),num,score);//找到第一个节点,在第一个节点后插入节点 
        
    	cin >> num >> score ;
        InsertAfter(GetByIndex(lk,1),num,score);//找到第二个节点,在第一个节点后插入节点 
        
        DeleteAfter(GetByIndex(lk,0));//删除第二个节点 
        PrintAll(lk);//打印 
    }
    

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

    展开全文
  • * 将两个升序链表合并为一个新的升序链表并返回。 * 新链表是通过拼接给定的两个链表的所有节点组成的。 */ public class MergeTwoList { /** * 思路是新建一个带头节点的链表,然后根据比较两个节点的值得...
  • 将两个升序链表合并为一个新的升序链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。 链表的结构是: 链表可分为单向链表和双向链表一个单向链表包含两个值: 当前节点的值和一个指向下一个节点...
  • 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 代码: /** * Definition for singly-linked list. * public class ListNode { * int val;... * ListNode(in...
  • leetCode 21题 将两个升序链表合并为一个新的 升序 链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。 示例 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 迭代法 定义...
  • 将两个升序链表合并为一个新的升序链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 二,解决思路 1,定义一个...
  • 将两个有序链表合并为一个新的有序链表并返回新链表是通过拼接给定的两个链表的所有节点组成的 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 Java实现 /** * Definition...
  • 题目原文 题目:给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。示例:给定 1->2->3->4, 你应该返回 2->1->4->3. 可以用递归或者非递归...
  • 将两个有序链表合并为一个新的有序链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 /** * Definition for ...
  • 因为这道题花了自己的一些时间,所以... * 输入一个链表,反转链表后,输出新链表的表头。 * @author 18491 * */ public class ReverseList02 { public ListNode02 reverseList(ListNode02 head) { if(head...
  • 链表面试题3:将两个有序链表合并为一个新的有序链表并返回新链表是通过拼接给定的两个链表的所有节点组成 的。 首先我们的思想是将得一个链表和第二个链表的每个结点进行比较,谁小谁就插入到新链表的最后。 ...
  • 编写单链表类模板,实现链表创建,遍历,链表结点的插入,删除,查找,建立一个整数链表一个字符串链表。 IntList.h #include<iostream> using namespace std; template<typename T> class int...
  • 那么怎么通过data以及next创建一个链表呢? 万物皆有开端,所以我们首先需要创立一个头结点,head。 public static Node createLinkByHead(Scanner reader) { Node head=null; } 然后我们将键盘录入的数据...
  • 将两个有序链表合并为一个新的有序链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。 百度过一些解法后,希望记住的解法:递归。 因为是两个排序好的链表,所以,每次ListNode temp都是两者中较小的...
  • 链表创建链表

    千次阅读 2019-12-14 20:44:53
    首先:定义一个结构体. typedef struct node { int date; struct node *next; }list;...“list” 是给这个结构体起的别名,为了使用方便。...第二:创建一个链表. list *createlinklist() { list *p...
  • 解题思路: 1,先构造一个链表 2,定义一个栈,将链表元素放入到栈中 3,利用栈的先进后出,实现从尾到头返回 ...*输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。 * public class ListNode { * ...
  • //将两个有序链表并一个有序链表算法,该程序也可以cFree环境运行。 // c1.h (程序名) #include<string.h> #include<ctype.h> #include<malloc.h> // malloc()等 #include<limits.h> //...
  • 循环链表 循环链表就是最后一个结点的指针域指向头结点,整个链表形成一个环。 创建一个结点类: class Node(object): """创建一个结点类""" ...创建一个创建循环链表的类: 接下来的一些操作循环链表的...
  • 将两个有序链表合并为一个新的有序链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 思想: 从两个有序链表的第...
  • 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 1->2->3->5. 思路:用两个节点,删除让前一个节点比后一个节点先跑n次,然后两个一起跑。当前一个节点遍历结束...
  • 合并有序单循环链表,不重新申请存储空间; 创建有序单循环链表指向尾结点; 单循环链表的指针指向尾结点;
  • """将两个有序链表合并为一个新的有序链表并返回新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1->2->4, 1->3->4 输出:1->1->2->3->4->4 """ 链表结构: ...
  • 链表创建链表遍历

    千次阅读 2022-04-02 00:41:12
    链表创建链表遍历
  • 返回入环的第一个节点之前我们要判断是否成环,判断方法如下 判断了是否成环之后怎么找到成环的第一个节点呢,分析如下 代码 /** * Definition for singly-linked list. * struct ListNode { * int val; * ...
  • 给定一个链表,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环...
  • 将两个有序的链表合并为一个新链表,要求链表是通过拼接两个链表的节点来生成的,且合并后新链表依然有序。 比如{1,4} {3,5},合并就是{1,3,4,5}; 解题思路 首先我们要判定是否有一个链表为空,都为空,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 482,898
精华内容 193,159
关键字:

如何创建并返回一个新链表