数据结构05

0501

创建并打印带有头结点的整数链表。
输入要求：
多组输入。
每组数据输入一个整数n（n>=0)，代表元素个数，接下来输入n个整数
输出要求：
打印链表中的数据元素，每个整数后一个空格，打印结束后换行。
空表输出一个空行。
数据示例1：
输入：
6 
1 3 5 6 2 4
3
1 2 3
输出：
1 3 5 6 2 4 
1 2 3 

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

typedef struct LNode{
    int   data;       //数据域
    struct LNode  *next;   //指针域
}LNode,*LinkList;   


void createList(LinkList &L, int n); // 创建n个结点的链表 

void printList(LinkList L); // 打印链表 

int main(){
	int n;
	while(~scanf("%d", &n)){
		LinkList L;
		createList(L, n);
		printList(L);
	}
	return 0;
}
/
void createList(LinkList &L, int n) // 创建n个结点的链表 
{
	L=new LNode;
	L->next=NULL;
	LNode *r=L;//始终指向最后一个结点 
	for(int i=0;i<n;i++)
	{
		LinkList p=new LNode;//创建一个新的结点 
		scanf("%d",&p->data);
		p->next=NULL;//给next域赋值 
		r->next=p;//将p链接到r的后面 
		r=r->next;
	}
}
void printList(LinkList L) // 打印链表 
{
	LNode *p=L->next;
	while(p!=NULL){
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}

0502

根据序号和值在带有头结点整数链表中进行查找
输入要求：
首先输入一个整数n（n>=0)，代表元素个数，接下来输入n个整数
然后，循环输入由一个整数表示的操作命令，其中
0 代表打印链表
1 代表根据序号查找，接下来输入一个代表序号的整数
2 代表根据值查找，接下来输入要查找的值
输出要求：
根据输入的命令进行输出
0：打印链表中的数据元素，每个整数后一个空格，打印结束后换行。
1或2：查找成功输出元素的值，失败输出”Not Found“
数据示例1：
输入：
5
2 4 6 8 10
0
1 1
1 0
2 3
2 6
输出：
2 4 6 8 10 
2
Not Found
Not Found
6

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

typedef struct LNode{
    int   data;       //数据域
    struct LNode  *next;   //指针域
}LNode,*LinkList;   


void createList(LinkList &L, int n); // 创建n个结点的链表 

void printList(LinkList L); // 打印链表 

// 根据序号查找 
// 返回序号为i（序号从1开始）的结点的地址，找不到返回NULL 
LNode* findI(LinkList L, int i); 

// 根据值查找
// 返回值为e的第一个节结点的地址，找不到返回NULL 
LNode* findV(LinkList L, int e);

int main(){
 LinkList L;
 int cmd, e, n, i;
 LNode *p;
 scanf("%d", &n);
 createList(L, n); 
 while (scanf("%d", &cmd) != EOF )  { // 选择操作 
  switch (cmd) {
  case 0:
   printList(L);
   break;
  case 1: // 根据序号查找 
   scanf("%d", &i);
   p = findI(L, i);
   if ( p!=NULL) printf("%d\n", p->data);
   else printf("Not Found\n");
   break; 
    
  case 2: // 根据值查找 
   scanf("%d", &e);
   p = findV(L, e);
   if ( p!=NULL) printf("%d\n", p->data);
   else printf("Not Found\n");
   break; 
   
  default:
   printf("Unknow Command.\n");
   break;
  }
 }
 return 0;
}
void createList(LinkList &L, int n) // 创建n个结点的链表 
{
	L=new LNode;
	L->next=NULL;
	LNode *r=L;
	for(int i=0;i<n;i++)
	{
		LNode *p=new LNode;
		scanf("%d",&p->data);
		p->next=NULL;
		r->next=p;
		r=r->next;
	}
}

