链表

最新推荐文章于 2024-03-07 21:25:38 发布

20190917

最新推荐文章于 2024-03-07 21:25:38 发布

阅读量175

点赞数

分类专栏：链表文章标签：链表

本文链接：https://blog.csdn.net/sun2014moon/article/details/80512232

版权

链表专栏收录该内容

1 篇文章 0 订阅

订阅专栏

#define NODE_NUM 10
#define OAS 50
#define NOS 55
#include<iostream>
using namespace std;
//单链表的存储方法
struct _node
{
	double df;
	double energy;
	int		nbr;
	int oas;
	//int nos;
};
struct Node
{
	int data;
	int show_id;
	double df;
	double energy;
	Node *next;  
};

class LinkList
{
public:
	LinkList();                    
	LinkList(struct _node x[]);	
	~LinkList();	
	void SelectSort();
	void adjust();
	void PrintList();					
private:
	Node *flag,*front,*rear;                         	
		
};

LinkList::LinkList()
{
	front = new Node;
	front->next = NULL;
}
LinkList::LinkList(struct _node x[])      
{
	rear = new Node;
	front = new Node;
	rear = front;
	for (int i = 0; i < NODE_NUM; i++)
	{
		if(x[i].nbr==1){
			Node *temp = new Node;
			temp->show_id=i;
			temp->df=x[i].df;
			temp->energy=x[i].energy;
			rear->next=temp;
			rear=temp;
		}else
			continue;
		
	}
	//cout<<"tail's df:"<<tail->df<<endl;
	rear->next = NULL;
}
LinkList:: ~LinkList(){}
void LinkList::PrintList()
{
	Node *p = front->next;
	while (p!= NULL)
	{
		cout << p->df << "  ";
		p = p->next;
	}
	cout << endl;

}
void LinkList::adjust(){
	Node *p;
	p=front->next;
	front->next=p->next;
	rear->next=p;
	rear=p;
	rear->next=NULL;
	
}
void LinkList::SelectSort()
{
	Node *pre,*maxPtr,*first,*last;
	Node *p = front;
	Node *q = new Node;
	pre=NULL;maxPtr=NULL;first=NULL;last=NULL;
	while (p->next!= NULL)
	{
		for(p=front->next,maxPtr=front->next;p->next!=NULL;p=p->next){
			if(p->next->df>maxPtr->df){
				pre=p;
				maxPtr=p->next;
			}
		}
		if(first==NULL){
			first=maxPtr;
			last=maxPtr;
		}else{
			last->next=maxPtr;
			last=maxPtr;
		}
		if(maxPtr==front->next){
			front->next=maxPtr->next;
		}else{
			pre->next=maxPtr->next;
		}
		p=front;
	}
	if(first!=NULL){
		last->next=NULL;
	}
	front->next=first;
	rear=last;
	flag=first;
}			
void main()
{
	struct _node nodeNbr[NODE_NUM];
	nodeNbr[0].df=453.1;
	nodeNbr[1].df=294.3;
	nodeNbr[2].df=136.4;
	nodeNbr[3].df=521.7;
	nodeNbr[4].df=957.6;
	nodeNbr[5].df=753.1;
	nodeNbr[6].df=894.3;
	nodeNbr[7].df=736.4;
	nodeNbr[8].df=621.7;
	nodeNbr[9].df=357.6;

	nodeNbr[0].energy=47845.3;
	nodeNbr[1].energy=35327.6;
	nodeNbr[2].energy=23256.2;
	nodeNbr[3].energy=56178.4;
	nodeNbr[4].energy=78032.1;
	nodeNbr[5].energy=67845.3;
	nodeNbr[6].energy=95327.6;
	nodeNbr[7].energy=13256.2;
	nodeNbr[8].energy=86178.4;
	nodeNbr[9].energy=58032.1;

	nodeNbr[0].nbr=1;
	nodeNbr[1].nbr=0;
	nodeNbr[2].nbr=1;
	nodeNbr[3].nbr=0;
	nodeNbr[4].nbr=1;
	nodeNbr[5].nbr=1;
	nodeNbr[6].nbr=0;
	nodeNbr[7].nbr=1;
	nodeNbr[8].nbr=0;
	nodeNbr[9].nbr=1;

	nodeNbr[0].oas=1;
	nodeNbr[1].oas=0;
	nodeNbr[2].oas=0;
	nodeNbr[3].oas=0;
	nodeNbr[4].oas=1;
	nodeNbr[5].oas=0;
	nodeNbr[6].oas=0;
	nodeNbr[7].oas=1;
	nodeNbr[8].oas=0;
	nodeNbr[9].oas=0;
	
	LinkList list(nodeNbr);
	list.PrintList();
	cout<<endl;

	list.SelectSort();
	list.PrintList();
	cout<<endl;	

	list.adjust();
	list.PrintList();
	cout<<endl;	

	list.adjust();
	list.PrintList();
	cout<<endl;
}

