深大OJ——数据结构专项——实验01 顺序表+链表

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

A. DS顺序表–连续操作

题目描述

建立顺序表的类，属性包括：数组、实际长度、最大长度（设定为1000）

该类具有以下成员函数：

构造函数：实现顺序表的初始化。

插入多个数据的multiinsert(int i, int n, int item[])函数，实现在第i个位置，连续插入来自数组item的n个数据，即从位置i开始插入多个数据。

删除多个数据的multidel(int i, int n)函数，实现从第i个位置开始，连续删除n个数据，即从位置i开始删除多个数据。

编写main函数测试该顺序表类。

输入

第1行先输入n表示有n个数据，即n是实际长度；接着输入n个数据

第2行先输入i表示插入开始的位置，再输入k表示有k个插入数据，接着输入k个数据

第3行先输入i表示删除开始的位置，再输入k表示要删除k个数据

输出

顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开

第1行输出创建后的顺序表内容

第2行输出执行连续插入后的顺序表内容

第3行输出执行连续删除后的顺序表内容

输入样例1

6 11 22 33 44 55 66
2 3 99 88 77
4 5

输出样例1

6 11 22 33 44 55 66
9 11 99 88 77 22 33 44 55 66
4 11 99 88 66

代码

#include 
using namespace std;
class Data {
		int *a;
		int len;
		int max;

	public:
		Data(int b[],int l,int m=1000):a(b),len(l) {
		}
		void multiinsert(int i, int n, int item[]) {
			int j,k;
			for(j=len+n-1; j>=i-1+n; j--)
				a[j]=a[j-n];
			for(j=i-1,k=0; j<i+n-1; j++,k++)
				a[j]=item[k];
			len+=n;
		}
		void multidel(int i, int n) {
			int j;
			for(j=i-1; j+n<len; j++)
				a[j]=a[j+n];
			len-=n;
		}
		void prin() {
			cout<<len<<' ';
			int i;
			for(i=0; i<len; i++)
				cout<<a[i]<<' ';
			cout<<endl;
		}
};

int main() {
	int n,i,a[1000],k,j;
	cin>>n;
	for(i=0; i<n; i++)
		cin>>a[i];
	Data p(a,n);
	p.prin();
	cin>>i>>k;
	int *item=new int [k];
	for(j=0; j<k; j++)
		cin>>item[j];
	p.multiinsert(i,k,item);
	p.prin();
	cin>>i>>n;
	p.multidel(i,n);
	p.prin();
}

B. DS顺序表–合并操作

题目描述

建立顺序表的结构体，属性包括：数组、实际长度、最大长度（设定为1000）

已知两个递增序列，把两个序列的数据合并到顺序表中，并使得顺序表的数据递增有序

输入

第1行先输入n表示有n个数据，接着输入n个数据，表示第1个序列，要求数据递增互不等

第2行先输入m表示有m个数据，接着输入m个数据，表示第2个序列，要求数据递增互不等

输出

顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开

第1行输出创建后的顺序表内容

输入样例1

3 11 33 55
5 22 44 66 88 99

输出样例1

8 11 22 33 44 55 66 88 99

代码如下：

#include 
using namespace std;
class Data {
		int *a;
		int len;
		int max;
	public:
		Data(int b[],int l,int m=1000):a(b),len(l),max(m) {
		}
		void add(Data p) {
			int i,j;
			int t;
			for(i=len,j=0; j<p.len; i++,j++)
				a[i]=p.a[j];
			len+=p.len;

			for(i=0; i<len-1; i++)
				for(j=i+1; j<len; j++) {
					if(a[i]>a[j]) {
						t=a[i];
						a[i]=a[j];
						a[j]=t;
					}
				}

		}
		void prin() {
			cout<<len<<' ';
			int i;
			for(i=0; i<len; i++)
				cout<<a[i]<<' ';
			cout<<endl;
		}
};
int main() {
	int a[1000],b[1000],n;
	cin>>n;
	int i;
	for(i=0; i<n; i++)
		cin>>a[i];
	Data p(a,n);
	
	cin>>n;
	for(i=0; i<n; i++)
		cin>>b[i];
	Data q(b,n);
	p.add(q);
	p.prin();
}

C. DS顺序表之循环移位