void printList(LinkList L) // 打印链表 
{
	LNode *p=L->next;
	while(p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}
// 根据序号查找 
// 返回序号为i（序号从1开始）的结点的地址，找不到返回NULL 
LNode* findI(LinkList L, int i){
	LNode *p=new LNode;
	p=L->next;
	int j=1;
	while(p)
	{
		if(i==j){
			return p;
		}
		p=p->next;
		j++;
	}
	return NULL;
}
// 根据值查找
// 返回值为e的第一个节结点的地址，找不到返回NULL 
LNode* findV(LinkList L, int e){
	LNode *p=L->next;
	while(p){
		if(p->data==e){
			return p;
		}
		p=p->next;
	}
	return NULL;
}

0503

*根据序号和值在带有头结点整数链表中查找前驱结点
提示：
指针p所指结点的后继结点为p->next
指针p所指结点的后继结点的数据域为p->next->data
位置1的前驱结点为头结点
长度为n的链表，位置n+1的前驱结点为第n个结点（尾结点）
输入要求：
首先输入一个整数n（n>=0)，代表元素个数，接下来输入n个整数
然后，循环输入由一个整数表示的操作命令，其中
0 代表打印链表
3 代表根据序号查找前驱，接下来输入一个代表序号的整数
4 代表根据值查找前驱，接下来输入要查找的值
输出要求：
根据输入的命令进行输出
0：打印链表中的数据元素，每个整数后一个空格，打印结束后换行。
3或4：查找成功输出前驱元素的值（头结点的值用”Unknown“表示），失败输出”Not Found“
数据示例1：
输入：
5
2 4 6 8 0
3 1
3 5
3 0
3 6
3 7
4 2
4 1
4 0
0
输出：
Unknown
8
Not Found
0
Not Found
Unknown
Not Found
8
2 4 6 8 0 

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

typedef struct LNode{
    int   data;       //数据域
    struct LNode  *next;   //指针域
}LNode,*LinkList;   

void createList(LinkList &L, int n); // 创建n个结点的链表 

void printList(LinkList L); // 打印链表 

// 根据序号查找前驱 
// 返回序号为i（序号从1开始）的结点的前驱结点的地址，找不到返回NULL 
LNode* findIP(LinkList L, int i); 

// 根据值查找前驱 
// 返回值为e的第一个结点的前驱结点的地址，找不到返回NULL 
LNode* findVP(LinkList L, int e); 

int main(){
	LinkList L;
	int cmd, e, n, i;
	LNode *p;
	scanf("%d", &n);
	createList(L, n); 
	while (scanf("%d", &cmd) != EOF )  { // 选择操作 
		switch (cmd) {
		case 0:
			printList(L);
			break;
			
		case 3: // 根据序号查找前驱 
			scanf("%d", &i);
			p = findIP(L, i);
			if(p==L) printf("Unknown\n");
			else if ( p!=NULL) printf("%d\n", p->data);
			else printf("Not Found\n");
			break; 
			
		case 4: // 根据值查找前驱 
			scanf("%d", &e);
			p = findVP(L, e);
			if(p==L) printf("Unknown\n");
			else if ( p!=NULL) printf("%d\n", p->data);
			else printf("Not Found\n");
			break; 
						
		default:
			printf("Unknow Command.\n");
			break;
		}
	}
	return 0;
} 
//
void createList(LinkList &L, int n)// 创建n个结点的链表 
{
	L=new LNode;
	L->next=NULL;
	LNode *r=L;
	for(int i=0;i<n;i++){
		LNode *p=new LNode;
		scanf("%d",&p->data);
		p->next=NULL;
		r->next=p;
		r=r->next;
	}
}
void printList(LinkList L) // 打印链表 
{
	LNode *p=L->next;
	while(p!=NULL){
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}

// 根据序号查找前驱 
// 返回序号为i（序号从1开始）的结点的前驱结点的地址，找不到返回NULL 
LNode* findIP(LinkList L, int i){
	LNode *p=L;
	int j=1;
	while(p){
		if(j==i){
			return p;
		}
		p=p->next;
		j++;
	}
	return NULL;
}

// 根据值查找前驱 
// 返回值为e的第一个结点的前驱结点的地址，找不到返回NULL 
LNode* findVP(LinkList L, int e){
	LNode *p=L;
	while(p->next){
		if(p->next->data==e){
			return p;
		}
		p=p->next;
	}
	return NULL;	
}

0504

实现链表的插入和删除操作
注意：可以调用找前驱操作，以简化代码
输入要求：
首先输入一个整数n（n>=0)，代表元素个数，接下来输入n个整数
然后，循环输入由一个整数表示的操作命令，其中
0 代表打印链表
5 代表插入，接下来输入插入位置和要插入的值
6 代表删除，接下来输入要删除元素的位置
输出要求：
根据输入的命令进行输出
0：打印链表中的数据元素，每个整数后一个空格，打印结束后换行。
5或6：操作成功输出”OK"，失败输出”ERROR“
数据示例1：
输入：
5
2 4 6 8 0
5 0 999
5 7 999
5 6 999
5 7 999
5 1 999
0
6 0
6 8
6 8
6 1
0
输出：
ERROR
ERROR
OK
OK
OK
999 2 4 6 8 0 999 999 
ERROR
OK
ERROR
OK
2 4 6 8 0 999

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