#define NODE_NUM 5
#include<iostream>
using namespace std;
//单链表的存储方法
struct _node
{
	double df;
	double energy;
	int		nbr;
};
struct Node
{
	int data;
	int show_id;
	double df;
	double energy;
	Node *next;  //此处<T>也可以省略
};

class LinkList
{
public:
	LinkList();                    //建立只有头结点的空链表
	LinkList(struct _node x[]);
	LinkList(int a[], int n);     //建立有n个元素的单链表
	~LinkList();                 //析构函数
	void SelectSort();
	int Length();               //求单链表的长度
	int Get(int i);             //取单链表中第i个结点的元素值
	int Locate(int x);           //求单链表中值为x的元素序号
	void Insert(int i, int x);   //在单链表中第i个位置插入元素值为x的结点
	int Delete(int i);           //在单链表中删除第i个结点
	void PrintList();             //遍历单链表，按序号依次输出各元素
	void Reverse();                       //就地逆置
	void Purge();         //飞抵见有序排列的线性表  删除结点值相同的多余结点
private:
	Node *head;                         //单链表的头指针
	Node *flag;
	Node *tail;
	Node *first;
};

/*
*前置条件：单链表不存在
*输    入：无
*功    能：构建一个单链表
*输    出：无
*后置条件：构建一个单链表
*/
LinkList::LinkList()
{
	first = new Node;
	first->next = NULL;
}
/*
*前置条件：单链表不存在
*输    入：顺序表信息的数组形式a[],单链表长度n
*功    能：将数组a[]中元素建为长度为n的单链表
*输    出：无
*后置条件：构建一个单链表
*/
/* LinkList::LinkList(int a[], int n)                       //头插法构建单链表
{
	first = new Node;
	first->next = NULL;           //生成头结点 头结点的指针域为空
	for (int i = 0; i < n; i++)
	{
		Node *s = new Node;
		s->data = a[i];
		s->next = first->next;
		first->next = s;
	}
}
*/
//head is block ,data store in head->next
LinkList::LinkList(struct _node x[])                       //尾插法构建单链表
{
	Node *tail = new Node;
	head = new Node;
	tail = head;//尾指针初始化
	for (int i = 0; i < NODE_NUM; i++)
	{
		if(x[i].nbr==1){
			Node *temp = new Node;
			temp->show_id=i;
			temp->df=x[i].df;
			temp->energy=x[i].energy;
			tail->next=temp;
			tail=temp;
		}else
			continue;
		
	}
	tail->next = NULL;

}LinkList::LinkList(int a[], int n)                       //尾插法构建单链表
{
	Node *r = new Node;
	first = new Node;
	r = first;//尾指针初始化
	for (int i = 0; i < n; i++)
	{
		Node *s = new Node;
		s->data = a[i];
		r->next = s;
		r = s;
	}
	r->next = NULL;

}
/*
*前置条件：无
*输    入：无
*功    能：无
*输    出：无
*后置条件：无
*/
LinkList:: ~LinkList(){}
/*
*前置条件：单链表存在
*输    入：查询元素位置i
*功    能：按位查找位置为i的元素并输出值
*输    出：查询元素的值
*后置条件：单链表不变
*/
int LinkList::Get(int i)
{
	Node *p = first->next;
	int count = 1;
	while (p != NULL&&count < i)
	{
		p = p->next;
		count++;
	}
	if (p == NULL)
		throw "位置";
	else
		return p->data;
}

