字符处理跟写入链表，读取文件全部内容跟链表排序，将数据写入文件

 //----------------------------------------------start  CMyLinkList_h.h---------------------------------------------------------//

#include <iostream>

#include <fstream>

#include <cstdlib>

#include <string>

#include <ctime> //统计时间用

#include <conio.h> //getch用

#include <stdlib.h>    //_ltoa_s用

#define CMYLINKLIST_H

typedef unsigned long u_long;

typedef unsigned int u_int;

typedef unsigned long list_length;

class CMyLinkList

{

public:

u_long node_num = 1;

typedef struct Node //链表节点

{

long num;

struct Node *pNext;

}NODE, *PNODE;

CMyLinkList(u_long num);

CMyLinkList(){}

~CMyLinkList();

PNODE CreateList(); //构建链表

void ShowList(PNODE ); //输出链表

bool AddNode(PNODE ,u_long); //添加节点

bool DeleteNode(PNODE, u_long); //删除节点

u_long NodeNum(PNODE ); //统计节点个数

private:

PNODE Head; //保存头结点

};

class CFuntion

{

private:

const char *str; //保存输入的字符串

public:

u_long node_num = 1; //保存有效节点数

/*CFuntion();*/

~CFuntion();

void Chioces();

void SelectInput();

void DosInput(); //手写提示输入

void FilesInput(); //文件读取

void ChioceSort(); //选择排序方法

bool Check(const char *); //校验输入是否正确

u_long NodeNum(const char *); //统计有效节点数

long *StrToNum(const char *); //将输入的字符串转换为数字保存到动态数组中

};

class CSort:public CMyLinkList

{

private:

clock_t start,end; //排序开始，结束时间

double spend_time; //保存花费的时间

CMyLinkList::PNODE pHead; //保存排序后的链表

public:

~CSort();

double SpendTime(); //排序花费的时间

CMyLinkList::PNODE BubbleSort(CMyLinkList::PNODE ); //冒泡排序

CMyLinkList::PNODE InsertSort(CMyLinkList::PNODE ); //插入排序

CMyLinkList::PNODE SelectSort(CMyLinkList::PNODE ); //选择排序

void SortedShow(); //输出排序后的链表

};

 //----------------------------------------------end   CMyLinkList_h.h----------------------------------------------------------//

 //----------------------------------------------start  CFuntion.cpp--------------------------------------------------------//

#include "stdafx.h"

#include "CMyLinkList_h.h"

using namespace std;

string str1;

string str2;

long *arr = NULL;

void CFuntion::Chioces()

{

cout << "\t|--------------------------------------|" << endl;

cout << "\t| 1.手写输入       |       2.从文件读取|" << endl;

cout << "\t|--------------------------------------|" << endl;

char case_chioce; //选择方法

enum { dos = '1', file = '2'};

case_chioce = _getch();

switch (case_chioce)

{

case dos:

SelectInput();

break;

case file:

FilesInput();

break;

default:

exit(0);

break;

}

}

void CFuntion::SelectInput()

{

bool ck;

do

{

DosInput();

ck = Check(str); //校验字符串是否正确

} while (!ck);

node_num = NodeNum(str);

arr = new long[node_num]; //创建动态数组保存输入的各个数字

if (NULL == arr)

{

cout << "分配内存失败！" << endl;

exit(0);

}

arr = StrToNum(str); //得到转换后的数组

cout << "输入的数字为：" << endl;

for (u_int i = 0; i < node_num; ++i)

cout << arr[i] << " ";

cout << endl;

}

CFuntion::~CFuntion()

{

delete []arr;

}

void CFuntion::FilesInput()