题目描述

顺序表的移位是循环移位，例如顺序表：1，2，3，4，5，6。如果左移1位，即原来的头元素移动到末尾，其它元素向左移1位，变成2，3，4，5，6，1。同理，如果右移1位，即原来的尾元素移动到头，其它元素向右移1位，变成6，1，2，3，4，5。以下是移位的多个例子：

原数据：1，2，3，4，5，6

左移3位：4，5，6，1，2，3，与原数据对比

右移4位：3，4，5，6，1，2，与原数据对比

请编写程序实现顺序表的循环移位操作

输入

第1行输入n表示顺序表包含的·n个数据

第2行输入n个数据，数据是小于100的正整数

第3行输入移动方向和移动的位数，左移方向为0，右移方向为1

第4行输入移动方向和移动的位数，左移方向为0，右移方向为1

注意：移动操作是针对上一次移动后的结果进行的

输出

第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开

第二行输出第一次移位操作后，顺序表内的所有数据，数据之间用空格隔开

第三行输出第二次移位操作后，顺序表内的所有数据，数据之间用空格隔开

输入样例1

5
11 22 33 44 55
0 2
1 4

输出样例1

11 22 33 44 55
33 44 55 11 22
44 55 11 22 33

代码示例：

#include 
using namespace std;

void show(int a[],int n){
	int i;
	for(i=0;i<n;i++)
	 cout<<a[i]<<' ';
	 cout<<endl;
}
int main() {
	int n,i,a[100];
	cin>>n;
	for(i=0; i<n; i++)
		cin>>a[i];
	show(a,n);
	int k,N;
	cin>>k>>N;
    if(k==0) {
		int j;
		int *b=new int[N];
		for(i=0; i<N; i++)
			b[i]=a[i];

		for(i=N; i<n; i++)
			a[i-N]=a[i];
			
		for(i=N+1,j=0; i<n; i++,j++)
			a[i]=b[j];
	}
	else{
		int j;
		int *b=new int[N];
		for(i=n-1,j=N-1; i>=n-N; i--,j--)
			b[j]=a[i];

		for(i=0; i<n-N; i++)
			a[i+N]=a[i];
			
		for(i=0; i<N; i++)
			a[i]=b[i];
	}
    show(a,n);
    
    cin>>k>>N;
    if(k==0) {
		int j;
		int *c=new int[N];
		for(i=0; i<N; i++)
			c[i]=a[i];

		for(i=N; i<n; i++)
			a[i-N]=a[i];
		for(i=N+1,j=0; i<n; i++,j++)
			a[i]=c[j];

	}
	else{
		int j;
		int *c=new int[N];
		for(i=n-1,j=N-1; i>=n-N; i--,j--)
			c[j]=a[i];

		for(i=0; i<n-N; i++)
			a[i+N]=a[i];
			
		for(i=0; i<N; i++)
			a[i]=c[i];
	}
    show(a,n);
}

D. 计算2支股票的M天运动平均价格

题目描述

给定2支股票的开盘价和收盘价的N天历史数据，

要求按开盘和收盘，分别计算每支股票的每个日期对应的M天移动平均价格。

假定两个股票数据如下：

日期 开盘/收盘 第1支股票价格S1 第2支股票价格S2

2004/7/29 close 6 4

2004/7/25 close 2 6

2004/7/26 open 8 12

2004/7/30 open 2 4

2004/7/27 close 8 10

2004/7/28 open 4 2

按M=2天计算移动平均价格，按先开盘，后收盘价，输出如下：（若某日期之前，没有M-1条的记录（日期不用连续），则不用输出）

2004/7/28 open 6 7

2004/7/30 open 3 3

2004/7/27 close 5 8

2004/7/29 close 7 7

其中, 2004/7/28日的S1的值为(8+4)/2 = 6， 即将2004/7/28和（最近1条记录2004/7/26，最近2条记录，最近M-1条记录）的价格，求和并计算平均。

输入

第1行：N天记录 M天平均

第2行到N+1行：N天2支股票的开盘与收盘价格（注意日期是无序的）

6 2

2004/7/29 close 6 4

2004/7/25 close 2 6

2004/7/26 open 8 12

2004/7/30 open 2 4

2004/7/27 close 8 10