/*
*前置条件：单链表存在
*输    入：查询元素值x
*功    能：按值查找值的元素并输出位置
*输    出：查询元素的位置
*后置条件：单链表不变
*/
int LinkList::Locate(int x)
{
	Node *p = first->next;
	int count = 1;
	while (p != NULL)
	{
		if (p->data == x)
			return count;
		else
			p = p->next;
		count++;
	}
	return 0;  //返回0 查找不成功

}
/*
*前置条件：单链表存在
*输    入：插入元素x,插入位置i
*功    能：将元素x插入到单链表中位置i处
*输    出：无
*后置条件：单链表插入新元素
*/
void LinkList::Insert(int i, int x)             
{
	Node *p = first;
	int count = 0;
	while (p != NULL&&count < i - 1)
	{
		p = p->next;
		count++;
	}
	if (p == NULL)
		throw "位置";
	else
	{
		Node *s = new Node;
		s->data = x;
		s->next = p->next;
		p->next = s;
	}
}
/*
*前置条件：单链表存在
*输    入：无
*功    能：输出单链表长度
*输    出：单链表长度
*后置条件：单链表不变
*/
int LinkList::Length()
{
	Node *p = first->next;
	int count = 0;
	while (p != NULL)
	{
		p = p->next;
		count++;
	}
	return count;
}
/*
*前置条件：单链表存在
*输    入：要删除元素位置i
*功    能：删除单链表中位置为i的元素
*输    出：无
*后置条件：单链表删除元素
*/
int LinkList::Delete(int i)
{
	Node *p = new Node;
	p = first;
	int count = 0;
	while (p != NULL&&count < i - 1)
	{
		p = p->next;
		count++;
	} 
	if (p == NULL || p->next == NULL)
		throw "位置";
	else
	{
		Node *q = new Node;
		q = p->next;
		int x = q->data;
		p->next = q->next;
		delete q;
		return x;
	}
	
}
/*
*前置条件：单链表存在
*输    入：无
*功    能：单链表遍历
*输    出：输出所有元素
*后置条件：单链表不变
*/
void LinkList::PrintList()
{
	Node *p = head->next;
	while (p!= NULL)
	{
		cout << p->df << "  ";
		p = p->next;
	}
	cout << endl;

}
void LinkList::Reverse()     //单链表的逆置
{
	Node *p = first->next;//p指向第一个元素
	Node *q;   
	first->next = NULL; //断开头结点与链表
	while (p)
	{
		q = p;
		p = p->next;
		q->next = first->next;
		first->next = q;
	}
}
void LinkList::SelectSort()
{
	Node *pre,*max,*first,*last;
	Node *p = head;
	Node *q = new Node;
	pre=NULL;max=NULL;first=NULL;last=NULL;
	while (p->next!= NULL)
	{
		for(p=head->next,max=head->next;p->next!=NULL;p=p->next){
			if(p->next->df>max->df){
				pre=p;
				max=p->next;
			}
		}
		if(first==NULL){
			first=max;
			last=max;
		}else{
			last->next=max;
			last=max;
		}
		if(max==head->next){
			head->next=max->next;
		}else{
			pre->next=max->next;
		}
		p=head;
	}
	if(first!=NULL){
		last->next=NULL;
	}
	head->next=first;
}
		
	

void LinkList::Purge()
{
	Node *p = first->next;
	Node *q = new Node;
	while (p->next != NULL)
	{
		if (p->data == p->next->data)    //当前节点与后继结点的值相比 相等则删除后继结点
		{
			q = p->next;
			p->next = q->next;
			delete q;
		}
		else
			p = p->next;
	}

}
void main()
{
	struct _node nodeNbr[NODE_NUM];
	nodeNbr[0].df=453.1;
	nodeNbr[1].df=294.3;
	nodeNbr[2].df=136.4;
	nodeNbr[3].df=521.7;
	nodeNbr[4].df=957.6;
	nodeNbr[0].energy=47845.3;
	nodeNbr[1].energy=35327.6;
	nodeNbr[2].energy=23256.2;
	nodeNbr[3].energy=56178.4;
	nodeNbr[4].energy=78032.1;
	nodeNbr[0].nbr=1;
	nodeNbr[1].nbr=1;
	nodeNbr[2].nbr=1;
	nodeNbr[3].nbr=0;
	nodeNbr[4].nbr=1;
	//int a[21] = {0,1,2,3,4,4,4,5,5,7,7,9,9,10,11};
	LinkList list(nodeNbr);
	list.PrintList();
	cout<<endl;
	list.SelectSort();
	list.PrintList();
	//list.Reverse();
	//list.PrintList();
	//list.Insert(3, 9);
	//list.PrintList();
	//list.Delete(4);
	//list.PrintList();
	//list.Purge();
	//list.PrintList();

}