{

char fileload[256] = {0};

cout << "Input like: d:/text.txt or d:\\\\text.txt" << endl;

cin >> fileload;

ifstream in(fileload, ios::in);

if (!in)

{

cout << "can't open the file.please input correct load!" << endl;

exit(0);

}

istreambuf_iterator<char> beg(in), end;

str2.assign(beg, end);

str = str2.c_str();

in.close();

if (!Check(str)) //校验字符串是否正确

{

cout << "文件里面字符串格式有误！" << endl;

exit(0);

}

node_num = NodeNum(str);

cout << node_num<<endl;

arr = new long[node_num]; //创建动态数组保存输入的各个数字

if (NULL == arr)

{

cout << "分配内存失败！" << endl;

exit(0);

}

arr = StrToNum(str); //得到转换后的数组

cout << "读取的数字为：" << endl;

for (u_int i = 0; i < node_num; ++i)

cout << arr[i] << " ";

cout << endl;

}

void CFuntion::DosInput()

{

cout << "----please input like:1,2,3,6,9,555,888,777----" << endl;

//getline(cin, str1);

cin >> str1;

str = str1.c_str();

}

bool CFuntion::Check(const char *str)

{

//↓↓↓↓↓------------ 1 未改判断负数------------↓↓↓↓↓//

//int str_length = strlen(str); //字符串长度

//int i; //循环跟下标

//if (0 == str_length)

//{

// return false;

//}

//for (i = 0; i < str_length; i++) //校验是否为这种格式：1,2,3,4 //其他如：,1,2,3 或1，，2,3或1,2,都是错误的

//{

// if ((('0' <= str[i]) && (str[i] <= '9')) || (',' == str[i]))

// {

// if ((str[i] == ',') && (str[i + 1] == ',') && (i + 1 < str_length))

// {

// return false;

// }

// }

// else

// {

// return false;

// }

//}

//if (',' == str[i - 1] || ',' == str[0]) //检测第一个跟最后一个字符是否为，号

//{

// return false;

//}

//return true;

//↑↑↑↑↑------------ 1 ------------↑↑↑↑↑//

//↓↓↓↓↓------------ 2 ------------↓↓↓↓↓//

if (0 == *str || ',' == *str) //第一个为，号的时候，返回错误

{

return false;

}

while (0 != *str)

{

if ((('0' <= *str) && (*str <= '9')) || (',' == *str) || ('-' == *str))

{

if ((*str == ',') && (*(str + 1) == ',')) //,号后面为,号，返回错误

{

return false;

}

else if ((*str == '-') && (*(str + 1) == ',')) //-号后面为,号，返回错误

{

return false;

}

else if ((('0' <= *str) && (*str <= '9')) && (*(str + 1) == '-') && \

(('0' <= *(str + 2)) && (*(str + 2) <= '9'))) //数字之间有-号，返回错误

{

return false;

}

else

{

str++;

}

}

else //输入的不是数字，是其他字符，返回错误

{

return false;

}

}

if (',' == *(str - 1) || '-' == *(str - 1)) //检测第一个跟最后一个字符是否为，号跟-号，返回错误

//if (',' == str[-1])

{

return false;

}

return true; //想到的错误就这么多，返回通过

//↑↑↑↑↑------------ 2 ------------↑↑↑↑↑//

}

u_long CFuntion::NodeNum(const char *str) //统计节点数

{

for (; 0 != *str; ++str)

{

if (*str == ',')

{

++node_num;

}

}

return node_num;

}

long *CFuntion::StrToNum(const char *str) //字符串转换为数字

{

long result = 0; //临时得到的各个数的结果

int i = 0; //动态数组下标用

while (*str != '\0')

{

if ('-' == *str) //为负数时

{

++str;

while (',' != *str && 0 != *str)

{

result = result * 10 + *str - '0';

str++;

}

str++;

result = 0 - result; //得到的正结果取反

arr[i] = result;

}

else //为大于等于0得数时

{

while (',' != *str && 0 != *str)

{

result = result * 10 + *str - '0';

str++;

}

str++;

arr[i] = result;

}

if (0 != result)

{

result = 0;

}

++i;

}

return arr;

}

CMyLinkList::CMyLinkList(u_long num)

{

Head = NULL;

node_num = num;

}

CMyLinkList::~CMyLinkList() //删除链表，释放内存

