将两个有序链表和为另外一个链表,并保证有序

直接递归

代码:

#include <iostream>
#include <stack>
using namespace std;

 typedef struct listNode{
	int key;
	struct	listNode *pNext;
 } * pNode,Node;

void createNode(pNode &pHead){
		bool isFirst=true;
		int temp;
		scanf("%d",&temp);
		pNode p=pHead,q;
		while(temp!=0){
			q=(pNode)malloc(sizeof(Node));
			q->key=temp;
			q->pNext=NULL;
			if(isFirst){
				p=pHead=q;
				isFirst=false;
			}else{
				p->pNext=q;
				p=q;
			}

			scanf("%d",&temp);
		}
		cout<<"原链表是:"<<endl;
		p=pHead;
		while(p){
			cout<<p->key<<" ";
			p=p->pNext;
		}
}
void print(const pNode merge){
	pNode p=merge;
	while(p){
		cout<<p->key<<" ";
		p=p->pNext;
	}
}
pNode merge(const pNode pHead1,const pNode pHead2){

	if(pHead1==NULL)
		return pHead2;
	else if(pHead2==NULL)
		return pHead1;
	pNode pMerge=NULL;
	if(pHead1->key > pHead2->key){
		pMerge = pHead2;
    	pMerge->pNext = merge(pHead1,pHead2->pNext);
	}else{
		pMerge=pHead1;
		pMerge->pNext=merge(pHead1->pNext,pHead2);
	}

	return pMerge;
}
void printListReverse(const pNode pHead){
	if(pHead==NULL)
		return;
	printListReverse(pHead->pNext);
	cout<<pHead->key;

}

int main(){
	pNode pHead1=NULL;
	pNode pHead2=NULL;

	createNode(pHead1);
	createNode(pHead2);
	pNode merge1 = merge(pHead1,pHead2);
	print(merge1);
	return 0;

}

运行结果:

将两个有序链表和为另外一个链表,并保证有序,布布扣,bubuko.com

时间: 2024-10-13 17:57:28

将两个有序链表和为另外一个链表,并保证有序的相关文章

链表的艺术——Linux内核链表分析

引言: 链表是数据结构中的重要成员之中的一个.因为其结构简单且动态插入.删除节点用时少的长处,链表在开发中的应用场景许多.仅次于数组(越简单应用越广). 可是.正如其长处一样,链表的缺点也是显而易见的.这里当然不是指随机存取那些东西,而是因为链表的构造方法(在一个结构体中套入其同类型指针)使得链表本身的逻辑操作(如添加结点,删除结点,查询结点等),往往与其应用场景中的业务数据相互混杂.这导致我们每次使用链表都要进行手工打造,做过链表的人肯定对此深有了解. 是否能将链表从变换莫測的业务数据中抽象出

颠倒一个链表的顺序 C++

首先我们定义一个头结点: struct Node{ int data; Node*next; }; 接下来我们写一个函数来创建一个链表: //a是一个数组,n代表数组元素的个数 Node*createLinkList(int a[],int n) { if(a==NULL||n==0) return NULL; Node*L,*T=NULL; for(int i=0;i<n;i++) { if(i==0) {L=new Node; L->data=a[i]; L->next=NULL;

合并两个有序的单链表,合并之后的链表依然有序【出现频率高】

合并两个有序的单链表,合并之后的链表依然有序: 这道题经常被各公司考察. 例如: 链表1:   1->2->3->4 链表2:   2->3->4->5 合并后:   1->2->2->3->3->4->4->5 解题思路:   挨着比较链表1和链表2.   这个类似于归并排序.尤其要注意两个链表都为空.和其中一个为空的情况.只需要O (1) 的空间.时间复杂度为O (max(len1,len2)) public Node me

链表(三)——链表删除冗余结点&amp;amp;插入结点到有序链表

1.一个以递增方式排列的链表,去掉链表中的冗余值. 思路一:设有两个指针p和q.使p不动,q依次往后循环直到p->data不等于q->data,再将中间的冗余数据删除. 思路二:设有两个指针p和q,使p在前,q在后,仅仅要找到一个冗余就删除一个,依次往后删除. 输入的链表:1 3 3 3 3 6 6 8 9 10 删除后的链表:1 3 6 8 9 10 比較两种思路.思路二的想法相比于思路一要好.所以这里实现思路二的代码. 2.将一个结点插入到一个有序的链表中. 思路:首先要判定这个链表是递增

将两个无序链表合成一个链表

对于链表,可以先将两个链表排序,然后再将其枚举合成一个链表. 或者是先将一个链表接到另一个链表的尾部,然后将总链表排序. 1 #include <bits/stdc++.h> 2 #include <iostream> 3 #include <cstring> 4 #include <cstdio> 5 #include <malloc.h> 6 using namespace std; 7 struct Node{ 8 int date; 9

用两种递归思路与循环实现单链表的反转

typedef struct ListNode{ int data; struct ListNode *next; }ListNode; //递归一 ListNode *ReverseList (ListNode *pHead, ListNode *nHead = NULL) { //每次取下第一个节点头插法创建新链表 //nHead为反转后链表的头节点 if(pHead == NULL) return NULL; ListNode *pNext = pHead -> next; pHead -

反转一个链表的两种方法:递归和循环

下面是反转一个链表的两种方法: 一.循环算法 //反转一个链表,循环算法 LinkList Reverse(LinkList& head) { // if(!head) // return head; //此时不用判断head是否为空,如是空的话返回的也是空 LinkList cur = head; LinkList hou; LinkList beh = 0; while (cur) { hou = cur->next; cur->next = beh; beh = cur; cur

链表习题(4)-有一个带头结点的单链表,编写算法使其元素递增有序

1 /*有一个带头结点的单链表,编写算法使其元素递增有序*/ 2 /* 3 算法思想:利用直接插入排序的思想,先构成只含有一个数据结点的有序单链表,然后依次插入 4 剩余结点到合适的位置. 5 */ 6 void Sort(LinkList& L) 7 { 8 LNode *p = L->next, *pre; 9 LNode *r = p->next; 10 p->next = NULL; 11 while (p) 12 { 13 r = p->next; 14 pre

java 数据结构 图中使用的一些常用算法 图的存储结构 邻接矩阵:图的邻接矩阵存储方式是用两个数组来标示图。一个一位数组存储图顶点的信息,一个二维数组(称为邻接矩阵)存储图中边或者弧的信息。 设图G有n个顶点,则邻接矩阵是一个n*n的方阵,定义为: 实例如下,左图是一个无向图。右图是邻接矩阵表示:

以下内容主要来自大话数据结构之中,部分内容参考互联网中其他前辈的博客. 图的定义 图是由顶点的有穷非空集合和顶点之间边的集合组成,通过表示为G(V,E),其中,G标示一个图,V是图G中顶点的集合,E是图G中边的集合. 无边图:若顶点Vi到Vj之间的边没有方向,则称这条边为无项边(Edge),用序偶对(Vi,Vj)标示. 对于下图无向图G1来说,G1=(V1, {E1}),其中顶点集合V1={A,B,C,D}:边集合E1={(A,B),(B,C),(C,D),(D,A),(A,C)}: 有向图:若