2004/7/28 open 4 2

输出

每个日期的最近M条记录（包括该日期的价格在内）的平均价格（若某日期之前没有M-1条的记录（日期不用连续），则不用输出）

2004/7/28 open 6 7

2004/7/30 open 3 3

2004/7/27 close 5 8

2004/7/29 close 7 7

输出样例1

6 2
2004/7/29 close 6 4
2004/7/25 close 2 6
2004/7/26 open 8 12
2004/7/30 open 2 4
2004/7/27 close 8 10
2004/7/28 open 4 2

输出样例1

2004/7/28 open 6 7
2004/7/30 open 3 3
2004/7/27 close 5 8
2004/7/29 close 7 7

代码示例：

#include 
using namespace std;
class DA {
	public:
		string date;
		string sta;
		int num1,num2;
};
int main() {
	int N,M;
	cin>>N>>M;
	DA *D=new DA[N];
	int i,j;
	for(i=0; i<N; i++)
		cin>>D[i].date>>D[i].sta>>D[i].num1>>D[i].num2;

			
	for(i=0; i<N-1; i++)
		for(j=i+1; j<N; j++)
			if(D[i].date>D[j].date) {
				string p,q;
				p=D[i].date;
				D[i].date=D[j].date;
				D[j].date=p;

				q=D[i].sta;
				D[i].sta=D[j].sta;
				D[j].sta=q;
				int a,b;
				a=D[i].num1;
				D[i].num1=D[j].num1;
				D[j].num1=a;

				b=D[i].num2;
				D[i].num2=D[j].num2;
				D[j].num2=b;
			}

	int count,nn1,nn2,k;
	for(i=0; i<N; i++) {
		if(D[i].sta!="open") continue;
		for(j=i-1,count=0,nn1=D[i].num1,nn2=D[i].num2; j>=0&&j<N&&count!=M-1; j--) {
			if((D[j].date<D[i].date)&&(D[i].sta==D[j].sta)) {
				count++;
				nn1+=D[j].num1;
				nn2+=D[j].num2;
			}
		}
		if(count==M-1) cout<<D[i].date<<" "<<D[i].sta<<' '<<nn1/M<<' '<<nn2/M<<endl;
	}

	for(i=0; i<N; i++) {
		if(D[i].sta!="close") continue;

		for(j=i-1,count=0,nn1=D[i].num1,nn2=D[i].num2; j>=0&&j<N&&count!=M-1; j--) {
			if((D[j].date<D[i].date)&&(D[i].sta==D[j].sta)) {
				count++;
				nn1+=D[j].num1;
				nn2+=D[j].num2;
			}
		}
		if(count==M-1) cout<<D[i].date<<" "<<D[i].sta<<' '<<nn1/M<<' '<<nn2/M<<endl;
	}
}

E. DS单链表–类实现

题目描述

用C++语言和类实现单链表，含头结点

属性包括：data数据域、next指针域

操作包括：插入、删除、查找

注意：单链表不是数组，所以位置从1开始对应首结点，头结点不放数据

类定义参考

输入

n

第1行先输入n表示有n个数据，接着输入n个数据

第2行输入要插入的位置和新数据

第3行输入要插入的位置和新数据

第4行输入要删除的位置

第5行输入要删除的位置

第6行输入要查找的位置

第7行输入要查找的位置

输出

n

数据之间用空格隔开，

第1行输出创建后的单链表的数据

每成功执行一次操作（插入或删除），输出执行后的单链表数据

每成功执行一次查找，输出查找到的数据

如果执行操作失败（包括插入、删除、查找等失败），输出字符串error，不必输出单链表

输入样例1

6 11 22 33 44 55 66
3 777
1 888
1
11
0
5

输出样例1

11 22 33 44 55 66
11 22 777 33 44 55 66
888 11 22 777 33 44 55 66
11 22 777 33 44 55 66
error
error
44

代码：

#include
#include
using namespace std;
#define  ok    0
#define  error -1

class ListNode {
public:
    int data;
    ListNode *next;

    ListNode() {
        next = NULL;
        data = 0;
    }
};

class LinkList {
public:
    ListNode *head;
    int len;

    LinkList();

    ~LinkList();

    ListNode *CreateNode(int n);

