c语言逆置函数invert,c语言：顺序表的实现（二 ） 就地逆置，有序合并，大小调整。...

#include

#include

#define LIST_INIT_SIZE 100

using namespace std;

struct Node

{

int *elem;

int Length;

int Listsize;

};

//函数声明部分

void Error(char *s); //错误处理函数

void printNode(Node &l); //输出函数

void InitNode(Node &L); // 初始化函数

void CreatNode(Node &l); //顺序表创建函数

void InvertNode(Node &l); //顺序表就地逆置函数

void MeryNode(Node &L1, Node &L2,Node &L3);//顺序表连接函数

void AdjustNode(Node &l); //顺序表调整函数

//函数定义部分

void Error(char *s) //错误处理函数

{

cout << s << endl;

exit(1);

}

void InitNode(Node &L) //初始化函数

{

L.elem = new int[LIST_INIT_SIZE];

if (!L.elem)

Error("Overflow!");

L.Length = 0;

L.Listsize = LIST_INIT_SIZE;

}

void CreatNode(Node &l) //创建顺序表

{

int n;

cout << "请输入元素个数：";

cin >> n;

cout << "请输入数据元素：" << endl;

for (int i = 0; i < n; i++)

{

cin >> l.elem[i];

l.Length++;

}

cout << "顺序表创建成功！" << endl;

}

void InvertNode(Node &l) //就地逆置函数

{

int n = l.Length;

for (int i = 0; i < n / 2; i++)

{

int t = l.elem[n - i - 1];

l.elem[n - i - 1] = l.elem[i];

l.elem[i] = t;

}

}

void MeryNode(Node &L1, Node &L2,Node &L3)//连接函数

{

L3.Length = L1.Length + L2.Length;

L3.elem = new int[L3.Length];

if (!L3.elem)

Error("Overflow!");

int i = 0;

int j = 0;

int k = 0;

while ((i < L1.Length) && (j < L2.Length)) //合并L1和L2

{

if (L1.elem[i] <= L2.elem[j])

{

L3.elem[k] = L1.elem[i];

i++;

k++;

}

else

{

L3.elem[k] = L2.elem[j];

j++;

k++;

}

}

while (i < L1.Length) //将L1的多余部分链到L3上

{

L3.elem[k] = L1.elem[i];

k++;

i++;

}

while (j < L2.Length) //将L2的多余部分链到L3上

{

L3.elem[k] = L2.elem[j];

k++;

j++;

}

}

void AdjustNode(Node &l)//调整函数

{

int n = l.Length;

int *temp = new int[n];

int x = 0;

int y = n - 1;

for (int i = 0; i < n; i++)

{

if (l.elem[i] < 0)

{

temp[x] = l.elem[i];

x++;

}

else

{

temp[y] = l.elem[i];

y--;

}

}

for (int j = 0; j < n; j++)

{

l.elem[j] = temp[j];

}

delete[] temp;

}

void printNode(Node &l) //输出函数

{

for (int i = 0; i < l.Length; i++)

{

cout << l.elem[i] << " ";

}

cout << endl;

}

int main() //主函数测试

{

Node t1,t2,t3;

//初始化三个结构体变量

InitNode(t1);

InitNode(t2);

InitNode(t3);

//对t1的操作实现

CreatNode(t1);

cout << "顺序表t1逆置之前：" << endl;

printNode(t1);

cout << "顺序表t1逆置之后：" << endl;

InvertNode(t1);

printNode(t1);

cout << "顺序表调整之后：" << endl;

AdjustNode(t1);

printNode(t1);

//对t1的操作实现

CreatNode(t2);

cout << "顺序表t2逆置之前：" << endl;

printNode(t2);

cout << "顺序表t2逆置之后：" << endl;

InvertNode(t2);

printNode(t2);

cout << "顺序表调整之后：" << endl;

AdjustNode(t2);

printNode(t2);

cout << "顺序表合并之后：" << endl;

MeryNode(t1, t2,t3);

printNode(t3);

return 0;

}