【数据结构】实验三：链表

news/2024/5/14 4:47:03

实验三链表

一、实验目的与要求

1）熟悉链表的类型定义；

2）熟悉链表的基本操作；

3）灵活应用链表解决具体应用问题。

二、实验内容

1）请设计一个单链表的存储结构，并实现单链表中基本运算算法。

编写程序linklist.cpp实现单链表的各种基本运算（假设单链表元素类型ElemType为char），并在此基础上设计主程序exp.cpp完成以下功能。

§ 初始化单链表。

§ 依次插入a,b,c,d,e元素。

§ 输出单链表的元素和长度。

§ 判断单链表是否为空。

§ 输出单链表的第3个元素。

§ 输出元素a的位置。

§ 在第4个元素位置上插入f元素。

§ 查找单链表的第3个元素，如果在，则删除；如果不在，则输出找不到。

§ 释放单链表。

2）请设计一个职工文件emp.dat，每个职工记录包含职工编号(no)、姓名(name)、部门号(depno)和工资数(salary)信息。设计一个单链表的存储结构，完成以下功能：

§ 从emp.dat文件中读取职工记录,并建立一个带头结点的单链表L。

§ 输入一个职工记录。

§ 显示所有职工记录。

§ 按职工编号no对所有职工记录进行递增排序。

§ 按部门号depno对所有职工记录进行递增排序。

§ 按工资数salary，对所有职工记录进行递增排序。

§ 删除指定职工号的职工记录。

§ 删除职工文件中的全部记录。

§ 将单链表中的所有职工记录存储到职工文件emp.dat中。

3）编写程序，实现在带头结点的单链表 L 中删除一个最小值结点的算法。请写出算法思想。

三、实验结果

1）请将调试通过的源代码粘贴在下面。（代码注意书写规范、主要模块要有功能注释）