    ListNode *LL_index(int i);

    int LL_get(int i);

    int LL_insert(int i, int item);

    int LL_del(int i);

    void LL_display();
};

LinkList::LinkList() {
    head = new ListNode();
    len = 0;
}

LinkList::~LinkList() {
    ListNode *p, *q;
    p = head;
    while (p != NULL) {
        q = p;
        p = p->next;
        delete q;
    }
    len = 0;
    head = NULL;
}

int LinkList::LL_get(int i) {
    if (LL_index(i)) return LL_index(i)->data;
    else return error;
}

ListNode *LinkList::LL_index(int i) {
    int j;
    ListNode *p;
    p = head->next;
    j = 1;
    while (p != NULL && j < i) {
        p = p->next;
        j++;
    }
    if (j != i) return NULL;
    else return p;
}

ListNode *LinkList::CreateNode(int n) {
    ListNode *tail = head, *pnew;
    int i;
    for (i = 0; i < n; i++) {
        pnew = new ListNode;
        cin >> pnew->data;
        tail->next = pnew;
        tail = pnew;
    }
    pnew = NULL;
    delete pnew;
    len += n;
    return head;
}

void LinkList::LL_display() {
    ListNode *p;
    p = head->next;
    while (p) {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}

int LinkList::LL_del(int i) {
    ListNode *p = head, *q;
    int j;
    while (p->next && j < i - 1) {
        p = p->next;
        j++;
    }
    if (!p->next || j > i - 1) return error;
    q = p->next;
    p->next = q->next;
    free(q);
    return ok;
}

int LinkList::LL_insert(int i, int item) {
    ListNode *p = head, *s;
    int j = 0;
    while (p && j < i - 1) {
        p = p->next;
        j++;
    }
    if (!p || j > i - 1) return error;
    s = new ListNode;
    s->data = item;
    s->next = p->next;
    p->next = s;
    return ok;
}

int main() {
    int n, i, num;
    cin >> n;
    LinkList p;
    ListNode *head;
    head = p.CreateNode(n);
    p.LL_display();
    cin >> i >> num;
    if (p.LL_insert(i, num) == 0)
        p.LL_display();
    else cout << "error\n";
    cin >> i >> num;
    if (p.LL_insert(i, num) == 0)
        p.LL_display();
    else cout << "error\n";

    cin >> i;
    if (p.LL_del(i) == 0)p.LL_display();
    else cout << "error\n";
    cin >> i;
    if (p.LL_del(i) == 0)p.LL_display();
    else cout << "error\n";

    cin >> i;
    if (p.LL_get(i) != -1) cout << p.LL_get(i);
    else cout << "error\n";
    cin >> i;
    if (p.LL_get(i) != -1) cout << p.LL_get(i);
    else cout << "error\n";
}

F. DS单链表–结点交换

题目描述

用C++实现含头结点的单链表，然后实现单链表的两个结点交换位置。

注意不能简单交换两个结点包含数据，必须通过修改指针来实现两个结点的位置交换

交换函数定义可以参考：

swap（int pa, int pb) //pa和pb表示两个结点在单链表的位置序号

swap (ListNode * p, ListNode * q) //p和q表示指向两个结点的指针

输入

第1行先输入n表示有n个数据，接着输入n个数据

第2行输入要交换的两个结点位置

第3行输入要交换的两个结点位置

输出

第一行输出单链表创建后的所有数据，数据之间用空格隔开

第二行输出执行第1次交换操作后的单链表数据，数据之间用空格隔开

第三行输出执行第2次交换操作后的单链表数据，数据之间用空格隔开

如果发现输入位置不合法，输出字符串error，不必输出单链表

输入样例1

5 11 22 33 44 55
1 4
2 6

输出样例1

11 22 33 44 55
44 22 33 11 55
error

提示

注意要用链表实现哦！

代码：

#include
#include

#define  ok    0
#define  error -1
using namespace std;

class ListNode {
public:
    int data;
    ListNode *next;

    ListNode() {
        next = NULL;
        data = 0;
    }
};

class LinkList {
public:
    ListNode *head;
    int len;

    ListNode *LL_index(int i);

    LinkList();

    ~LinkList();

    ListNode *CreateNode(int n);

    int swap(int pa, int pb);

