精华内容
下载资源
问答
  • 将两个有序表合并为一个有序单链表 void combine(Node * f1,Node * f2,Node * f3,int n,int m) { //创建作为标记的结点,p指向有序表f1,q指向有序表f2,back指向新表f3 Node * p, * q, * back; p = f1...

    首先是Node结点的建立

    //建立结点 
    class Node
    { 
        public:
        Node(){
            next=NULL;data=0;
        }
        Node(int n){
            next=NULL;data=n;
        }
        int data;
        Node *next;
    };

    这道题需要三个函数实现相应功能

    打印

    void show(Node* first)
    {
        Node *p;
        p=first->next;
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            p=p->next; 
        }
        cout<<endl;
    }

    创建有序表

    void build(Node *front,int size)
    {
        Node *curr,*pre,*p;
        cout<<"please input the data: "<<endl;
        for(int i=0;i<size;i++)
        {
            int data;
            curr=front->next;
            //输入要插入的数字 
            cin>>data;
            //创建新结点 
            p=new Node(data);
            //pre永远在curr的前面,curr是每次遍历的开始 
            pre=front;
            //当前的结点,数字不大于插入目标时,将目标插在这个结点的前面 
            while(curr!=NULL&&curr->data<=data) 
            {
                pre=curr;
                curr=curr->next;
            }
            p->next=curr; 
            pre->next=p;
        }
        //打印这个创建的有序表 
        show(front);
    }

    将两个有序表合并为一个有序单链表

    void  combine(Node* f1,Node* f2,Node *f3,int n,int m)
    {
        //创建作为标记的结点,p指向有序表f1,q指向有序表f2,back指向新表f3 
        Node*p,*q,*back;
        p=f1->next;
        q=f2->next;
        back=f3->next;
        //如果两个有序表满足,一空一不空,则直接打印不空的那个 
        if (f1->next == NULL && f2->next != NULL)
        {
            cout<<"after combine:"<<endl;
            show(f2);
        }       
        else if(f2->next == NULL && f1->next != NULL)
        {
            cout<<"after combine:"<<endl;
            show(f1);   
        }
        //如果两有序表都空,输出blank      
        else if(f1->next==NULL && f2->next==NULL) cout<<"blank"<<endl;
        //两有序表均非空 
        else 
        {
            //比较两个有序表中的数字,先插小的,指针前进,继续比较取小的 
            int t=0;
            while(t<m+n)
            {
                while(p!=NULL && (q==NULL || p->data<=q->data))
                {
                Node *k=new Node(p->data);
                //问题:原来的写法因为k是创建的孤立结点,没有连上就用back指去
                //会造成back也脱离f3 
                //back=k;
                //back=k->next;
                //修改成如下,当f3空时,k就是第一个结点了,此后f3非空,将k插入到表尾 
                if(f3->next!=NULL)
                    back->next=k;
                else
                    f3->next=k;
                back=k;
                p=p->next;
                t++;
                }
                while(q!=NULL && (p==NULL || p->data>=q->data))
                {
                Node *k=new Node(q->data);
                //原理同上一条注释 
                //back=k;
                //back=k->next;
                if(f2->next!=NULL) 
                    back->next=k;
                else
                    f2->next=k;
                back=k;
                q=q->next;
                t++;
                }
            }
            cout<<endl<<"after combine:"<<endl;
            //打印合并得到的有序表f3 
            show(f3);       
        }
    }

    其实思路很容易有,编两个数字链表画画就能想明白,两个有序表,头节点为 f1和f2,用 p 标记 f1->next ,用 q 标记 f2->next ,创建一个节点 f3,它就是新链表的头节点,用 back 指向它,注意这里的 f1,f2,f3 ,都是其指向的next的指向为空,而不是它们为空,它们是有指向的。
    然后就是比较大小的问题,当两个有序表,一空一不空,则直接打印不空的那个,重点是都非空的两个。
    最外面一个while循坏,当插入次数不大于两个表的元素数量,里面两个while循环

    while(p!=NULL && (q==NULL || p->data<=q->data))
    while(q!=NULL && (p==NULL || p->data>=q->data))

    三个点:
    1. p!=NULL 和 q!=NULL,如果没有这两个条件就会两个while跳来跳去
    2. q==NULL 在 || 的前面一个,因为执行顺序,当为NULL时直接跳出这个while,如果是p->data<=q->data在 || 的前面,那q为NULL时就会报错,所以先判断
    3. 两个符号 <=、>=而不是<、>,有了这个等号避免不必要的在两个while里跳来跳去,相等时执行当前while里的语句

    ps:可能路过的大佬会有更简单快速的方法,敬请赐教~

    展开全文
  • 要求:随机创建两个单链表,实现单链表的排序,再对两个有序单链表进行合并。 ================================= 源代码 #include  using namespace std; template  class node {  public:  T...

    实现两个有序单链表的合并。要求:随机创建两个单链表,实现单链表的排序,再对两个有序单链表进行合并。

    =================================


    源代码

    #include <iostream>

    using namespace std;

    template <typename T>

    class node

    {

       public:

          T nodeValue;      // data held by the node

          node<T> *next;    // next node in the list

          node() : next(NULL) {};

          node(const T& item, node<T> *nextNode =  NULL) :  nodeValue(item), next(nextNode){};

    };

     

    #include "node.h"

    #define size 10        //宏定义size10

     

    #include<stdio.h>       //随机数

    #include<stdlib.h>

    #include<time.h>

    #define random(x) (rand()%x)

     

    node <int> *OrderList(node <int> *p,node <int> *&first);     //声明排序子函数,生成随机链表,排序后成为有序链表

    node <int> *merge(node <int> *p1,node <int> *p2);       //声明合并子函数,实现2个有序链表合并成一个新的有序链表

    void input(node <int> *p);                              //声明输出子函数,输出链表

     

    int main(int argc, char* argv[])

    {

    node <int> *p1=NULL;

    node <int> *first1=NULL;

    node <int> *p2=NULL;

    node <int> *first2=NULL;

    node <int> *p3=NULL;

     

    srand(time(0));

    cout<<"第一个有序单链表:"<<endl;

    p1=OrderList(p1,first1);                   

    cout<<"第二个有序单链表:"<<endl;

    p2=OrderList(p2,first2);

    cout<<"合并两个有序链表:"<<endl;

    p3=merge(p1,p2);

    input(p3);

    cout<<endl;

    return 0;

    }

     

    node <int> *OrderList(node <int> *p,node <int> *&first){

    void InsertSort(node <int> *pre,node <int> *curr,node <int> *p,node <int> *&first);//声明插入排序子函数,链表插入排序,实现递增

    int x;

    node <int> *pre=NULL;     //声明前驱指针,指向当前节点前一个节点

    node <int> *curr=NULL;    //声明当前指针,指向当前所指向的节点

    x=random(100);

        first=new node <int> (x);     //生成第一个节点

    InsertSort(pre,curr,p,first);   //链表进行插入递增排序,调用插入排序子函数

    p=first;   

    input(p);    //输出有序链表

    p=first;

    return p;         

    }

     

    void InsertSort(node <int> *pre,node <int> *curr,node <int> *p,node <int> *&first){   //插入排序子函数

    int x;

    for(int i=2;i<=size;i++){

    p=NULL;      //p指针为插入指针,每次生成一个节点,与链表中各个节点比较,然后插入链表

    curr=first;    //当前指针初始化,为每次遍历比较作准备

    pre=first;     //前驱指针初始化,为每次遍历比较作准备

    x=random(100);

    p=new node <int> (x);    //生成一个新节点,p->next=NULL

    if((p->nodeValue) <= (first->nodeValue)){    //新插入的节点需要和头节点比较

    p->next=first;    //比头节点小,插在头结点之前

    first=p;          //插入节点变成头节点

    }else{

    while(1){   //循环遍历来比较已生成的链表

    if((p->nodeValue>= curr->nodeValue) && (curr->next==NULL)){ //当前节点是链表最后节点

    curr->next=p;                                           //并且新插入节点也比当前节点大,插入链表最后

    break;       //结束循环

    }else if((p->nodeValue >= pre->nodeValue) &&   //插入节点比前驱节点大,比当前节点小

    (p->nodeValue <= curr->nodeValue)){

    p->next=pre->next;   //新插入节点插入前驱节点后,即当前节点之前

    pre->next=p;         

    break;      

    }

    pre=curr;    //前驱指针和当前指针交替前进

    curr=curr->next;

    }

    }

    }

    }

     

    node <int> * merge(node <int> *p1,node <int> *p2){   //实现2个有序链表合并成一个新的有序链表

        node <int> *p3=NULL;     //

        if(p1 == NULL){          //若第一个链表全部合并完,即p1已经指向链表最后

            return (p2);         //返回p2,即直接输出p2此时指向节点,遍历输出第二个链表余下部分

    }

    else if(p2 == NULL){

            return (p1);  

    }

        if(p1->nodeValue <= p2->nodeValue)  //判断p1指向节点值小于p2指向节点值

        {  

            p3 = new node <int> (p1->nodeValue);   //p3生成一个节点,节点值为此时p1所指向节点值

            p3->next = merge(p1->next, p2);        //p3后继为p1->nextp2,需要递归判断

        }  

        else  

        {  

            p3 = new node <int> (p2->nodeValue);  

            p3->next = merge(p1, p2->next);  

        }  

        return (p3);       //返回p3 

     

    void input(node <int> *p){

    while (p!=NULL){        //输出链表

    cout<<p->nodeValue<<" ";

    p=p->next;

    }

    cout<<endl<<endl;

    }


     

    宏定义size10

    生成p1,first1指针来指向第一条链表,将p1,first1作为实参传给OrderList子函数,在OrderList子函数中,首先声明插入排序子函数,链表插入排序,实现递增。在OrderList函数中声明前驱指针,指向当前节点前一个节点声明当前指针,指向当前所指向的节点。之后随即生成头节点,first指向链表第一个节点。调用InsertSort子函数进行插入排序,将pre,curr,p,first这4个指针作为实参传递过去。然后将p指向头指针,调用输出函数输出有序链表。第二条链表同理可得,不予累述。

    在插入排序子函数InsertSort()中,一开始利用for循环循环size-1次,插入size-1个节点。循环中随即生成插入节点,而p指针为插入指针,每次生成一个节点,与链表中各个节点比较,然后插入链表,当前指针curr和前驱指针pre初始化指向头指针,为每次遍历比较作准备。一开始if判断与头节点相比较,小于头节点,p->next指向头指针,p变成头指针first。之后进入while(1)循环遍历链表让插入指针p所指向节点值与各个进行节点比较。若当前节点是链表最后节点,并且新插入节点也比当前节点大,插入链表最后,curr->next=p,

    break结束循环,或者插入节点比前驱节点大,比当前节点小,新插入节点插入前驱节点后,即当前节点之前(p->next=pre->next; pre->next=p;),之后结束循环。而在while(1)循环中前驱指针pre和当前指针curr交替前进,以此实现在链表中间插入节点。

    将传递回来的2个指针p1p2(已经指向各自链表头结点),p3=merge(p1,p2),作为实参传递给merge子函数,在merge函数中node <int> *p3=NULL,生成一个指向合并新链表的指针p3。一开始if(p1 == NULL){ return (p2); }else if(p2 == NULL){return (p1); }通过这个if-else来判断若其中一个链表全部归并给新链表,则直接返回另一个指针,在主函数按顺序输出(这2个是有序链表,所以顺序输出也是递增的)。之后的if-else来判断当p1指向节点值小于p2指向节点值,则p3生成一个节点,节点值为此时p1所指向节点值,p3后继为p1->nextp2,需要递归该merge函数进行判断。当p2指向节点值小于p1指向节点值情况同理,不予累述。之后返回指针p3,也就是在这个函数中,当p1p2一开始比较是,新链表一生成一个节点,就返回此时p3,在主函数调用input(p3)函数输出,利用正向递归,p3->next一直指下去,一直输出每一个节点,直到其中p1p2分别指向的链表其中之一先全部归并给新链表,则立刻返回另一个指针p,在主函数调用输出函数输出这个指针指向节点开始之后的节点值。

    展开全文
  • C语言:有序单链表创建

    千次阅读 2018-12-16 16:59:01
    如何创建一个带头结点的有序单链表? 链表在创建的时候就把它创建成有序的会显得专业许多(雾), 而不是先创建无序链表再排序; 拿一道典型例题举个栗子,相信你们都见过这道题; Problem Description 输入N个...

    如何创建一个带头结点的有序的单链表?

    链表在创建的时候就把它创建成有序的会显得专业许多(雾),
    而不是先创建无序链表再排序;
    拿一道典型例题举个栗子,相信你们都见过这道题;

    Problem Description
    输入N个无序的整数,建立一个有序链表,链表中的结点按照数值非降序排列,输出该有序链表。
    Input
    第一行输入整数个数N;
    第二行输入N个无序的整数。
    Output
    依次输出有序链表的结点值。
    Sample Input
    6
    33 6 22 9 44 5
    Sample Output
    5 6 9 22 33 44
    Hint
    不得使用数组!

    那么思路是什么呢?
    我们可以再输入新的结点时逐个进行查找与插入操作,这样建立的就是有序的链表啦

    #include<stdio.h>
    struct node
    {
     int data;
     struct node * next;
    };
    struct node * sort(struct node * p,int x)
    {
     struct node *ph,*pte,*paf;
     ph=p;
     pte = (struct node *)malloc(sizeof(struct node));
     pte->data = x;pte->next = NULL;
     while (p->next)
     {
      paf = p->next;
      if (paf->data >= x)
      {
       pte->next = p->next;
       p->next = pte;
       return ph;
      }
      p = p->next;
     }
     pte->next = p->next;
     p->next = pte;
     return ph;
     //while外表示的是创建第一个结点和最后一个结点时的情况
     //大小排序为p<pte<=paf
    }
    void list(struct node *p)
    {
     p = p->next;
     while (p)
     {
      printf("%d ", p->data);
      p = p->next;
     }
    }
    int main()
    {
     struct node *ph;
     ph = (struct node *)malloc(sizeof(struct node));
     ph->next = NULL;
     int n, i, x;
     scanf("%d", &n);
     for (i = 0;i < n;i++)
     {
      scanf("%d", &x);
      ph = sort(ph, x);
     }
     list(ph);
     getchar();
     getchar();
     return 0;
    }
    

    鸣谢这位V家厨(https://www.cnblogs.com/luoxiaoyi/p/9726720.html)

    展开全文
  • 两个有序单链表合成为一个有序单链表,自己写的代码运行出错, 弄了很久都没解决,是我的思路错了,还是代码细节出问题了?求大神帮忙 编译通过,但是运行是直接提示exe停止运行 ``` #include #include ...
  • 实现两个有序单链表的合并。要求:随机创建两个单链表,实现单链表的排序,再对两个有序单链表进行合并。
  • 将两个单链表合并成一个有序单链表 思路:因为链表可以由结点轻松构造,所以首先需要创建单链表的元素,然后选择构造方式构造单链表,本代码为后插构造单链表。然后有了链表,怎么合并为一个有序单链表。大体可以先...

    3.10
    4.将两个单链表合并成一个有序单链表

    由于以前初学c++时所写的代码不堪入目,不符合规范性,完整性和鲁棒性,于是今日重写其核心算法以警示自己。

    Node* Merge(Node p1Head, Node p2Head)
    {
    	if(p1Head == nullptr)
    		return p2Head;
    	if(p2Head == nullptr)
    		return p1Head;
    	
    	Node* pMergedHead=nullptr;
    	
    	if(p1Head->info<p2Head->info)
    	{
    		pMergedHead=p1Head;
    		pMergedHead->next=Merge(p1Head->next,p2Head);
    	}
    	else
    	{
    		pMergedHead=p2Head;
    		pMergedHead->next=Merge(p1Head,p2Head->next)
    	}
    	return pMergedHead;
    }
    

    思路:因为链表可以由结点轻松构造,所以首先需要创建单链表的元素,然后选择构造方式构造单链表,本代码为后插构造单链表。然后有了链表,怎么合并为一个有序单链表。大体可以先尝试排序构造的每个单链表,然后再在合并的时候进行有序比较排列即可。

    #include<stdlib.h>
    #include<stdio.h>
    #include<iostream>
    typedef struct Node {
     
     int info;
    
     struct Node *next;
    
    }*List;
    void creatList(List *head,int n) {
    
     int i;
    
     List p,q;
    
     *head = (List)malloc(sizeof(struct Node));
    
     (*head)->next = NULL;
    
     q = *head;
    
     for ( i = 0; i < n; i++)
    
     {
    
      p = (List)malloc(sizeof(struct
    Node));
    
      cin >> p->info;
    
      p->next = q->next;
    
      q->next = p;
    
      p = q;
    
     }
    
    }
    int List_length(List a);
    
    void maopaosort(List p) {
    
     List la, lb;
    
     int n = List_length(p);
    
     int i, j,temp;
    
     for ( i = 0,la=p->next; i < n;
    i++,la=la->next)
    
     {
    
      for ( j = i+1,lb=la->next; j
    < n; j++,lb=lb->next)
    
      {
    
       if
    (la->info>lb->info)
    
       {
    
        temp
    = la->info;
    
        la->info
    = lb->info;
    
        lb->info
    = temp;
    
       }
    
      }
    
     }
    
    }
    int List_length(List a) {
    
     int i=0;
    
     List p;
    
     p = a->next;
    
     while (p != NULL)
    
     {
    
      ++i;
    
      p = p->next;
    
     }
    
     return i;
    
    }
    void outputlist(List head) {
    
     List p;
    
     p = head->next;
    
     while (p!=NULL)
    
     {
    
      cout << p->info
    << " ";
    
      p=p->next;
    
     }
    
    }
    void merge(List l1, List l2, List *l3) {
    
     List p1,p2, p3;
    
     *l3 = l1;
    
     p1 = l1->next;
    
     p2 = l2->next;
    
     p3 = *l3;
    
     while (p1!=NULL&&p2!=NULL)
    
     {
    
      if (p1->info >
    p2->info) {
    
       p3->next=
    p2;
    
       p2 =
    p2->next;
    
       p3 =
    p3->next;
    
      }
    
      else
    
      {
    
       p3->next =
    p1;
    
       p1 =
    p1->next;
    
       p3 =
    p3->next;
    
      }
    
    }  
    
     if (p1 != NULL) {
    
      p3->next= p1;
    
     }
    
     else
    
     {
    
      p3->next= p2;
    
     }
    
    }
    int main() {
    
     List a, b, c;
    
     creatList(&a, 5);
    
     maopaosort(a);
    
     //outputlist(a);
    
     creatList(&b, 4);;
    
     maopaosort(b);
    
     //outputlist(b);
    
     merge(a, b, &c);
    
     //cout << endl;
    
     outputlist(c);
    
    }
    
    展开全文
  • /*链表*/ #include typedef struct node {  int data; ... struct node *next;.../*后插法创建单链表*/ void hou_create(Listlink *head,int n) {  int i;  Listlink p,q;  *head=(Listlin
  • 这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何...在有序单链表L中插入数值x,仍然有序。(输入单链表数值时需要从小到大输入) 欢迎使用Markdown编辑器 #include
  • #include&lt;stdlib.h&gt; #include &lt;stdio.h&gt; typedef struct LNode{  int data;  struct LNode* next;...L,int a[],int n)//链表的创建 {  List *p1,*p2;  L=(List*)...
  • } } void merge(linklist &LA,linklist &LB,linklist &LC)//算法2.16 链式有序表的合并 { //已知单链表LA和LB的元素按值非递减排列 //归并LA和LB得到新的单链表LC,LC的元素也按值非递减排列 lnode *pa,*pb,*pc;...
  • 单链表的基本操作 包括 :链表的创建(头插法,尾插法),链表的遍历,两个单调递增的链表合并为一个单调递增的链表,两个单调递增的链表合并为一个单调递减的链表   #include #include using namespace std;...
  • 将两个有序单链表进行合并,合并结果仍有序。(合并过程不占用其他存储空间) #include<stdio.h> #include<stdlib.h> #define MAXSIZE 10010 #define ElemType int typedef struct LNode{ ElemType ...
  • 已知两个已排序链表头节点指针headA与headB,将这两个链表合并,合并后仍为 有序的,返回合并后的头节点。 主要步骤如下: 创建一个临时的头节点,头节点每次指向headA 或者 headB较小的节点 当headA->data 比...
  • 带头单链表的创建、打印和释放见博客 一:单链表的创建、打印和释放 1. 递归方式实现 思路:如果两个结点... * 递归实现两个有序单链表的合并 * @param[in] pNode1 NODE_t * :单链表的第一个有效结点 * @pa...
  • 6-2 带头结点的有序单链表插入及删除 (15 分) 请编写函数实现在带头结点的单链表中进行有序插入和删除操作。 程序运行时,第一行输入元素个数,第二行依次输入各个待插入元素值,第三行输出创建的有序链表中各元素...
  • Codeup问题 F: 算法2-25 有序单链表删除重复元素 题目地址 这里是一只想转计算机专业的大一自学菜鸡,看其他大佬好像都是创建链表和删除重复元素分别写一个函数。对算法复杂度还不太了解,希望有大佬看到能指出我...
  • //单链表的逆置 LinkList transpose(LinkList head){  LinkList q,p,r,s;  if(head==NULL||head->next==NULL){  return NULL;  }  s=head->next;  r=s->next;  p=s->next;  while(r){ ...
  • #include "stdafx.h" #include "malloc.h" typedef struct Node { char data;...// 创建单链表 void CreateList(List *&L, char a[], int n) { List *s,*r; L = (List *)malloc(...
  • 合并有序单链表(递归实现)

    千次阅读 2010-05-24 21:22:00
    此处大多数代码参考另一篇博文《动态单向链表的创建》,用以创建测试用的单链表。#include using namespace std; struct Node { int data; Node *next; }; Node *createList (Node *head) { struct Node *p, *s; ...
  • 关于单链表以及搜集的一些面试题关于单链表的面试题 链表是以节点的方式来存储 每个节点都包含一个data域和next域,data域用来存放数据,next域用来指向下一个节点 链表的各个节点不一定是连续存储的 先来看普通...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 314
精华内容 125
关键字:

创建有序单链表