typedef struct LNode{
    int   data;       //数据域
    struct LNode  *next;   //指针域
}LNode,*LinkList;   


void createList(LinkList &L, int n); // 创建n个结点的链表 

void printList(LinkList L); // 打印链表 

// 在位置i（从1开始）插入元素e 
// 成功返回1，失败返回0 
int insert(LinkList &L, int i, int e); 

// 删除位置i的元素 
// 成功返回1，失败返回0 
int del(LinkList &L, int i); 

int main(){
	LinkList L;
	int cmd, e, n, i, re;
	LNode *p;
	scanf("%d", &n);
	createList(L, n); 
	while (scanf("%d", &cmd) != EOF )  { // 选择操作 
		switch (cmd) {
		case 0:
			printList(L);
			break;
			
		case 5: // 在位置i插入元素e
			scanf("%d %d", &i, &e);
			re = insert(L, i, e);
			if (re) printf("OK\n");
			else printf("ERROR\n");
			break; 
			
		case 6: // 删除位置i的元素 
			scanf("%d", &i);
			re = del(L, i);
			if (re) printf("OK\n");
			else printf("ERROR\n");
			break;  
						
		default:
			printf("Unknow Command.\n");
			break;
		}
	}
	return 0;
} 
/ 
void createList(LinkList &L, int n) // 创建n个结点的链表 
{
	L=new LNode;
	L->next=NULL;
	LNode *r=L;
	for(int i=0;i<n;i++){
		LNode *p=new LNode;
		scanf("%d",&p->data);
		p->next=NULL;
		r->next=p;
		r=r->next; 
	} 
}
void printList(LinkList L)// 打印链表 
{
	LNode *p=L->next;
	while(p!=NULL){
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}
// 在位置i（从1开始）插入元素e 
// 成功返回1，失败返回0 
int insert(LinkList &L, int i, int e){
	LNode *p=L;
	int j=0;
	while(p&&(j<i-1)){
		p=p->next;
		j++;
	}
	
	if(!p||j>i-1){
		return 0;
	}
	LNode *s=new LNode;
	s->data=e;
	s->next=p->next;
	p->next=s;
	return 1;
}

// 删除位置i的元素 
// 成功返回1，失败返回0 
int del(LinkList &L, int i){
	LNode *p=L;
	int j=0;
	while((p->next)&&(j<i-1)){
		p=p->next;
		j++;
	}
	if((!p->next)||(j>i-1))return 0;
			LNode *r=p->next;
			p->next=r->next;
			delete r;
			return 1;
}

0505

复制非空链表中第一个最大元素=
输入要求：
多组输入。
每组首先输入一个整数n（n>0），表示表长，然后输入n个整数
输出要求：
输出复制操作后链表中元素，每个元素后面有一个空格，输出结束后换行。
数据示例1：
输入：
10 
1 2 3 4 5 1 2 3 4 5
3
1 2 3
输出：
1 2 3 4 5 5 1 2 3 4 5 
1 2 3 3
思路提示：
可以找到第一个最大元素后，在其后面插入一个相同元素。

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

typedef struct LNode{
    int   data;       //数据域
    struct LNode  *next;   //指针域
}LNode,*LinkList;   

// 根据用户输入，创建n个结点的链表 
void createList(LinkList &L, int n); 

// 打印链表，每个元素后一个空格，打印结束换行 
void printList(LinkList L); 

// 复制非空链表中第一个最大元素
void duplicateMax(LinkList &L);


int main(){
	int n;
	while(~scanf("%d", &n)){
		LinkList L;
		createList(L, n);
		duplicateMax(L); 
		printList(L);
	}
	return 0;
}
//
// 根据用户输入，创建n个结点的链表 
void createList(LinkList &L, int n){
	L=new LNode;
	L->next=NULL;
	LNode *r=L;
	for(int i=0;i<n;i++)
	{
		LNode *p=new LNode;
		scanf("%d",&p->data);
		p->next=NULL;
		r->next=p;
		r=r->next;
	}
}

// 打印链表，每个元素后一个空格，打印结束换行 
void printList(LinkList L){
	LNode *p=L->next;
	while(p){
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}

// 复制非空链表中第一个最大元素
void duplicateMax(LinkList &L){
	LNode *p=L->next;
	LNode *max=new LNode;
//	LNode *r=new LNode;
	int n=0;
	max->data=p->data;
	while(p!=NULL){
		if((p->data)>max->data){
			max->data=p->data;
			n++;
		}
		p=p->next;
	}
	p=L;
	while(n--){
		p=p->next;
	}
	max->next=p->next;
	p->next=max;
}

0506

删除非空链表中第一个最小元素
输入要求：
多组输入。
每组首先输入一个整数n（n>0），表示表长，然后输入n个整数
输出要求：
输出删除操作后表中元素，每个元素后面有一个空格，输出结束后换行。
数据示例1：
输入：
6
1 2 3 1 2 3
5
5 4 3 2 1
输出：
2 3 1 2 3
5 4 3 2 
思路提示：
需要首先找到第一个最小元素的前驱

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

typedef struct LNode{
    int   data;       //数据域
    struct LNode  *next;   //指针域
}LNode,*LinkList;

void printList(LinkList L){
	LNode *p = L->next;
	while(p){
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

// 根据用户输入，创建n个结点的链表 
void createList(LinkList &L, int n); 

// 删除非空链表中第一个最小元素
void deleteMin(LinkList &L);


int main(){
	int n;
	while(~scanf("%d", &n)){
		LinkList L;
		createList(L, n);
		deleteMin(L); 
		printList(L);
	}
	return 0;
}
/
// 根据用户输入，创建n个结点的链表 
void createList(LinkList &L, int n){
	L=new LNode;
	L->next=NULL;
	LNode *r=L;
	for(int i=0;i<n;i++){
		LNode *p=new LNode;
		scanf("%d",&p->data);
		p->next=NULL;//给next域赋值 
		r->next=p;//将p链接到r的后面 
		r=r->next;
	}
} 

// 删除非空链表中第一个最小元素
void deleteMin(LinkList &L){
	LNode *p=L->next;
	LNode *min=new LNode;
	min->data=p->data;
	int n=0;
	while(p){
		if((p->data)<min->data){
			min->data=p->data;
			n++;
		}
		p=p->next;
	}
	p=L;
	while(n--){
		p=p->next;
	}
	p->next=p->next->next;
	delete min;
}