1222: 基于链表的两个非递减有序序列的合并

问题：

给定两个非递减的整数序列A和B，利用链表表示序列A和B，将A和B合并为一个非递增的有序序列C，序列C允许有重复的数据。要求空间复杂度为O(1)。

输入
多组数据，每组数据有三行，第一行为序列A和B的长度n和m，第二行为序列A的n个元素，第三行为序列B的m个元素（元素之间用空格分隔）。n=0且m=0时输入结束。

输出
对于每组数据输出一行，为合并后的序列，每个数据之间用空格分隔。

测试样例：

输入
5 5
1 3 5 7 9
2 4 6 8 10
5 6
1 2 2 3 5
2 4 6 8 10 12
0 0
输出
10 9 8 7 6 5 4 3 2 1
12 10 8 6 5 4 3 2 2 2 1 

注意，要求显示 空间复杂度为O(1)，意味着一定情况下牺牲时间复杂度

而接下来的代码，最差时间复杂度为O(n2),但空间复杂度O(1)

运行结果相对不错！

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct SNode *Stack;
struct SNode{
	int data;
	struct SNode *next;
};

Stack read(int n);
void com_fin(int m, Stack S);
void push(int num, Stack S);
Stack find_push(int num, Stack S);
void fn_push(int num, Stack S);

int pop(Stack S);
bool isEmpty(Stack S);
void print_result(Stack S);

int main()
{
	int n, m;
	Stack PtrL1, PtrL2;
// 利用scanf的返回值，来实现循环条件，输入两个数，且不为零
	while(scanf("%d%d", &n, &m) == 2 && (n || m)){
		PtrL1 = read(n);
		PtrL2 = find_push(m, PtrL1);
		print_result(PtrL2);
	}
	return 0;
}

Stack read(int n)
{
	Stack PtrL;
	PtrL = (Stack)malloc(sizeof(struct SNode));
	PtrL ->next = NULL;
	int num;
	while(n--){
		scanf("%d", &num);
		push(num, PtrL);

	}
	return PtrL;
}
void push(int num, Stack S)
{
	Stack new_s;
	new_s = (Stack)malloc(sizeof(struct SNode));
	new_s ->data = num;
	new_s ->next = S ->next;
	S ->next = new_s;
}
bool isEmpty(Stack S)
{
	if(S ->next == NULL){
		return true;
	}else{
		return false;
	}
}
Stack find_push(int num, Stack S)
{
	int n_t;
	if(isEmpty(S)){
		free(S);
		return (read(num));
	}
	while(num--){
		scanf("%d", &n_t);
		fn_push(n_t, S);              
	}
	return S;
}
void fn_push(int num, Stack S)
{
	Stack f_s;
	bool flag = false;
	f_s = S;
	while(!isEmpty(f_s)){
		if(num >= f_s ->next ->data){
			if(flag == true){
				break;
			}
			push(num, f_s);
			flag = true;
		}else{
			f_s = f_s ->next;
		}
	}
	if(flag == false){
		push(num, f_s);
	}
	return ;
}
int pop(Stack S)
{
	Stack p_s;
	int top;
	if(isEmpty(S)){
		printf("error 1 exit!");
		return -1;
	}else{
		p_s = S ->next;
		S ->next = p_s ->next;
		top = p_s ->data;
		free(p_s);
		return top;
	}
}
void print_result(Stack S)
{
	int n;
	if (isEmpty(S))
		printf("^v^!!!, error, <error 2>");
	while(!isEmpty(S)){
		n = pop(S);
		printf("%d ", n);
	}
	printf("\n");
}

这是第二个方法，链表输入，栈输出问题,空间O(1)

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
 
/*
这很明确为一个简单的，链表输入，栈输出问题！
*/
typedef struct Llist *List;
typedef struct Llist *Stack;
struct Llist{
	int data;
	struct Llist *next;
};
 
List readL(int num);
void attach(int num, List* rear);
List crt_pare(List a, List b);
void push_stack(int data, Stack S);
int pop_stack(Stack S);
int compare(int a, int b);
void print_result(List P);
void free_link(List *PtrL);
 