{

PNODE p = NULL;

p = Head;

while (NULL != p)

{

delete p;

p = NULL;

Head = Head->pNext;

p = Head;

}

}

CMyLinkList::PNODE CMyLinkList::CreateList() //创建链表

{

if (NULL == arr) //输入为空

{

cout << "无数据写入链表!" << endl;

exit(0);

}

Head = new Node; //创建表头，不保存数据，指向有有效数据的头结点

PNODE pTail = Head;

pTail->pNext = NULL;

for (u_long i = 0; i < node_num; ++i)

{

PNODE newlist = new Node;

newlist->num = arr[i];

pTail->pNext = newlist;

newlist->pNext = NULL;

pTail = newlist;

}

return Head;

}

void CMyLinkList::ShowList(PNODE pHead) //输出链表

{

pHead = pHead->pNext;

cout << "链表里的数据是:" << endl ;

while (NULL != pHead)

{

cout << pHead->num << " ";

pHead = pHead->pNext;

}

cout << endl;

}

bool CMyLinkList::AddNode(PNODE pHead,list_length num) //添加节点，num为要插入到第几个节点

{

PNODE newnode = new Node;

if (NULL == newnode || num > NodeNum(pHead))

{

return false;

}

PNODE p = pHead;

for (list_length i = 1; i < num; ++i) //找到要插入的那个节点的前一个节点

p = p->pNext;

cout << "insert_num:";

cin >> newnode->num;

PNODE q; //临时变量，用于交换找到的节点

q = p->pNext;

p->pNext = newnode;

newnode->pNext = q;

return true;

}

bool CMyLinkList::DeleteNode(PNODE pHead, u_long del) //删除节点，del为要删除的第几个节点

{

PNODE p = pHead;

u_long i = 0;

while (p->pNext != NULL && i<del - 1) //找到要删除的点

{

p = p->pNext;

i++;

}

if (p->pNext == NULL || i>del - 1) //判断是否为链表尾，或超出节点数

{

return false;

}

PNODE q; //创建临时变量保存要删除的节点

q = p->pNext;

p->pNext = p->pNext->pNext;

delete q;

return true;

}

u_long CMyLinkList::NodeNum(PNODE pHead) //统计有效节点个数

{

u_long i = 0;

pHead = pHead->pNext;

while (NULL != pHead)

{

++i;

pHead = pHead->pNext;

}

return i; //返回有效节点个数

}

 //----------------------------------------------end   CFuntion.cpp--------------------------------------------------------//

 //----------------------------------------------start CSort.cpp---------------------------------------------------------//

#include "stdafx.h"

#include "CMylinkList_h.h"

using namespace std;

CMyLinkList::PNODE CSort::BubbleSort(CMyLinkList::PNODE Head) //冒泡排序

{

start = clock();

u_long i ,j;

CMyLinkList::PNODE p, q;

long temp;

for (i = 0, p = Head->pNext;NULL != p; i++,p = p->pNext)

{

for ( j= i + 1,q = p->pNext;  NULL != q; j++,q = q->pNext)

{

if (p->num > q->num)

{

temp = p->num;

p->num = q->num;

q->num = temp;

}

}

}

end = clock();

pHead = Head;

return Head;

}

CMyLinkList::PNODE CSort::InsertSort(CMyLinkList::PNODE Head)

{

pHead = Head;

Head = Head->pNext;

PNODE p = NULL, q = NULL, t = NULL,first = NULL;

first = Head->pNext; //将第二个设为无序表起点

Head->pNext = NULL; //设置第一个为有序表，指针域置为NULL

start = clock(); //开始计时

while (NULL != first) //无序表不为空

{

for (t = first,q = Head; ((q != NULL) && (q->num < t->num));) //将无序表第一个数字跟有序表逐个比较

{ //如果小于有序表前一个，则有序表前一个下移一位

p = q;

q = q->pNext;

}

first = first->pNext;

if (q == Head) //如果取出的无需表数都不比有序表的数小，则加入到有序表中

{

Head = t;

}

else //

{ //

p->pNext = t; //否则，则在有序表中找到了该位置，添加入有序表

} //

t->pNext = q; //当if成立，q为NULL，不成立，q指向最后尾结点时也为NULL

}

end = clock(); //结束计时

return pHead;

}