#include <iostream>
using namespace std;
struct node{
	int ID;
	int num;
	struct node *next;
};
int main() {
	int n=5;
	int k=2;
	node *head=new node();
	head->next=NULL;
	node *tail=head;
	node *p=NULL;
	for(int i=1;i<=n;i++){
		p=new node();
		p->ID=i;
		p->num=i;
		tail->next=p;
		p->next=NULL;
		tail=p;
	}
	tail->next=head;
	
	p=head;
	while(p->next!=head){
		p=p->next;
		cout<<p->ID<<" ";
	}
	cout<<endl;
	
	node *q=NULL;
	do{
		int haha;
		cin>>haha;
		p=head;
		while(p->next!=head){
			q=p;
			p=p->next;
			int x=p->num;
			cout<<p->ID<<":"<<p->num<<endl;
			if(x%k==0||x%10==k){
				cout<<"delete:"<<p->ID<<endl;
				q->next=p->next;
							
			}
			tail=p;
		}
		tail->next=head;
		cout<<"tail:"<<tail->ID<<endl;
		p=head->next;
		p->num=tail->num+1;
		q=p;
		while(p->next!=head){
			p=p->next;
			p->num=q->num+1;
			q=p;
		}
		
		p=head;
		while(p->next!=head){
			p=p->next;
			cout<<p->ID<<" ";
		}
		cout<<endl;
		
		p=head;
		while(p->next!=head){
			p=p->next;
			cout<<p->num<<" ";
		}
		cout<<endl;
	}while(head->next!=tail);
	p=head->next;
	cout<<p->ID;
	return 0;
}

#include<iostream>
using namespace std;
//单链表的存储方法
struct Node
{
	int data;
	Node *next;  //此处<T>也可以省略
};

class LinkList
{
public:
	LinkList();                    //建立只有头结点的空链表
	LinkList(int a[], int n);     //建立有n个元素的单链表
	~LinkList();                 //析构函数
	int Length();               //求单链表的长度
	int Get(int i);             //取单链表中第i个结点的元素值
	int Locate(int x);           //求单链表中值为x的元素序号
	void Insert(int i, int x);   //在单链表中第i个位置插入元素值为x的结点
	int Delete(int i);           //在单链表中删除第i个结点
	void PrintList();             //遍历单链表，按序号依次输出各元素
	void Reverse();                       //就地逆置
	void Purge();         //飞抵见有序排列的线性表  删除结点值相同的多余结点
private:
	Node *first;                         //单链表的头指针
};

/*
*前置条件：单链表不存在
*输    入：无
*功    能：构建一个单链表
*输    出：无
*后置条件：构建一个单链表
*/
LinkList::LinkList()
{
	first = new Node;
	first->next = NULL;
}
/*
*前置条件：单链表不存在
*输    入：顺序表信息的数组形式a[],单链表长度n
*功    能：将数组a[]中元素建为长度为n的单链表
*输    出：无
*后置条件：构建一个单链表
*/
/* LinkList::LinkList(int a[], int n)                       //头插法构建单链表
{
	first = new Node;
	first->next = NULL;           //生成头结点 头结点的指针域为空
	for (int i = 0; i < n; i++)
	{
		Node *s = new Node;
		s->data = a[i];
		s->next = first->next;
		first->next = s;
	}
}
*/
LinkList::LinkList(int a[], int n)                       //尾插法构建单链表
{
	Node *r = new Node;
	first = new Node;
	r = first;//尾指针初始化
	for (int i = 0; i < n; i++)
	{
		Node *s = new Node;
		s->data = a[i];
		r->next = s;
		r = s;
	}
	r->next = NULL;

}
/*
*前置条件：无
*输    入：无
*功    能：无
*输    出：无
*后置条件：无
*/
LinkList:: ~LinkList(){}
/*
*前置条件：单链表存在
*输    入：查询元素位置i
*功    能：按位查找位置为i的元素并输出值
*输    出：查询元素的值
*后置条件：单链表不变
*/
int LinkList::Get(int i)
{
	Node *p = first->next;
	int count = 1;
	while (p != NULL&&count < i)
	{
		p = p->next;
		count++;
	}
	if (p == NULL)
		throw "位置";
	else
		return p->data;
}