第一题实验代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <malloc.h>
using namespace std;
typedef char ElemType;//定义单链表结点类型 
typedef struct LNode{ElemType data;struct LNode *next; 
}LinkList;//初始化单链表
void InitList(LinkList *&L){//头节点创建 L=(LinkList *)malloc(sizeof(LinkList));L->next =NULL;
} //删除单链表
void DestroyList(LinkList *L){LinkList *p=L;LinkList *q=L->next ;while(q!=NULL){free(p);p=q;q=p->next ;}free(p);
} //判断单链表是否为空
bool ListEmpty(LinkList *L){if(L->next == NULL){return 0;//0 代表空 }else{return 1;//1 代表非空 }
}//单链表长度计算
int ListLength(LinkList *L){LinkList *p=L;int i=0;while(p->next !=NULL){p=p->next ;i++;} return i;
} //输出单链表
void DispList(LinkList *L){LinkList *p=L->next ;while(p->next !=NULL){cout<<p->data <<" ";p=p->next ;}cout<<p->data<<endl;
} //求某个元素的值 List + Location + Element 
int GetElem(LinkList *L,int i,ElemType &e){LinkList *p=L;int j=0;while(p!=NULL && j<i){j++;p=p->next ;}if(p==NULL){return 0;}else{e=p->data;return 1;}
} //查找元素位置 List + Element
int LocateElem(LinkList *L,ElemType e){LinkList *p=L;int j=0;while(p!=NULL && p->data ==e){j++;p=p->next ;}if(p==NULL){return 0;}else{return j+1; }
} //插入元素 -> List + Location + Element
int ListInsert(LinkList *L,int i,ElemType e){LinkList *p=L;LinkList *s;int j=0;while(p!=NULL && j<i-1){j++;p=p->next ;}if(p==NULL){return 0;}else{s=(LinkList *)malloc(sizeof(LinkList));s->data =e;s->next =p->next ;p->next =s;return 1;}
}//删除元素 -> List + Location + Element
int ListDelete(LinkList *L,int i,ElemType e){LinkList *p=L;LinkList *s;int j=0;while(p!=NULL && j<i-1){j++;p=p->next ;}if(p==NULL){return 0;}else{s=p->next ;if(s==NULL){return 0;}e=s->data ;p->next =s->next ;free(s);return 1;}
}int main(){LinkList *h;ElemType e;cout<<endl<<"初始化单链表"<<endl;InitList(h);cout<<endl<<"依次插入abcde元素"<<endl;ListInsert(h,1,'a');ListInsert(h,2,'b');  ListInsert(h,3,'c');  ListInsert(h,4,'d');  ListInsert(h,5,'e');  cout<<endl<<"输出单链表的元素和长度"<<endl;DispList(h);cout<<"Length = "<<ListLength(h)<<endl;cout<<endl<<"判断单链表是否为空"<<endl;if(ListEmpty(h)==1){cout<<"单链表不为空"<<endl;}else{cout<<"单链表为空"<<endl;}cout<<endl<<"输出单链表的第3个元素"<<endl;GetElem(h,3,e);cout<<e<<endl;cout<<endl<<"输出元素a的位置"<<endl;int location=LocateElem(h,'a');cout<<location<<endl;cout<<endl<<"在第4个元素位置上插入f元素"<<endl;ListInsert(h,4,'f');DispList(h);cout<<"Length = "<<ListLength(h)<<endl;cout<<endl<<"查找单链表的第3个元素"<<endl;int flag=ListDelete(h,3,e);if(flag==1){cout<<"元素存在，已经删除"<<endl;} else{cout<<"元素不在，无法删除"<<endl;}DispList(h);cout<<"Length = "<<ListLength(h)<<endl;cout<<endl<<"释放单链表"<<endl;DestroyList(h);return 0;
}

第一题输出展示：

 第二题实验代码：

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <iomanip> 
using namespace std;//每个职工记录的基本信息建立 
typedef struct w{int no;//职工编号(no)char name[10];//姓名(name)int depno;//部门号(depno)int salary;//工资数(salary)struct w* next;
}worker;//输入一个职工记录 
void input(worker *&L){worker *p=(worker*)malloc(sizeof(worker));cout<<"请输入该职工的基本信息"<<endl; cin>> p->no >> p->name >> p->depno >> p->salary ;//头插法 p->next=L->next ;L->next =p;cout<<"已完成，可输入2进行查询"<<endl;
}//显示所有职工记录
void show(worker *L){worker *p=L->next ;for(p=L->next;p!=NULL;p=p->next ){cout<<"  no："<<setw(12)<<p->no<<"  name："<<setw(12)<<p->name<<"  depno："<<setw(12)<<p->depno<<"  salary："<<setw(12)<<p->salary<<endl;}cout<<endl; 
}//按照no排序
void no_sort(worker *&L){worker *p,*q,*s;if(L->next ==NULL){cout<<"当前链表为空"<<endl;return;}q=L->next->next;L->next->next=NULL;while(q!=NULL){p=L;while(p->next !=NULL && q->no >= p->next ->no){p=p->next ;}s=q->next ;q->next =p->next ;p->next =q;q=s;}cout<<"已完成，可输入2进行查询"<<endl;
} //按照depno排序 
void depno_sort(worker *&L){worker *p,*q,*s;if(L->next==NULL){cout<<"当前链表为空"<<endl;return ;}q=L->next ->next;L->next ->next=NULL;while(q!=NULL){p=L;while(p->next !=NULL && q->depno >=p->next ->depno){p=p->next ;}s=q->next ;q->next =p->next ;p->next =q;q=s;}cout<<"已完成，可输入2进行查询"<<endl;
}//按照salary排序 
void salary_sort(worker *&L){worker*p,*q,*s;       if(L->next==NULL){printf("链表为空\n");return;}q=L->next->next;L->next->next=NULL;while(q!=NULL){p=L;while(p->next!=NULL && q->salary >= p->next->salary){p=p->next;}s=q->next;q->next=p->next;p->next=q;q=s;}cout<<"已完成，可输入2进行查询"<<endl;
}//删除指定职工号的职工记录
void listdelete(worker *&L){worker *p,*temp;int num;cout<<"请输入要删除职工的工号："<<endl;cin>>num;for(p=L;p->next !=NULL;p=p->next ){if(p->next ->no==num){temp=p->next ;p->next =temp->next;free(temp);break;}}cout<<"已完成，可输入2进行查询"<<endl;
}//删除职工文件中的全部记录
void destroy(worker *&L){worker *p=L->next;worker *q;while(p!=NULL){q=p;p=p->next;free(q);}L->next=NULL;cout<<"已完成，可输入2进行查询"<<endl;
} //生成用户界面
void book(){cout<<endl;cout<<"本链表可以进行以下操作"<<endl; cout<<"1：输入一个职工记录"<<endl; cout<<"2：显示所有职工记录"<<endl;cout<<"3：按职工编号no对所有职工记录进行递增排序"<<endl;cout<<"4：按部门号depno对所有职工记录进行递增排序"<<endl;cout<<"5：按照工资数salary对所有职工记录进行递增排序"<<endl;cout<<"6：删除制定职工号的职工记录"<<endl;cout<<"7：删除职工文件中的全部记录"<<endl;cout<<"8：结束本次操作"<<endl;
}int main(){//初始化链表 worker*L=(worker*)malloc(sizeof(worker));L->next=NULL;while(1){int opt;book();cout<<"请输入以上数字进行职工信息操作："; cin>>opt;switch(opt){case 1://输入一个职工记录 input(L);break;case 2:show(L);break;case 3:no_sort(L);break;case 4:depno_sort(L);break;case 5:salary_sort(L);break;case 6:listdelete(L);break;case 7:destroy(L);break;case 8:return 0;default:cout<<"输入数字有误，请重新输入"<<endl; }}
}

第二题输出展示：

操作1：

 

 操作2：

 操作3：

 操作4：

 操作5：

 操作6：

 操作7：

 操作8：

 第三题实验代码：

void delminnode(LinkNode *L){LinkNode *r=L,*p=L->next,*q=p->next,*s=p;//p总是指向最小结点，r总是指向p的前驱结点，q遍历，s指向q的前驱结点while(q!=NULL){if(p->data > q->data){r=s;         //p>q时，r指向p p=q;         //p总是指向最小结点 q=q->next;   //q向后遍历 s=s->next;}else{q=q->next; s=s->next;}} r->next = p->next;free(p); //删除p结点
}

2）请分析你程序中每个功能模块的算法时间复杂度。

第一题：

p从头结点开始遍历，每经过一个非空元素就通过free(p)进行删除，同时重置p为其后继结点q，重置q为q的后继结点。由此可见，时间复杂度为O(n)。

 

只需要对头结点的后继结点进行判断，因为头结点不存放数据，所以若后继结点非空则链表非空，若后继结点为空则链表为空。由此可见，时间复杂度为O(1)。

 

通过p遍历链表，计算链表所存储的元素个数，遇到空指针便结束计算。由此可见，时间复杂度为O(n)。

 

通过p遍历链表，输出链表所存储的每一个元素，遇到空指针便结束输出。由此可见，时间复杂度为O(n)。

 

本段代码是求指定位置的元素，通过遍历单链表从头结点摸索到指定位置的结点并输出其对应的元素。由此可见，时间复杂度为O(n)。

 

本段代码是求指定元素的位置，通过遍历单链表从头结点摸索每一个位置的元素是否与已知元素等同，若等同则输出相应的位置。由于初始化计数变量j是从0开始计数的，因此在最后需要进行+1操作。由此可见，时间复杂度为O(n)。

 

本段代码是在指定位置插入指定元素，通过while循环确定所需要插入的元素的前驱结点，再插入指定元素。由此可见，时间复杂度为O(n)。

 

本段代码是在指定位置删除元素，思路与在指定位置插入指定元素类似，主要是通过while循环确定所需要删除的元素的。由此可见，时间复杂度为O(n)。

 

第二题：

本段代码是直接插入一打数据，不需要遍历单链表。由此可见，时间复杂度为O(1)。

 

本段代码是通过从头结点遍历单链表，找到每一个结点所存储的数据并输出。由此可见，时间复杂度为O(n)。

 

本段代码是按照工号对职工信息进行排序，实现过程主要是通过两个while循环。外层循环是从头结点遍历到最后一个结点，并假设头结点所存的工号元素为最小值，内层循环是比较下一个结点与当前结点所存工号元素的大小，若不存在大小突变，则继续通过p遍历单链表。由此可见，时间复杂度为O(n²)。

 

本段代码是按照部门号对职工信息进行排序，实现过程主要是通过两个while循环。外层循环是从头结点遍历到最后一个结点，并假设头结点所存的部门号元素为最小值，内层循环是比较下一个结点与当前结点所存部门号元素的大小，若不存在大小突变，则继续通过p遍历单链表。由此可见，时间复杂度为O(n²)。

 

本段代码是按照工资对职工信息进行排序，实现过程主要是通过两个while循环。外层循环是从头结点遍历到最后一个结点，并假设头结点所存的工资元素为最小值，内层循环是比较下一个结点与当前结点所存工资元素的大小，若不存在大小突变，则继续通过p遍历单链表。由此可见，时间复杂度为O(n²)。

 

本段代码是删除指定的职工信息，主要通过从头结点遍历单链表实现。当for循环中遇到与指定工号相同的工号元素时，通过free()进行删除该元素组。由此可见，时间复杂度为O(n)。

 

本段代码是删除指定的职工信息，主要通过从头结点遍历单链表实现。通过while循环摸到该单链表的尾部，在遇到每一个元素组的时候，通过free()进行删除该元素组，最后将头指针的后继结点重置为NULL。由此可见，时间复杂度为O(n)。

 

第三题：

算法思想：q从头结点指向的下一个结点开始遍历直到链表结束，每一次寻找到最小值就存入p中，遇到更小的值就进行替换。遍历完成后，最小值p且r为p的前驱结点，然后删除p即可获得最终效果。由此可见，时间复杂度为O(n)。

 

其他参考代码：

#include<iostream>
#include<stdio.h>
using namespace std;
#define Elemtype char               //最后没有分号 
//typedef LNode *LinkList;         //LinkList和LNode*   是不同的名字，但是他们是同一个指针类型，命名的不同是为了概念上更加明确。
//这里的LinkList类型的指针变量L表示它是单链表的头指针，LNode* 类型的指针变量表示它是指向某一结点的指针 
class LNode{private:Elemtype data;LNode *next;public:LNode(){this->next=NULL;}/*void InitList_L(LNode* &L)    //链表初始化函数 {L=new LNode;L->next=NULL; }void DestroyList_L(LNode* &L)  //对于结构体：销毁函数  从 头结点 开始，依次释放表中每一个节点所占用的存储空间 {LNode *p;p=new LNode;      p->next=NULL;                while(L)                    //如果L存放的东西不为空，也即L指向的地方不为空，那就接着循环。 这样可以找到最后一个结点 {p=L;                   //p指向的地方和L指向的地方一样             
//p仅仅指向现在的L指向的这一个地方，即头结点，每一次删头结点，之前的第一个成为了头结点，那就接着删 
//确实是可以通过p把L里面的一个一个删除，只删p的话就是只删了这一个结点 L=L->next;            //L是一个指针，指向L这个结点，也就是头结点。 L->next指的是第L+1个结点，也就是第一个结点 delete p;           p->next=NULL;       }}void ClearList_L(LNode* &L)   //对于结构体：清空函数  从单链表  第一个  节点开始，依次释放表中每一个节点所占用的存储空间 {LNode *p;LNode *q;p=L->next;                 //L是头结点，L存着的就是头结点的物理地址。所以L->next就是第一个节点的物理地址   q=new LNode;        //所以用这样的方法new出来的就是这个地址的头结点 while(p){q=p;p=p->next;delete q;q->next=NULL;} L->next=NULL;             } */void pushback(Elemtype t)       //在链表最后面添加元素 {LNode *p;p=new LNode;               //存放数据的LNode* 指针要new，不new会出大问题。只用作遍历可以不new p->next=NULL;p->data=t;LNode *pp;                pp=this;                   while(pp->next!=NULL){pp=pp->next;}pp->next=p;}void show()                  //按顺序输出链表元素 {LNode *p;p=this;while(p->next!=NULL){cout<<p->next->data<<" ";p=p->next;//cout<<"!"<<endl;}}int getLength()                                //输出链表长度 {LNode* p;p=this;int i=0;while(p->next!=NULL){i++;p=p->next;}return i;}bool isEmpty()                       //判断链表是否为空表 {LNode *p;p=this;if(p->next==NULL){return 1;}else{return 0;}}Elemtype threeShow()               //输出第三元素所在的位置 {LNode *p;p=this;int i=0;for(i=0;i<3;i++){p=p->next;}return p->data;}int concernA()    //判断字母a是否在链表里面，如果在，就输出位置 {LNode *p;p=this->next;int i=0;while(1){if(p->data=='a'){break;}else{i++;}p=p->next;if(i==5){break;}}if(i==5){return 0;}else{return i+1;}}void insert(Elemtype m,int n)         //在指定地方插入元素 {int i=0;LNode* p;p=new LNode;p->data=m;p->next=NULL;LNode *q;q=this;for(i=0;i<n-1;i++){q=q->next;}p->next=q->next;q->next=p;cout<<"已经按需插入"<<endl; }void Mydelete(int n)                  //删除指定位置的元素 {LNode *p;p=this;int i=0;if((*this).getLength()>=n+1){for(i=0;i<n-1;i++){p=p->next;}LNode* q;q=p->next;p->next=p->next->next;delete q;q->next=NULL;cout<<"删除了第"<<n<<"个元素"<<endl;}else if((*this).getLength()==n){for(i=0;i<n-1;i++){p=p->next;}LNode* q;q=p->next;p->next=NULL;delete q;q->next=NULL;cout<<"删除了第"<<n<<"个元素"<<endl;}else{cout<<"长度不足三，没有第三个元素"<<endl;}}~LNode()                            //析构函数 {cout<<endl<<"析构函数调用！"<<endl;}/*~LNode()                          //析构函数：  注意！！！想删除头结点，得用头删法，从头开始删 {LNode *L;L=this;LNode *p;p=new LNode;p->next==NULL;int i=0;while(L){p=L;L=L->next;delete p;p->next=NULL;cout<<i;i++;} cout<<"析构函数调用！"<<endl;}*/
};
int main()
{Elemtype t;LNode a;int i=0;while(i<5){cin>>t;a.pushback(t); i++;}cout<<"链表长度为："<<a.getLength()<<endl;if(a.isEmpty()==1){cout<<"链表为空"<<endl;}else{cout<<"链表不为空"<<endl;}cout<<"链表中第三个元素为："<<a.threeShow()<<endl;if(a.concernA()==0){cout<<"没有字母a"<<endl;} else{cout<<"字母a的位置为："<<a.concernA()<<endl;} Elemtype f='f';a.insert(f,4);int pos=3;a.show();cout<<endl;a.Mydelete(pos);a.show();
} 

#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<fstream>
#include<vector>
using namespace std;
typedef long long ll;
struct emp{int salary;                        //薪水string name,depno,id;             //姓名、部门编号、职工号
};ostream& operator << (ostream& out,const emp p)          //输出流
{out<<p.id<<" "<<p.name<<" "<<p.depno<<" "<<p.salary;return out;
}
bool cmp1(emp a,emp b){return a.salary<b.salary;
}
template<typename T>
class List{private:T data;List *link;public:List();~List();void append(const T& val);	           // 链尾增加一个元素void insertElement(int pos,const T& val);	 // 在指定位置pos后添加一个元素valvoid deleteElement(const string& val);	               // 删除所有值为val的元素 ，有析构函数时，这个delete也可能引起析构函数的调用。 void travalList()const;             // 从头节点遍历输出链表并输出长度bool isEmpty() const;               //判断是否为空void elementPos(const int& pos);   //输出第pos+1位置 因为从0开始计算void findElement(const T& val);    //输出b元素为val的位置void findDelete(const int& pos);  //查找并删除void deletetxt();                   //删除文本内容void nwlist();                      //读取职工记录void gtin();                        //读入一个记录void sortSalary();//以下为排序void sortId();void sortDepno();void writeTxt();//写入文件
};template<typename T>
List<T>::List(){link=NULL;
}template<typename T>
void List<T>::append(const T& val){List* head=this;while((head->link)!=NULL){head=head->link;}List<T> *a = new List();a->data=val;head->link=a;
}template<typename T>
void List<T>::deleteElement(const string& val)
{int flag=0;List* head=this;while((head->link)!=NULL){if(head->link->data.id==val){flag=1;List* tmp=head->link;head->link=tmp->link;tmp->link=NULL;delete tmp;continue;}if(head->link==NULL) break;head=head->link;}if(flag==0){cout<<"\nElement "<<val<<" not Found.";}
}template<typename T>
void List<T>::travalList()const
{int l=0;List* head=this->link;while(head!=NULL){l++;cout<<head->data<<endl;head=head->link;}cout<<"\nlength: "<<l<<endl;
}template<typename T>
List<T>::~List()
{if(this->link!=NULL){delete this->link;this->link=NULL;}
}template<typename T>
void List<T>::deletetxt()
{ofstream f("emp.dat",ios::trunc);f.close();
}template<typename T>
void List<T>::nwlist()
{FILE* fp;fp=freopen("emp.dat","r",stdin);int l;cin>>l;for(int i=1;i<=l;i++){emp tmp;cin>>tmp.id>>tmp.name>>tmp.depno>>tmp.salary;this->append(tmp);}fclose(fp);
}template<typename T>
void List<T>::gtin()
{emp tmp;cin>>tmp.id>>tmp.name>>tmp.depno>>tmp.salary;this->append(tmp);
}template<typename T>
void List<T>::sortSalary()
{vector<emp> q;List* head=this->link;while(head!=NULL){q.push_back(head->data);head=head->link;}for(int i=0;i<q.size()-1;i++){for(int j=0;j<q.size()-1-i;j++){if(q[j].salary>q[j+1].salary){emp tmp=q[j];q[j]=q[j+1];q[j+1]=tmp;}}}head=this->link;int l=0;while(head!=NULL){head->data=q[l];l++;head=head->link;}
}template<typename T>
void List<T>::sortId()
{vector<emp> q;List* head=this->link;while(head!=NULL){q.push_back(head->data);head=head->link;}for(int i=0;i<q.size()-1;i++){for(int j=0;j<q.size()-1-i;j++){if(q[j].id>q[j+1].id){emp tmp=q[j];q[j]=q[j+1];q[j+1]=tmp;}}}head=this->link;int l=0;while(head!=NULL) {head->data=q[l];l++;head=head->link;}
}template<typename T>
void List<T>::sortDepno()
{vector<emp> q;List* head=this->link;while(head!=NULL){q.push_back(head->data);head=head->link;} for(int i=0;i<q.size()-1;i++){for(int j=0;j<q.size()-1-i;j++){if(q[j].depno>q[j+1].depno){emp tmp=q[j];q[j]=q[j+1];q[j+1]=tmp;}}}head=this->link;int l=0;while(head!=NULL){head->data=q[l];l++;head=head->link;}
}template<typename T>
void List<T>::writeTxt()                      
{FILE* fp;fp=freopen("emp.dat","w",stdout);vector<emp> q;List* head=this->link;while(head!=NULL){q.push_back(head->data);head=head->link;}cout<<q.size()<<endl;for(int i=0;i<q.size();i++){cout<<q[i].id<<" "<<q[i].name<<" "<<q[i].depno<<" "<<q[i].salary<<endl;}fclose(fp);
}int main() 
{List<emp> list;list.nwlist();list.travalList();list.sortSalary();list.travalList();list.sortDepno();list.travalList();list.deleteElement("001");list.travalList();list.deletetxt();list.writeTxt();return 0;
}

//在单链表里面删除一个最小结点的算法
#include<iostream>
#include<stdio.h>
using namespace std;
#define Elemtype double               //最后没有分号 
//typedef LNode *LinkList;            //LinkList和LNode*   是不同的名字，但是他们是同一个指针类型，命名的不同是为了概念上更加明确。
//这里的LinkList类型的指针变量L表示它是单链表的头指针，LNode* 类型的指针变量表示它是指向某一结点的指针 
class LNode{private:Elemtype data;LNode *next;public:LNode(){this->next=NULL;}void pushback(Elemtype t)       //在链表最后面添加元素 {LNode *p;p=new LNode;               //存放数据的LNode* 指针要new，不new会出大问题。只用作遍历可以不new p->next=NULL;p->data=t;LNode *pp;               pp=this;                 while(pp->next!=NULL){pp=pp->next;}pp->next=p;}void show()                                //按顺序输出链表元素 {LNode *p;p=this;while(p->next!=NULL){cout<<p->next->data<<" ";p=p->next;}}int getLength()                                //输出链表长度 {LNode* p;p=this;int i=0;while(p->next!=NULL){i++;p=p->next;}return i;}void Mydelete(int n,int flag)             //删除指定位置的元素 {LNode *p;p=this;int i=0;if((*this).getLength()>=n+1){for(i=0;i<n-1;i++){p=p->next;}LNode* q;q=p->next;p->next=p->next->next;delete q;q->next=NULL;cout<<"删除了第"<<n<<"个元素"<<endl;}else if((*this).getLength()==n){for(i=0;i<n-1;i++){p=p->next;}LNode* q;q=p->next;p->next=NULL;delete q;q->next=NULL;cout<<"删除了第"<<n<<"个元素"<<endl;}else{cout<<"长度不足三，没有第三个元素"<<endl;}}~LNode()                            //析构函数 {cout<<endl<<"析构函数调用！"<<endl;}void min(){LNode *p;p=this->next;int len=(*p).getLength()+1;    //因为，它此时初始位置为this->next而不是this,所以求出来长度少一 Elemtype s[10]={0},temp=0;int i=0,flag[100]={0},j=0;for(i=0;i<len;i++){s[i]=p->data;p=p->next;}temp=s[0];for(i=1;i<len;i++){if(s[i]<temp){temp=s[i];}}for(i=0;i<len;i++){if(s[i]==temp){flag[j]=i;j++;}}int k=0;for(k=0;k<j;k++){(*this).Mydelete(flag[k]+1,k);}}
}; 
int main()
{Elemtype t;LNode a;int i=0;while(i<5){cin>>t;a.pushback(t); i++;}a.show();a.min();a.show();
} /*LNode *p;p=this;LNode *f;f=new LNode;int i=0;if(n==1){f=p->next;p->next=p->next->next;delete f;f->next=NULL;}if(n==2&&flag==1){f=p->next;p->next=p->next->next;delete f;f->next=NULL;}for(i=0;i<n-1-flag;i++){p=p->next;}f=p->next;p->next=p->next->next;delete f;f->next=NULL;*/


http://www.mrgr.cn/p/26136225

相关文章

神经数据库：用于使用 ChatGPT 构建专用 AI 代理的下一代上下文检索系统 — （第 2/3 部分）

神经数据库：用于使用 ChatGPT 构建专用 AI 代理的下一代上下文检索系统 — （第 2/3 部分）

书接上回理解构建LLM驱动的聊天机器人时的向量数据库检索的局限性 - &#xff08;第1/3部分&#xff09;_阿尔法旺旺的博客-CSDN博客 其中我们强调了&#xff08;1&#xff09;嵌入生成&#xff0c;然后&#xff08;2&#xff09;使用近似近邻&#xff08;ANN&#xff09;搜索…
阅读更多...
ZooKeeper原理剖析

ZooKeeper原理剖析

1.ZooKeeper简介 ZooKeeper是一个分布式、高可用性的协调服务。在大数据产品中主要提供两个功能&#xff1a; 帮助系统避免单点故障&#xff0c;建立可靠的应用程序。提供分布式协作服务和维护配置信息。 2.ZooKeeper结构 ZooKeeper集群中的节点分为三种角色&#xff1a;Le…
阅读更多...
Linux 多线程并发Socket服务端的实现( 11 ) -【Linux通信架构系列 】

Linux 多线程并发Socket服务端的实现( 11 ) -【Linux通信架构系列 】

系列文章目录 C技能系列 Linux通信架构系列 C高性能优化编程系列 深入理解软件架构设计系列 高级C并发线程编程 设计模式系列 期待你的关注哦&#xff01;&#xff01;&#xff01; 现在的一切都是为将来的梦想编织翅膀&#xff0c;让梦想在现实中展翅高飞。 Now everythi…
阅读更多...
1221. 四平方和（超详细!!）

1221. 四平方和（超详细!!）

输入样例&#xff1a; 5输出样例&#xff1a; 0 0 1 2 本题思路&#xff1a;以空间换时间 由于暴力解法我们至少要枚举三个数&#xff0c;然后计算出第四个数 呢么需要进行三重循环,时间复杂度大概为O(n3),则会超时 所以我们要进行优化来降低时间复杂度 我们的思路是&#xf…
阅读更多...
【Rust笔记】意译解构 Object Safety for trait

【Rust笔记】意译解构 Object Safety for trait

意译解构Object Safety for trait 借助【虚表vtable】对被调用成员函数【运行时内存寻址】的作法允许系统编程语言Rust模仿出OOP高级计算机语言才具备的【专用多态Ad-hoc Polymorphism】特性。 计算机高级语言中的“多态”术语是一个泛指。它通常可被细化为 基于继承关系的“子…
阅读更多...
热风梳C22.2 NO.3亚马逊加拿大审核标准

热风梳C22.2 NO.3亚马逊加拿大审核标准

加拿大是目前亚马逊所有站点中&#xff0c;商业规模大、发展势头迅猛的站点之一。亚马逊加拿大站每月吸引近1600万访客。其优势在于在加拿大&#xff0c;目前平台的竞争较小&#xff0c;商家容易出单。既然加拿大站有这么多优势&#xff0c;那产品上架需要有哪些检测认证合规方…
阅读更多...
Rust操作MySQL

Rust操作MySQL

查询 本部分是对 「Rust入门系列」Rust 中使用 MySQL[1]的学习与记录 经常使用的时间处理库&#xff1a; chrono 流式查询使用&#xff1a; query_iter 输出到Vec使用&#xff1a; query 映射到结构体使用&#xff1a; query_map 获取单条数据使用&#xff1a; query_first 命名…
阅读更多...
消息队列——rabbitmq的不同工作模式

消息队列——rabbitmq的不同工作模式

目录 Work queues 工作队列模式 Pub/Sub 订阅模式 Routing路由模式 Topics通配符模式 工作模式总结 Work queues 工作队列模式 C1和C2属于竞争关系&#xff0c;一个消息只有一个消费者可以取到。 代码部分只需要用两个消费者进程监听同一个队里即可。 两个消费者呈现竞争关…
阅读更多...
【机器学习】了解 AUC - ROC 曲线

【机器学习】了解 AUC - ROC 曲线

一、说明 在机器学习中&#xff0c;性能测量是一项基本任务。因此&#xff0c;当涉及到分类问题时&#xff0c;我们可以依靠AUC - ROC曲线。当我们需要检查或可视化多类分类问题的性能时&#xff0c;我们使用AUC&#xff08;曲线下面积&#xff09;ROC&#xff08;接收器工作特…
阅读更多...
（八九）如何与InfluxDB交互InfluxDB HTTP API

（八九）如何与InfluxDB交互InfluxDB HTTP API

以下内容来自 尚硅谷&#xff0c;写这一系列的文章&#xff0c;主要是为了方便后续自己的查看&#xff0c;不用带着个PDF找来找去的&#xff0c;太麻烦&#xff01; 第 8 章 前言&#xff1a;如何与InfluxDB交互 1、InfluxDB启动后&#xff0c;会向外提供一套HTTP API。外部程…
阅读更多...
【机器学习】Feature Engineering and Polynomial Regression

【机器学习】Feature Engineering and Polynomial Regression

Feature Engineering and Polynomial Regression 1. 多项式特征2. 选择特征3. 缩放特征4. 复杂函数附录 首先&#xff0c;导入所需的库&#xff1a; import numpy as np import matplotlib.pyplot as plt from lab_utils_multi import zscore_normalize_features, run_gradien…
阅读更多...
级联选择框

级联选择框

文章目录 实现级联选择框效果图实现前端工具版本添加依赖main.js导入依赖级联选择框样式 后端数据库设计 实现级联选择框 效果图 实现 前端 工具版本 node.js v16.6.0vue3 级联选择框使用 Element-Plus 实现 添加依赖 在 package.json 添加依赖&#xff0c;并 npm i 导入…
阅读更多...
YouIcons-矢量图标、LOGO和插图素材下载 48000000+

YouIcons-矢量图标、LOGO和插图素材下载 48000000+

YouIcons是一个免费下载矢量图标、LOGO和插图素材下的网站&#xff0c;图标量高达千万级别&#xff0c;目前共收录48109736个&#xff0c;是世界领先的创意徽标logo社区&#xff0c;供创意人员下载、分享、成长和使用&#xff0c;是设计师获取灵感、发现并与全球设计师联系的社…
阅读更多...
PostgreSQL构建时间

PostgreSQL构建时间

– PostgreSQL构建时间 select make_timestamp(2023,7,27,7,34,16);
阅读更多...
C#——多线程之Task

C#——多线程之Task

C#——多线程之Task 前言一、Task是什么&#xff1f;二、各应用场景以及实例分析1.异步执行代码2.等待异步操作完成3.并行执行多个任务4.处理异常5.取消异步操作 三、一些其他问题1.WhenAll与WhenAny的区别 总结 前言 在代码编写过程中&#xff0c;经常会用到多线程的知识&…
阅读更多...
三子棋（超详解+完整码源）

三子棋（超详解+完整码源）

三子棋 前言一&#xff0c;游戏规则二&#xff0c;所需文件三&#xff0c;创建菜单四&#xff0c;游戏核心内容实现1.棋盘初始化1.棋盘展示3.玩家下棋4.电脑下棋5.游戏胜负判断6.game&#xff08;&#xff09;函数内部具体实现 四&#xff0c;游戏运行实操 前言 C语言实现三子棋…
阅读更多...
volley 学习笔记1--发送请求

volley 学习笔记1--发送请求

一、概览 Volley 具有以下优势&#xff1a; 自动网络请求调度。 多个并发网络连接。 透明磁盘和具有标准 HTTP 缓存一致性的内存响应缓存。 支持请求优先级。 取消请求 API。您可以取消单个请求&#xff0c;也可以设置要取消的请求的时间段或范围。 可轻松自定义&#xff…
阅读更多...
手机快充协议

手机快充协议

高通:QC2.0、QC3.0、QC3.5、QC4.0、QC5.0、 FCP、SCP、AFC、SFCP、 MTKPE1.1/PE2.0/PE3.0、TYPEC、PD2.0、PD3.0/3.1、VOOC 支持 PD3.0/PD2.0 支持 QC3.0/QC2.0 支持 AFC 支持 FCP 支持 PE2.0/PE1.1 联发科的PE&#xff08;Pump Express&#xff09;/PE 支持 SFCP 在PP…
阅读更多...
Stable Diffusion如何生成高质量的图-prompt写法介绍

Stable Diffusion如何生成高质量的图-prompt写法介绍

文章目录 Stable Diffusion使用尝试下效果prompt的编写技巧prompt 和 negative promptPrompt格式Prompt规则细节优化Guidance Scale 总结 Stable Diffusion Stable Diffusion是一个开源的图像生成AI系统,由Anthropic公司开发。它基于 Transformer模型架构,可以通过文字描述生成…
阅读更多...
学习笔记|大模型优质Prompt开发与应用课(二)|第五节:只需3步，优质Prompt秒变应用软件

学习笔记|大模型优质Prompt开发与应用课(二)|第五节:只需3步，优质Prompt秒变应用软件

原作者&#xff1a;依依│百度飞桨产品经理 一乔│飞桨开发者技术专家 分享内容 01:大模型应用简介 02:LLM应用开发范式 03: Al Studio大模型社区 04:AI对话类应用开发技巧 大模型技术爆发&#xff0c;各类应用产品涌现 文心产业级知识增强大模型 工作中的“超级助手”—…
阅读更多...
推荐文章

Copyright @ 2022~2023