    void LL_display();
};

LinkList::LinkList() {
    head = new ListNode();
    len = 0;
}

int LinkList::swap(int pa, int pb) {
    if ((pa < 1 || pa > len) || (pb < 1 || pb > len)) return error;

    ListNode *p, *q;
    p = new ListNode;
    p = LL_index(pa - 1);
    q = LL_index(pb - 1);

    ListNode *t = p->next;
    p->next = q->next;
    q->next = t;
    ListNode *tem = p->next->next;
    p->next->next = q->next->next;
    q->next->next = tem;
    return ok;
}

LinkList::~LinkList() {
    ListNode *p, *q;
    p = head;
    while (p != NULL) {
        q = p;
        p = p->next;
        delete q;
    }
    len = 0;
    head = NULL;
}

ListNode *LinkList::LL_index(int i) {
    int j;
    ListNode *p;
//    p = head->next;
    p = head;
    j = 0;
    while (p != NULL && j < i ) {
        p = p->next;
        j++;
    }
    return p;
}

ListNode *LinkList::CreateNode(int n) {
    ListNode *tail = head, *pnew;
    int i;
    for (i = 0; i < n; i++) {
        pnew = new ListNode;
        cin >> pnew->data;
        tail->next = pnew;
        tail = pnew;
    }
    pnew = NULL;
    delete pnew;
    len += n;
    return head;
}