int main()
{
	int n, m;
	while(scanf("%d%d", &n, &m) == 2 && (n || m)){
		
		List PtrL1, PtrL2;
		Stack PtrL3;
		PtrL1 = readL(n);
        PtrL2 = readL(m);
		if(!PtrL1 && !PtrL2){
			printf("error 1 not read !");
			break;
		}
		PtrL3 = crt_pare(PtrL1, PtrL2);
		print_result(PtrL3);
		free_link(&PtrL3);
	}
	return 0;
}
List readL(int num)
{
	List ptrL, rearL, temp;
	int r_n;
	
	ptrL = (List)malloc(sizeof(struct Llist));
	ptrL ->next = NULL;
	rearL = ptrL;
	for(int i = num; i > 0; i--){
		scanf("%d", &r_n);
		attach(r_n, &rearL);
	}
	temp = ptrL;
	ptrL = ptrL->next;
	free(temp);
	return ptrL;
}
List crt_pare(List a, List b)
{
	List c_1, c_2;
	Stack c_3, c_temp;
	int a_flag = 0, b_flag = 0;
	int c1, c2;
	Stack PtrL;
	c_1 = a; c_2 = b;
	if(c_1 == NULL)
	{
		c_1 = (List)malloc(sizeof(struct Llist));
		c_1 ->data = INT_MAX;
		c1 = 1;
	}
	if(c_2 == NULL)
	{
		c_2 = (List)malloc(sizeof(struct Llist));
		c_2 ->data = INT_MAX;
		c2 = 1;
	}
	c_3 = (Stack)malloc(sizeof(struct Llist));
	c_3 ->next = NULL;
	PtrL = c_3;
	while(1){
		if(c_1 ->next == NULL){
			a_flag = 1;
		}
		if(c_2 ->next == NULL){
			b_flag = 1;
		}			
		switch(compare(c_1 ->data, c_2 ->data)){
			case 1: push_stack(c_2 ->data, PtrL);
					if(b_flag == 0){
						c_2 = c_2 ->next;
					}else{
						c_2 ->data = INT_MAX;
					}	
					break;
					
			case 0: push_stack(c_1 ->data, PtrL);
					if(a_flag == 0){
						c_1 = c_1 ->next;
					}else{
						c_1 ->data = INT_MAX;
					}
					break;
		}
		if(c_1 ->data == INT_MAX && c_2 ->data == INT_MAX){
			break;
		}
	}
	if(c1 == 1){
		free(c_1);
	}
	if(c2 == 1){
		free(c_2);
	}
	return c_3;
}
void attach(int num, List* prear){
	List PtrL;
	PtrL = (List)malloc(sizeof(struct Llist));
	PtrL ->next = NULL;
	PtrL ->data = num;
	(*prear) ->next = PtrL;
	*prear = PtrL;
}
int compare(int a, int b)
{
	if(a >= b)
		return 1;
	else
		return 0;
}
void print_result(Stack P)
{
	int n;
	if (!P)
		printf("^v^!!!, error, <..>");
	while(P ->next){
		n = pop_stack(P);
		printf("%d ",n);
	}
	printf("\n");
}
 
void push_stack(int data, Stack S)
{
	Stack new_s;
	new_s = (Stack)malloc(sizeof(struct Llist));
	new_s ->data = data;
	new_s ->next = S ->next;
	S ->next = new_s;
}
int pop_stack(Stack S)
{
	Stack p_s;
	int top;
	if(S ->next == NULL){
		printf("已经全部输出了\n");
		return -1;
	}else{
		p_s = S ->next;
		S ->next = p_s ->next;
		top = p_s ->data;
		free(p_s);
		return top;
	}
}
void free_link(List *PtrL)
{
	List temp;
	if(!(*PtrL)){
		return ;
	}
	while(*PtrL){
		temp = *PtrL;
		(*PtrL) = (*PtrL) ->next;
		free(temp);
	}
}