CMyLinkList::PNODE CSort::SelectSort(CMyLinkList::PNODE Head) //选择排序

{

pHead = Head;

Head = Head->pNext;

PNODE first = NULL, min = NULL, tail = NULL, p_min = NULL, q = NULL ,p = NULL;

first = NULL;

start = clock(); //开始计时

while (Head != NULL) //在链表中找键值最小的节点

{

//注意：这里for语句就是体现选择排序思想的地方

for (p = Head, min = Head; p->pNext != NULL; p = p->pNext) //循环遍历链表中的节点，找出此时最小的节点。

{

if (p->pNext->num < min->num) //找到一个比当前min小的节点。

{

p_min = p; //保存找到节点的前驱节点：显然p->next的前驱节点是p

min = p->pNext; //保存键值更小的节点

}

}

//上面for语句结束后，就要做两件事；一是把它放入有序链表中；二是根据相应的条件判断，安排它离开原来的链表

//第一件事

if (first == NULL) //如果有序链表目前还是一个空链表

{

first = min; //第一次找到键值最小的节点

tail = min; //注意：尾指针让它指向最后的一个节点

}

else //有序链表中已经有节点

{

tail->pNext = min; //把刚找到的最小节点放到最后，即让尾指针的next指向它

tail = min; //尾指针也要指向它

}

//第二件事*/

if (min == Head) //如果找到的最小节点就是第一个节点

{

Head = Head->pNext; //显然让head指向原head->next,即第二个节点，就OK

}

else //如果不是第一个节点

{

p_min->pNext = min->pNext; //前次最小节点的next指向当前min的next,这样就让min离开了原链表

}

}

if (first != NULL) //循环结束得到有序链表first

{

tail->pNext = NULL; //单向链表的最后一个节点的next应该指向NULL

}

end = clock(); //结束计时

Head = first;

return pHead;

}

void CSort::SortedShow()

{

pHead = pHead->pNext;

cout << "排序后:" << endl;

while (NULL != pHead)

{

cout << pHead->num << " ";

pHead = pHead->pNext;

}

cout << endl;

}

double CSort::SpendTime()

{

return (double)(end - start) / CLOCKS_PER_SEC; //得到排序需要的时间

}

CSort::~CSort()

{

CMyLinkList::PNODE p, q;

p = pHead;

while (NULL != p)

{

q = p->pNext;

delete p;

p = q;

}

}

 

 //----------------------------------------------end  CSort.cpp---------------------------------------------------------//

 //----------------------------------------------start  CLinkList.cpp---------------------------------------------------------//

// CLinkList.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#ifndef CMYLINKLIST_h

#include "CMyLinkList_h.h"

#endif

using namespace std;

void Chioce();

void Chioce1();

void ListChioce(CMyLinkList::PNODE pHead);

void SortChioce(CMyLinkList::PNODE pHead);

bool WriteToFile(CMyLinkList::PNODE pHead);

int _tmain(int argc, _TCHAR* argv[])

{

CMyLinkList::PNODE pHead = NULL;

ListChioce(pHead);

return 0;

}

void Chioce()

{

cout << "\t|--------------------------------------|" << endl;

cout << "\t| 1.输出链表 | 2.添加节点 | 3.删除节点 |" << endl;

cout << "\t|--------------------------------------|" << endl;

cout << "\t| 4.排序     |其他默认退出|            |" << endl;

cout << "\t|--------------------------------------|" << endl;

}

void Chioce1()