/*
*前置条件：单链表存在
*输    入：查询元素值x
*功    能：按值查找值的元素并输出位置
*输    出：查询元素的位置
*后置条件：单链表不变
*/
int LinkList::Locate(int x)
{
	Node *p = first->next;
	int count = 1;
	while (p != NULL)
	{
		if (p->data == x)
			return count;
		else
			p = p->next;
		count++;
	}
	return 0;  //返回0 查找不成功

}
/*
*前置条件：单链表存在
*输    入：插入元素x,插入位置i
*功    能：将元素x插入到单链表中位置i处
*输    出：无
*后置条件：单链表插入新元素
*/
void LinkList::Insert(int i, int x)             
{
	Node *p = first;
	int count = 0;
	while (p != NULL&&count < i - 1)
	{
		p = p->next;
		count++;
	}
	if (p == NULL)
		throw "位置";
	else
	{
		Node *s = new Node;
		s->data = x;
		s->next = p->next;
		p->next = s;
	}
}
/*
*前置条件：单链表存在
*输    入：无
*功    能：输出单链表长度
*输    出：单链表长度
*后置条件：单链表不变
*/
int LinkList::Length()
{
	Node *p = first->next;
	int count = 0;
	while (p != NULL)
	{
		p = p->next;
		count++;
	}
	return count;
}
/*
*前置条件：单链表存在
*输    入：要删除元素位置i
*功    能：删除单链表中位置为i的元素
*输    出：无
*后置条件：单链表删除元素
*/
int LinkList::Delete(int i)
{
	Node *p = new Node;
	p = first;
	int count = 0;
	while (p != NULL&&count < i - 1)
	{
		p = p->next;
		count++;
	} 
	if (p == NULL || p->next == NULL)
		throw "位置";
	else
	{
		Node *q = new Node;
		q = p->next;
		int x = q->data;
		p->next = q->next;
		delete q;
		return x;
	}
	
}
/*
*前置条件：单链表存在
*输    入：无
*功    能：单链表遍历
*输    出：输出所有元素
*后置条件：单链表不变
*/
void LinkList::PrintList()
{
	Node *p = first->next;
	while (p!= NULL)
	{
		cout << p->data << "  ";
		p = p->next;
	}
	cout << endl;

}
void LinkList::Reverse()     //单链表的逆置
{
	Node *p = first->next;//p指向第一个元素
	Node *q;   
	first->next = NULL; //断开头结点与链表
	while (p)
	{
		q = p;
		p = p->next;
		q->next = first->next;
		first->next = q;
	}
}
void LinkList::Purge()
{
	Node *p = first->next;
	Node *q = new Node;
	while (p->next != NULL)
	{
		if (p->data == p->next->data)    //当前节点与后继结点的值相比 相等则删除后继结点
		{
			q = p->next;
			p->next = q->next;
			delete q;
		}
		else
			p = p->next;
	}

}
void main()
{
	int a[21] = {0,1,2,3,4,4,4,5,5,7,7,9,9,10,11};
	LinkList ll(a,21);
	ll.PrintList();
	//ll.Reverse();
	//ll.PrintList();
	//ll.Insert(3, 9);
	//ll.PrintList();
	//ll.Delete(4);
	//ll.PrintList();
	ll.Purge();
	ll.PrintList();

}

c语言_链表实例讲解(两个经典例子)  
2011-10-17 22:14:20|  分类： Linux学习笔记|举报|字号 订阅
原来使用单片机编程的时候，对链表使用的不多，现在转学嵌入式，发现链表，指针就是嵌入式的基础，从网上看到一篇学习链表的例子，感觉挺好的，转载过来一起分享。
建立一个学生成绩的线性链表，对其实现插入，删除，输出，最后销毁。
 
#include <stdio.h>
#include <stdlib.h>
struct grade
 {
    int score;
    struct grade *next;  
 };
typedef struct grade NODE;  //typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。
                             //使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，
        //另一个是简化一些比较复杂的类型声明。
 struct grade *create();   //创建链表 
 void insert(NODE *head,NODE *pnew,int i);   //插入链表 
 void pdelete(NODE *head,int i);   //删除列表 
 void display(NODE *head);   //输出链表 
 void Pfree(NODE *head);    //销毁链表 
 