void LinkList::LL_display() {
    ListNode *p;
    p = head->next;
    while (p) {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}

int main() {
    int n;
    cin >> n;
    LinkList p;
    ListNode *head;
    head = p.CreateNode(n);
    p.LL_display();

    int n1, n2;
    cin >> n1 >> n2;
    if (p.swap(n1, n2) == 0) p.LL_display();
    else cout << "error\n";
    cin >> n1 >> n2;
    if (p.swap(n1, n2) == 0) p.LL_display();
    else cout << "error\n";
}

G. DS单链表–合并

题目描述

假定两个单链表是递增有序，定义并实现以下函数，完成两个单链表的合并，继续保持递增有序

int LL_merge(ListNode *La, ListNode *Lb)

输入

第1行先输入n表示有n个数据，接着输入n个数据

第2行先输入m表示有M个数据，接着输入m个数据

输出

输出合并后的单链表数据，数据之间用空格隔开

输入样例1

3 11 33 55
4 22 44 66 88

输出样例1

11 22 33 44 55 66 88

代码

#include
#include

#define  ok    1
#define  error 0
using namespace std;

class ListNode {
public:
    int data;
    ListNode *next;

    ListNode() {
        next = NULL;
        data = 0;
    }
};

class LinkList {
public:
    ListNode *head;
    int len;


    LinkList();

//    ~LinkList();

    ListNode *CreateNode(int n);

    int LL_merge(ListNode *La, ListNode *Lb);

    void LL_display();
};

LinkList::LinkList() {
    head = new ListNode();
    len = 0;
}


//LinkList::~LinkList() {
//    ListNode *p, *q;
//    p = head;
//    while (p != NULL) {
//        q = p;
//        p = p->next;
//        delete q;
//    }
//    len = 0;
//    head = NULL;
//}


ListNode *LinkList::CreateNode(int n) {
    ListNode *tail = head, *pnew;
    int i;
    for (i = 0; i < n; i++) {
        pnew = new ListNode;
        cin >> pnew->data;
        tail->next = pnew;
        tail = pnew;
    }
    pnew = NULL;
    delete pnew;
    len += n;
    return head;
}

int LinkList::LL_merge(ListNode *La, ListNode *Lb) {
    ListNode *pa, *pb, *p;
    pa = new ListNode;
    pb = new ListNode;
    p = new ListNode;
    pa = La->next;
    pb = Lb->next;
    p = head;
    if (!pa || !pb) return error;
    while (pa && pb) {
        if (pa->data <= pb->data) {
            p->next = pa;
            p = pa;
            pa = pa->next;
        } else {
            p->next = pb;
            p = pb;
            pb = pb->next;
        }
    }
    p->next = pa ? pa : pb;
    return ok;
}

void LinkList::LL_display() {
    ListNode *p;
    p = head->next;
    while (p) {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}


int main() {
    int n;
    LinkList p, q, R;
    ListNode *La, *Lb;
    La = new ListNode;
    Lb = new ListNode;
    cin >> n;
    La = p.CreateNode(n);
    cin >> n;
    Lb = q.CreateNode(n);
    if (R.LL_merge(La, Lb))
        R.LL_display();
}

H. DS线性表—多项式相加

题目描述

对于一元多项式p(x)=p0+p1x+p2x2+…+pnxn，每个项都有系数和指数两部分，例如p2x2的系数为p2,指数为2。

编程实现两个多项式的相加。

例如5+x+2x2+3x3，-5-x+6x2+4x4，两者相加结果：8x2+3x3+4x4

其中系数5和-5都是x的0次方的系数，相加后为0，所以不显示。x的1次方同理不显示。

要求用单链表实现。

输入

第1行：输入t表示有t组测试数据

第2行：输入n表示有第1组的第1个多项式包含n个项

第3行：输入第一项的系数和指数，以此类推输入n行

接着输入m表示第1组的第2个多项式包含m项

同理输入第2个多项式的m个项的系数和指数

参考上面输入第2组数据，以此类推输入t组

假设所有数据都是整数

输出

对于每1组数据，先用两行输出两个原来的多项式，再用一行输出运算结果，不必考虑结果全为0的情况

输出格式参考样本数据，格式要求包括：

1.如果指数或系数是负数，用小括号括起来。

2.如果系数为0，则该项不用输出。

3.如果指数不为0，则用符号^{表示，例如x的3次方，表示为x}3。

4.多项式的每个项之间用符号+连接，每个+两边加1个空格隔开。

输入样例1

2
4
5 0
1 1
2 2
3 3
4
-5 0
-1 1
6 2
4 4
3
-3 0
-5 1
2 2
4
9 -1
2 0
3 1
-2 2

输出样例1

5 + 1x^1 + 2x^2 + 3x^3
(-5) + (-1)x^1 + 6x^2 + 4x^4
8x^2 + 3x^3 + 4x^4
(-3) + (-5)x^1 + 2x^2
9x^(-1) + 2 + 3x^1 + (-2)x^2
9x^(-1) + (-1) + (-2)x^1

代码：

#include
#include

#define  ok    1
#define  error 0
using namespace std;

int prin1(int a) {
    if (a < 0) {
        cout << '(' << a << ')';
        return ok;
    } else if (a > 0) {
        cout << a;
        return ok;
    } else return error;
}

int prin2(int a) {
    if (a < 0) {
        cout << "x^(" << a << ')';
        return ok;
    } else if (a > 0) {
        cout << "x^" << a;
        return ok;
    } else return error;
}

class ListNode {
public:
    int coef;
    int expn;
    ListNode *next;

    ListNode() {
        next = NULL;
        coef = 0;
        expn = 0;
    }
};

class LinkList {
public:
    ListNode *head;
    int len;

    void *add(ListNode *La, ListNode *Lb);

    LinkList();

    ListNode *CreateNode(int n);

    void LL_display();
};

LinkList::LinkList() {
    head = new ListNode();
    len = 0;
}

void *LinkList::add(ListNode *La, ListNode *Lb) {
    ListNode *pa, *pb, *p;
    p = head=La;
    pa = La->next;
    pb = Lb->next;
    while (pa != NULL && pb != NULL) {
        if (pa->expn < pb->expn) {
            p->next = pa;
            p = pa;
            pa = pa->next;
        } else if (pa->expn > pb->expn) {
            p->next = pb;
            p = pb;
            pb = pb->next;
        } else {
            int x = pa->coef + pb->coef;
            if (x == 0) {
                ListNode *pt, *pr;
                pt = pa;
                pa = pa->next;
                free(pt);
                pr = pb;
                pb = pb->next;
                free(pr);
            } else {
                ListNode *pt;
                p->next = pa;
                pa->coef = x;
                p = pa;
                pa = pa->next;
                pt = pb;
                pb = pb->next;
                free(pt);
            }
        }
    }
    if (pa == NULL) p->next = pb;
    else p->next = pa;

}

void LinkList::LL_display() {
    ListNode *p;
    p = head->next;
    int i, cnt = 0, j;
    while (p) {
        if (p->coef != 0)
            cnt++;
        p = p->next;
    }
    p = head->next;
    for (i = 1, j = 1; i <= cnt; i++,j++) {
        if (prin1(p->coef)) {
            prin2(p->expn);
            if (j != cnt) {
                cout << " + ";
            }
        }
        p = p->next;
    }
    cout << endl;
}

ListNode *LinkList::CreateNode(int n) {
    ListNode *tail = head, *pnew;
    int i;
    for (i = 0; i < n; i++) {
        pnew = new ListNode;
        cin >> pnew->coef >> pnew->expn;
        tail->next = pnew;
        tail = pnew;
    }
    pnew = NULL;
    delete pnew;
    len += n;
    return head;
}

int main() {
    int t, n;
    cin >> t;
    while (t--) {
        cin >> n;
        int i;
        LinkList p, q, R;
        ListNode *La, *Lb;
        La = p.CreateNode(n);
        p.LL_display();

        cin >> n;
        Lb = q.CreateNode(n);
        q.LL_display();

        R.add(La, Lb);
        R.LL_display();
    }
}

I. DS单链表—删除重复元素

题目描述

给定n个整数，按输入顺序建立单链表，删除其中的重复数字，输出结果链表。（要求不可以构建新结点，不可以定义新链表。在原链表上删除。）

输入

测试次数t

每组测试数据一行：

n（表示有n个整数），后跟n个数字

输出

对每组测试数据，输出删除重复数字后的结果链表表长和每个元素，具体格式见样例。

输入样例1

3
10 1 2 3 4 1 2 10 20 30 20
5 1 1 1 1 1
6 20 22 22 22 22 20

输出样例1

7: 1 2 3 4 10 20 30
1: 1
2: 20 22

代码：

#include
#include
#define  ok    0
#define  error -1
using namespace std;

class ListNode {
	public:
		int data;
		ListNode *next;

		ListNode() {
			next = NULL;
			data = 0;
		}
};

class LinkList {
	public:
		ListNode *head;
		int len;

		void LL_del();

		ListNode *LL_index(int i);

		int LL_get(int i);
		LinkList();
//
//		~LinkList();

		ListNode *CreateNode(int n);

		void LL_display();
};

LinkList::LinkList() {
	head = new ListNode();
	len = 0;
}

int LinkList::LL_get(int i) {
	if (LL_index(i)) return LL_index(i)->data;
	else return error;
}

ListNode *LinkList::LL_index(int i) {
	int j;
	ListNode *p;
	p = head->next;
	j = 1;
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	if (j != i) return NULL;
	else return p;
}
void LinkList::LL_del() {
	ListNode *P;
	int i,j;
	int num=len;
	int num1,num2;
//	num--;
//	P=LL_index(4);
//	Q=P->next;
//	P->next=Q->next;

	for(i=1; i<=len; i++) {
		num1=LL_get(i);
		for(j=i+1; j<=len; j++) {
			num2= LL_get(j);
			if(num1==num2) {
				ListNode *Q;
//				num--;
				P=LL_index(j-1);
				Q=P->next;
				P->next=Q->next;
				free(Q);
				len--;
				j--;
			}
		}

	}
	LL_display();

}
//
//LinkList::~LinkList() {
//	ListNode *p, *q;
//	p = head;
//	while (p != NULL) {
//		q = p;
//		p = p->next;
//		delete q;
//	}
//	len = 0;
//	head = NULL;
//}

void LinkList::LL_display() {
	ListNode *p;
	p = head->next;
	cout<<len<<':';
	while (p) {
		cout << ' '<< p->data ;
		p = p->next;
	}
	cout << endl;
}

ListNode *LinkList::CreateNode(int n) {
	ListNode *tail = head, *pnew;
	int i;
	for (i = 0; i < n; i++) {
		pnew = new ListNode;
		cin >> pnew->data;
		tail->next = pnew;
		tail = pnew;
	}
	pnew = NULL;
	delete pnew;
	len += n;
	return head;
}

int main() {
	int t, n;
	cin >> t;
	while (t--) {
		cin >> n;
		int i;
		LinkList p;
		ListNode *head;
		head = p.CreateNode(n);//创建链表对了
		p.LL_del();
//		p.LL_display();
	}
}