{

system("cls");

system("color 34");

cout << "\t|--------------------------------------|" << endl;

cout << "\t| 1.冒泡排序 | 2.插入排序 | 3.选择排序 |" << endl;

cout << "\t|--------------------------------------|" << endl;

cout << "\t| 4.输出链表 | 5.添加节点 | 6.删除节点 |" << endl;

cout << "\t|--------------------------------------|" << endl;

cout << "\t| 7.写入文件 |      其他默认退出       |" << endl;

cout << "\t|--------------------------------------|" << endl;

}

void ListChioce(CMyLinkList::PNODE pHead)

{

CFuntion Fun; //构建对象，输入数据

Fun.Chioces();

u_long num = Fun.node_num; //得到需要创建多长的链表（几个节点）

CMyLinkList list(num); //构建对象创建链表

pHead = list.CreateList(); //开始创建链表

Chioce();

char case_chioce; //选择方法

u_long insert_del = 0; //要删除或要添加的第几个节点

enum { one = '1', two = '2', three = '3', four = '4' };

while (1)

{

case_chioce = _getch();

//cin >> case_chioce;

  switch (case_chioce)

{

case one:

list.ShowList(pHead);

cout << "节点数:" << list.NodeNum(pHead)<<endl;

break;

case two:

cout << "insert to node:";

cin >> insert_del;

if (list.AddNode(pHead, insert_del))

{

cout << "sucess!\n" << endl;

}

else

cout << "failed!\n" << endl;

break;

case three:

cout << "delete to node:";

cin >> insert_del;

if (list.DeleteNode(pHead, insert_del))

{

cout << "sucess!\n" << endl;

}

else

cout << "failed!\n" << endl;

break;

case four:

SortChioce(pHead);

break;

default:

exit(0);

break;

}

}

}

void SortChioce(CMyLinkList::PNODE pHead)

{

Chioce1();

u_long insert_del = 0; //要删除或要添加的第几个节点

char case_chioce; //选项

CSort sort;

enum { one = '1', two = '2', three = '3', four = '4', five = '5',six = '6',seven = '7'};

while (1)

{

/*cout << "chioce sort select:";

cin >> case_chioce;*/

case_chioce = _getch();

switch (case_chioce)

{

case one:

sort.BubbleSort(pHead);

cout << "花费时间:" << sort.SpendTime() <<"s\n继续：";

break;

case two:

sort.InsertSort(pHead);

cout << "花费时间:" << sort.SpendTime() << "s\n继续：";

break;

case three:

sort.SelectSort(pHead);

cout << "花费时间:" << sort.SpendTime() << "s\n继续：";

break;

case four:

sort.ShowList(pHead);

break;

case five:

cout << "insert to node:";

cin >> insert_del;

if (sort.AddNode(pHead, insert_del))

{

cout << "sucess!\n" << endl;

}

else

cout << "failed!\n" << endl;

break;

case six:

cout << "delete to node:";

cin >> insert_del;

sort.node_num = sort.NodeNum(pHead);

if (sort.DeleteNode(pHead, insert_del))

{

cout << "sucess!\n" << endl;

}

else

cout << "failed!\n" << endl;

break;

case seven:

if (!WriteToFile(pHead))

{

cout << "文件出错！" << endl;

exit(0);

}

else

{

cout << "写入成功！" << endl;

}

break;

default:

exit(0);

break;

}

}

}

bool WriteToFile(CMyLinkList::PNODE pHead) //写入文件，写在D：text.txt

{

pHead = pHead->pNext;

char str[20] = {0};

ofstream file1;

file1.open("d:\\Sorted.txt");

if (!file1)

{

return false;

}

file1.close();

fstream file("d:\\Sorted.txt");

if (!file)

{

return false;

}

if (file.good())

{

while (NULL != pHead)

{

file.seekg(0, ios::end);

_ltoa_s(pHead->num,str,10);

string str1,str2 = " ";

if (NULL != pHead->pNext)

{

str1 = str + str2;

}

file.write(str1.c_str(), str1.length());

pHead = pHead->pNext;

}

}

file.close();

return true;

} 

 //----------------------------------------------end   CLinkList.cpp--------------------------------------------------------//