int main(int argc, char *argv[])
{
 struct grade *head,*pnew;
 head=create(); 
 if(head==NULL)
 return 0;
 printf("输出创建的链表：");
 display(head);
 pnew=(NODE *)malloc(sizeof(NODE));
 if(pnew==NULL)
 {
  printf("创建失败！");
  return 0;
 }
 pnew->score=88;
 insert(head,pnew, 3);   //将新节点插入节点3的后面 
 printf("插入后的链表：");
 display(head);
 pdelete(head,3);   //删除节点3 
 printf("删除后的链表：");
 display(head);
 Pfree(head);
 return 0;
}
struct grade *create()
{
 NODE *head,*tail,*pnew;
     int score;
    head=(NODE *)malloc(sizeof(NODE));  //创建头节点。 
  if(head==NULL)  //创建失败返回 
  {
   printf("创建失败！");
   return NULL;
   }
    head->next=NULL;  //头节点指针域置NULL
 tail=head;  // 开始时尾指针指向头节点
 printf("输入学生成绩：");
 while(1)    //创建链表 
 {
  scanf("%d",&score);
  if(score<0)  //成绩为负是退出循环 
    break;
  pnew=(NODE *)malloc(sizeof(NODE));  //创建新节点 
  if(pnew==NULL)  //创建失败返回 
  {
   printf("创建失败！");
   return NULL;
  }  
  pnew->score=score;  //新节点数据域存放输入的成绩 
  pnew->next=NULL;   //新节点指针域置NULL 
  tail->next=pnew;  //新节点插入到表尾 
  tail=pnew;   //为指针指向当前的尾节点 
 } 
 return head;  //返回创建链表的头指针 
}
void insert(NODE *head,NODE *pnew,int i)
{
 NODE *p;
 int j;
    
    p=head;
    for(j=0;j<i&&p!=NULL;j++)  //p指向要插入的第i个节点 
      p=p->next;
    if(p==NULL)  //节点i不存在 
 {
  printf("与插入的节点不存在！");
  return;
 }  
 
 pnew->next=p->next;   //插入节点的指针域指向第i个节点的后继节点 
 p->next=pnew;    //犟第i个节点的指针域指向插入的新节点 
}
void pdelete(NODE *head,int i)
{
 NODE *p,*q;
 int j;
 if(i==0)  //删除的是头指针，返回 
   return;
 p=head;
 for(j=1;j<i&&p->next!=NULL;j++)
   p=p->next;  //将p指向要删除的第i个节点的前驱节点 
 if(p->next==NULL)  //表明链表中的节点不存在 
 {
  printf("不存在！");
  return;
 }  
 q=p->next;  //q指向待删除的节点 
 p->next=q->next;  //删除节点i，也可写成p->next=p->next->next 
 free(q);   //释放节点i的内存单元 
}
void display(NODE *head)
{
 NODE *p;
 for(p=head->next;p!=NULL;p=p->next)
   printf("%d ",p->score);
 printf("\n");  
} 
void pfree(NODE *head)
{
 NODE *p,*q;
 
 p=head;
 while(p->next!=NULL)    //每次删除头节点的后继节点 
 {
  q=p->next;   
  p->next=q->next;
  free(q);
 }
 free (head);  //最后删除头节点 
}
void Pfree(NODE *head)
{
 NODE *p,*q;
 p=head;
 while(p->next!=NULL)
 {
  q=p->next;
  p->next=q->next;
  free(q);
 }
 free(p);
}
转自：http://hi.baidu.com/y%C9%D9%B0%D7y/blog/item/fa9f1c5b1525b500367abe80.html
 
链表是C语言中比较难，但是又比较重要的数据结构，相信有很多人在为它而头痛哦。
我做了一个链表的程序，发出来与大家共享，希望大家能用得着。


