c++关于单向链表的几种初步简单实现

 创建一个关于学生的结构体，并对其进行定义：

struct stu {
char sName[16];
char sNumber[16];
int nScore[3];
struct stu *next;
void copyLinker(struct stu * pH) {
strcpy(sName, pH->sName);
strcpy(sNumber, pH->sNumber);
nScore[0] = pH->nScore[0];
nScore[1] = pH->nScore[1];
nScore[2] = pH->nScore[2];
}
int total2() {
return nScore[0] + nScore[1] + nScore[2];
}
};

typedef  stu Cstu;

之后从文件中创建链表

Cstu * creatLinkerFromFile(const char * pFileName) {
ifstream Myin(pFileName);
int nCount;
Myin >> nCount;
Cstu *header = new  Cstu;
header->next = nullptr;
Cstu *temp = header;
for (int i = 0; i < nCount; i++) {
temp->next = new Cstu;
temp = temp->next;
Myin >> temp->sName >> temp->sNumber;
int nElement = sizeof(temp->nScore) / sizeof(int);
for (int j = 0; j < nElement; j++) {
Myin >> temp->nScore[j];
}
} 
temp->next = nullptr;//这一句如果忘了会出现循环跳不出的bug！！！
return header;

}

注意将最后的内存的next指向空，之后实现一个根据所给的人名来删除链表中的某个元素：

//0 删除第一次找到的 1 删除最后找到的 2 删除全部

bool DeleteElement(Cstu * pH, const char * pStuName, int nFlag) {


Cstu * pB = pH;
Cstu * pT = pH->next;
if (0 == nFlag) {
while (nullptr != pT) {
if (0==strcmp(pT->sName, pStuName)) {
pB->next = pT->next;
delete pT;
return true ;
}
else {
pB = pB->next;
pT = pT->next;
}
}
return false;
}else if(1==nFlag){
while (nullptr != pT ) {
if (0 == strcmp(pT->sName, pStuName)) {
pB->next = pT;
pT = pT->next;//这样是不是破坏了链表的连续性？
}
else {
pT = pT->next;
}
}
delete pB->next;
return true;
}
else if (2 == nFlag) {
while (nullptr != pT) {
if (0 == strcmp(pT->sName, pStuName)) {
pB->next = pT->next;//存下pT->next的位置
delete pT;
pT = pB->next;
}
else {
pB = pB->next;
pT = pT->next;
}
}
return true;
}
else {
cout<<"incorrect number!"<<endl;
}
return true;
}

之后写一个将链表写入文件中的函数：

//将链表写入文件中
bool WriteLinkerFile(Cstu *pH, const char * pFileName) {
ofstream Myout(pFileName);
Cstu * pT = new Cstu;
pT = pH->next;
while (nullptr != pT) {
Myout << pT->sName << " " << pT->sNumber << " ";
int nElement = sizeof(pT->nScore) / sizeof(int);
for (int i = 0; i < nElement; i++) {
Myout << pT->nScore[i] << " ";
}
Myout << endl;
pT = pT->next;
}
return true;

}

这个基本没有特别容易出错的地方；

之后

//增加一个新学生

void InsertNewStu(Cstu * pH, Cstu * aStu) {
Cstu * pNew = new Cstu();
*pNew = *aStu;

Cstu * pT = pH->next;
pH->next = pNew;

pNew->next = pT;//似乎用pStu->next不行？？？为什么

}

//之后以冒泡排序按链表中的某个属性

void swap(Cstu *p1,Cstu * p2) {
Cstu temp = *p1;
*p1 = *p2;
*p2 = temp;
}
void SortByName(Cstu *pH) {
Cstu *p3 = new Cstu;
bool isChange = true;
p3 = nullptr;
while (isChange) {
Cstu * pT = pH->next;
isChange = false;
for (; nullptr != pT->next&&nullptr != pT; pT = pT->next) {
if (strcmp(pT->sName,pT->next->sName)>0) {
p3 = pT->next;
swap(pT->sName, p3->sName);
swap(pT->sNumber, p3->sNumber);
for (int i = 0; i < 3; i++) {
swap(pT->nScore[i], p3->nScore[i]);
}
//此处的交换如果是交换整个结构体会出现错误，说不清，似乎是把指针也交换了？
isChange = true;
}
}
}

}

void SortByID(Cstu *pH) {
Cstu *p3 = new Cstu;
bool isChange = true;
p3 = nullptr;
while ( isChange) {
Cstu * pT = pH->next;
isChange = false;
for (;nullptr!=pT->next&&nullptr!=pT; pT = pT->next) {
if (strcmp(pT->sNumber, pT->next->sNumber)>0) {
p3 = pT->next;
swap(pT->sName, p3->sName);
swap(pT->sNumber, p3->sNumber);
for (int i = 0; i < 3; i++) {
swap(pT->nScore[i], p3->nScore[i]);
}
//此处的交换如果是交换整个结构体会出现错误，说不清，似乎是把指针也交换了？
isChange = true;
}
}
}
}
int total(Cstu * pH) {
int nCount = sizeof(pH->nScore) / sizeof(int);
int sum = 0;
for (int i = 0; i < nCount; i++) {
sum = sum + pH->nScore[i];
}
return sum;
}
void SortByTotalScore(Cstu * pH) {
Cstu *p3 = new Cstu;
bool isChange = true;
p3 = nullptr;
while (isChange) {
Cstu * pT = pH->next;
isChange = false;
for (; nullptr != pT->next&&nullptr != pT; pT = pT->next) {
int m = total(pT); int n = total(pT->next);//计算两个变量中的分数和
if (m>n) {
p3 = pT->next;
swap(pT->sName, p3->sName);
swap(pT->sNumber, p3->sNumber);
for (int i = 0; i < 3; i++) {
swap(pT->nScore[i], p3->nScore[i]);
}
//此处的交换如果是交换整个结构体会出现错误，说不清，似乎是把指针也交换了？
isChange = true;
}
}
}
}
void SortByScore(Cstu * pH, int nIndex) {
Cstu *p3 = new Cstu;
bool isChange = true;
p3 = nullptr;
while (isChange) {
Cstu * pT = pH->next;
isChange = false;
for (; nullptr != pT->next&&nullptr != pT; pT = pT->next) {
int m = pT->nScore[nIndex]; int n = pT->next->nScore[nIndex];//计算两个变量中的分数和
if (m>n) {
p3 = pT->next;
swap(pT->sName, p3->sName);
swap(pT->sNumber, p3->sNumber);
for (int i = 0; i < 3; i++) {
swap(pT->nScore[i], p3->nScore[i]);
}
//此处的交换如果是交换整个结构体会出现错误，说不清，似乎是把指针也交换了？
isChange = true;
}
}
}
}

对于冒泡排序，，找对结束的条件是关键。