#include <stdio.h>
#include <malloc.h>
#include <conio.h>
#include <stdlib.h>
//链表单元定义，链表相关变量
struct student
{
int id;
float score;
struct student *next;
} *head,*pthis;
//输入数据创建链表
void input()
{
struct student *tmp;
printf("\n\n请输入学生的信息以学号为0结束:\n");
do
{
printf("ID\t成绩\n");
if((tmp=(struct student*)malloc(sizeof(struct student)))==NULL)
{
printf("\n错误!不能申请所需的内存!\n");
exit(0);
}
scanf("%d\t%f",&tmp->id,&tmp->score);
tmp->next=NULL;
if(tmp->id!=0)
{
if(head==NULL)
{
head=tmp;
pthis=head;
}
else
{
pthis->next=tmp;
pthis=pthis->next;
}
}
}
while(tmp->id!=0);
free(tmp);
}
//搜索链表找到第一个符合条件的项目输出
void search(int id)
{
printf("\n\n查询结果\n");
printf("ID\t成绩\n");
printf("-------------------------------\n");
if(head==NULL)
{
printf("\n错误!没有数据!\n");
return;
}
pthis=head;
while(pthis!=NULL)
{
if(pthis->id==id)
{
printf("%d\t%.2f\n",pthis->id,pthis->score);
return;
}
else
{
pthis=pthis->next;
}
}
printf("\n没有找到!\n");
}
//列表输出链表中的所有项
void list()
{
printf("\n\n数据列表\n");
printf("ID\t成绩\n");
printf("-------------------------------\n");
if(head==NULL)
{
printf("错误,没有数据!\n");
return;
}
pthis=head;
while(pthis!=NULL)
{
printf("%d\t%.2f\n",pthis->id,pthis->score);
pthis=pthis->next;
}
}
//插入数据
void insert()
{
int i,p;
struct student *tmp;
if(head==NULL)
{
printf("\n\n数据不存在，无法插入!\n");
return;
}
printf("\n请输入插入点:\n");
scanf("%d",&p);
if(p<0)
{
printf("输入不合法!");
return;
}
printf("\n\n请输入学生的信息:\nID\t成绩\n");
if((tmp=(struct student*)malloc(sizeof(struct student)))==NULL)
{
printf("\n错误!不能申请所需的内存!\n");
exit(0);
}
scanf("%d\t%f",&tmp->id,&tmp->score);
tmp->next=NULL;
if(tmp->id!=0)
{
pthis=head;
if(p==0)
{
tmp->next=head;
head=tmp;
}
else
{
for(i=0;i<p-1;i++)
{
if(pthis->next->next==NULL)
{
printf("\n找不到插入点，您输入的数据太大!\n");
return;
}
pthis=pthis->next;
}
tmp->next=pthis->next;
pthis->next=tmp;
}
}
else
{
printf("\n数据无效!\n");
free(tmp);
}
}
//追加数据
void append()
{
struct student *tmp;
printf("\n\n请输入学生的信息:\nID\t成绩\n");
if((tmp=(struct student*)malloc(sizeof(struct student)))==NULL)
{
printf("\n错误!不能申请所需的内存!\n");
exit(0);
}
scanf("%d\t%f",&tmp->id,&tmp->score);
tmp->next=NULL;
if(tmp->id!=0)
{
if(head==NULL)
{
head=tmp;
}
else
{
pthis=head;
while(pthis->next!=NULL)
{
pthis=pthis->next;
}
pthis->next=tmp;
}
}
else
{
free(tmp);
printf("\n数据无效!\n");
}
}
//删除数据
void del()
{
int p,i;
struct student *tmp;
if(head==NULL)
{
printf("\n\n没有数据，无法删除!\n");
return;
}
printf("\n\n请输入要删除的记录号:\n");
scanf("%d",&p);
if(p<0)
{
printf("\n输入不合法!\n");
return;
}
if(p==0)
{
pthis=head;
head=pthis->next;
free(pthis);
pthis=head;
}
else
{
pthis=head;
for(i=0;i<p-1;i++)
{
pthis=pthis->next;
if(pthis->next==NULL)
{
printf("\n\n指定记录不存在，无法删除!\n");
return;
}
}
tmp=pthis->next;
pthis->next=pthis->next->next;
free(tmp);
}
}
//程序主函数
void main()
{
char command=0;
int id=0;

//主循环
do
{
printf("\n\n\t 菜单\n");
printf("-------------------------------\n");
printf("\ta,输入数据\n");
printf("\tb,查询记录\n");
printf("\tc,数据列表\n");
printf("\td,追加记录\n");
printf("\te,插入记录\n");
printf("\tf,删除记录\n");
printf("\tg,退出系统\n");
printf("-------------------------------\n");
printf("\t请选择:");
command=getch();
//命令处理
switch(command)
{
case 'a':
if(head==NULL)
{
input();
break;
}
else
{
printf("\n\n数据已经存在！\n");
break;
}
case 'b':
printf("\n\n要查询的ID:");
scanf("%d",&id);
search(id);
break;
case 'c':
list();
break;
case 'd':
append();
break;
case 'e':
insert();
break;
case 'f':
del();
break;
}
}
while(command!='g');
}

20190917

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
链表

#define NODE_NUM 10#define OAS 50#define NOS 55#include&lt;iostream&gt;using namespace std;//单链表的存储方法struct _node{ double df; double energy; int nbr; int oas; //int nos;};struct Node{...
复制链接

扫一扫