个人学习笔记。
C++可以使用struct和class，并且C++中与C中的struct不一样，它更像class。
参考：https://www.cnblogs.com/ccsccs/articles/4025215.html
线性表：由同类型数据元素构成有序序列的线性结构。包括数据对象集和操作集。
一、顺序存储实现（数组实现）
利用数组的连续存储空间顺序存放线性表各元素
arrlist.h
#ifndef ARRLIST_H
#define ARRLIST_H
#define MAXSIZE 20
#include<iostream>
using namespace std;
struct LNode;
typedef int ElementType;
typedef int Position;
typedef struct LNode *List;
void init(List l);
bool isEmpty(List l);
bool isLast(List l,Position p);
Position findX(List l, ElementType x);
ElementType findKth(List l, int k);
void insertX(List l, ElementType x, Position p);
void deleteP(List l, Position p);
void deleteX(List l, ElementType x);
void deleteL(List l);
void printL(List l);
typedef struct LNode
{
ElementType *data;//指向存线性表的动态存储空间的指针
Position last;//最后一个元素在数组中的位置
}ArrList;
#endifArrList.cpp
#include "stdafx.h"
#include"arrlist.h"
//初始化
void init(List l)
{
l->data = new ElementType[MAXSIZE]();
if (l->data==NULL)
{
cout << "空间用完" << endl;
exit(1);
}
l->last = -1;
}
//是否为空表
bool isEmpty(List l)
{
return l->last < 0;
}
//是否为表末尾
bool isLast(List l,Position p)
{
return p == l->last;
}
//查找第一次出现的元素x,找不到返回-1
Position findX(List l, ElementType x)
{
for (Position i = 0; i <= l->last;++i)
{
if (x==l->data[i])
{
return i;
}
}
return -1;
}
//返回第k个元素
ElementType findKth(List l, int k)
{
if (k-1>l->last||k-1<0)
{
cerr << "k无效" << endl;
}
return l->data[k-1];
}
//在位置p处插入x
void insertX(List l, ElementType x, Position p)
{
if (l->last+2>MAXSIZE||p<0)
{
cerr << "p无效" << endl;
}
else
{
for (Position i = l->last; i >= p;--i)
{
l->data[i + 1] = l->data[i];
}
l->data[p] = x;
++l->last;
}
}
//删除p处元素
void deleteP(List l, Position p)
{
if (p==-1||p>l->last)
{
cerr << "无该元素或输入p无效" << endl;
}
for (Position i = p + 1; i <= l->last; ++i)
{
l->data[i - 1] = l->data[i];
}
l->data[l->last] = 0;
--l->last;
}
//删除表中第一个x
void deleteX(List l, ElementType x)
{
Position p = findX(l, x);
deleteP(l, p);
}
void deleteL(List l)
{
if (l->data!=NULL)
{
delete[]l->data;
l->data = NULL;
}
}
void printL(List l)
{
if (l->last<0)
{
cerr << "空表" << endl;
}
else
{
for (Position i = 0; i < l->last;++i)
{
cout << l->data[i]<<ends;
}
cout << l->data[l->last] << endl;
}
}
main.cpp
#include "stdafx.h"
#include "arrlist.h"
int _tmain(int argc, _TCHAR* argv[])
{
ArrList arrlist;
List l = &arrlist;
init(l);
int input;
for (int i = 0; i < 10;++i)
{
cin >> input;
insertX(l, input, i);
}
printL(l);
deleteP(l, 5);
printL(l);
deleteX(l,10);
printL(l);
cout << findX(l,5) << endl;
cout << findKth(l,4) << endl;
return 0;
}
二、链式存储实现（链表实现）
list.h
#ifndef LIST_H
#define LIST_H
#include<iostream>
using namespace std;
typedef int ElementType;
typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;
struct Node
{
ElementType element;//结点数据
Position next;//指向下一个结点的指针
};
void init(List l);
int isEmpty(List l);
int isLast(Position p, List l);
Position findX(ElementType x, List l);
void deleteX(ElementType x, List l);
Position findPre(ElementType x, List l);
void insertX(ElementType x, List l,Position p);
void deleteL(List l);
Position header(List l);
Position first(List l);
Position advance(Position p);
void printL(List l);
#endifList.cpp
#include "stdafx.h"
#include "list.h"
void init(List l)
{
l->element = 0;
l->next = nullptr;
}
int isEmpty(List l)
{
return l->next == nullptr;
}
int isLast(Position p, List l)
{
return p->next == nullptr;
}
Position findX(ElementType x, List l)
{
Position p;
p = l->next;
while (p != nullptr&&p->element != x)
{
p = p->next;
}
return p;
}
Position findPre(ElementType x, List l)
{
Position p;
p = l;
while (p->next != nullptr&&p->next->element != x)
{
p = p->next;
}
return p;
}
void deleteX(ElementType x, List l)
{
Position p = findPre(x, l);
if (!isLast(p, l))
{
Position tmp = p->next;
p->next = tmp->next;
delete tmp;
}
}
//插在p的后面
void insertX(ElementType x, List l,Position p)
{
Position tmp;
tmp = new Node();
if (tmp == nullptr)
{
cerr<<"out of space" << endl;
}
tmp->element = x;
tmp->next = p->next;
p->next = tmp;
}
void deleteL(List l)
{
Position p, tmp;
p = l->next;
l->next = nullptr;
while (p != nullptr)
{
tmp = p->next;
delete p;
p = tmp;
}
}
Position header(List l)
{
return l;
}
Position first(List l)
{
return l->next;
}
Position advance(Position p)
{
return p->next;
}
void printL(List l)
{
Position p = l->next;
while (p!=nullptr)
{
cout << p->element << ends;
p = advance(p);
}
cout << endl;
}main.cpp
#include "stdafx.h"
#include "list.h"
int _tmain(int argc, _TCHAR* argv[])
{
Node node;
init(&node);
ElementType input;
Position p = header(&node);
cout << isEmpty(&node) << endl;
while (cin>>input)
{
insertX(input,&node,p);
p = advance(p);
}
printL(&node);
insertX(100, &node, header(&node));
printL(&node);
deleteX(100, &node);
printL(&node);
return 0;
}
三、多项式的乘法与加法
1）顺序存储结构实现
arrlist.h
#ifndef ARRLIST_H
#define ARRLIST_H
#define MAXSIZE 50
#include<iostream>
using namespace std;
typedef struct LNode
{
ElementType *data;//指向存线性表的动态存储空间的指针
Position last;//最后一个元素在数组中的位置
}*Polynomial;
typedef int ElementType;
typedef int Position;
void init(Polynomial poly);
void zeroPolynomial(Polynomial poly);
void inputPoly(Polynomial poly, ElementType x, Position p);
void addPolynomial(Polynomial poly1, Polynomial poly2, Polynomial sum);
void multiPolynomial(Polynomial poly1, Polynomial poly2, Polynomial multi);
void printPoly(Polynomial poly);
#endifArrList.cpp
#include "stdafx.h"
#include"arrlist.h"
//初始化
void init(List l)
{
l->data = new ElementType[MAXSIZE]();
if (l->data==NULL)
{
cout << "空间用完" << endl;
exit(1);
}
l->last = -1;
}
//初始化为0
void zeroPolynomial(Polynomial poly)
{
for (int i = 0; i < MAXSIZE;++i)
{
poly->data[i] = 0;
}
poly->last = 0;
}
void inputPoly(Polynomial poly,ElementType x,Position p)
{
if (p >= MAXSIZE)
cerr << "exceeded maxSize" << endl;
else
{
poly->data[p] = x;
if (poly->last<p)
{
poly->last = p;
}
}
}
//相加
void addPolynomial(Polynomial poly1, Polynomial poly2, Polynomial sum)
{
zeroPolynomial(sum);
sum->last = (poly1->last>poly2->last ? poly1->last : poly2->last);
for (int i = 0; i <= sum->last;++i)
{
sum->data[i] = poly1->data[i] + poly2->data[i];
}
}
void multiPolynomial(Polynomial poly1, Polynomial poly2, Polynomial multi)
{
zeroPolynomial(multi);
multi->last = poly1->last + poly2->last;
if (multi->last>MAXSIZE)
{
cerr << "exceeded array size" << endl;
}
else
{
for (int i = 0; i <= poly1->last; ++i)
for (int j = 0; j <= poly2->last;++j)
{
multi->data[i + j] += poly1->data[i] * poly2->data[j];
}
}
}
void printPoly(Polynomial poly)
{
int isZero = 1;
for (int i = poly->last; i >0; --i)
{
if (poly->data[i]!=0)
{
cout << poly->data[i] << " " << i << " ";
isZero = 0;
}
}
if (poly->data[0] != 0)
{
cout << poly->data[0] << " 0" << endl;
isZero = 0;
}
else if (isZero == 0)
cout << endl;
if (isZero==1)
{
cout << "0 0" << endl;
}
}main.cpp
#include "stdafx.h"
#include"arrlist.h"
int _tmain(int argc, _TCHAR* argv[])
{
LNode ln1, ln2;
Polynomial poly1=&ln1;
Polynomial poly2=&ln2;
init(poly1);
init(poly2);
int n,x,y;
cin >> n;
for (int i = 0; i < n;++i)
{
cin >> x>>y;
inputPoly(poly1, x, y);
}
cin >> n;
for (int i = 0; i < n; ++i)
{
cin >> x>>y;
inputPoly(poly2, x, y);
}
LNode ln_sum, ln_multi;
Polynomial sum = &ln_sum;
Polynomial multi = &ln_multi;
init(multi);
init(sum);
addPolynomial(poly1, poly2, sum);
multiPolynomial(poly1, poly2, multi);
printPoly(multi);
printPoly(sum);
return 0;
}输入： 两行，每行先输入多项式非零项个数，再以指数递降方式输入一个多项式非零项系数和指数
输出：输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数，零多项式应输出0 0
数组存储的话对于比较稀疏的多项式（很多0项）浪费空间，只适用于稠密的多项式，另外数组指定一个最大长度，对于项数很高的稀疏多项式的加乘不太适用。
2）链式存储结构实现
list.h
#ifndef LIST_H
#define LIST_H
#include<iostream>
using namespace std;
typedef struct PolyNode *Polynomial;
struct PolyNode
{
int coef;
int expon;
PolyNode *next;
};
Polynomial readPoly();
void appendPoly(int c, int e, Polynomial *rear);
Polynomial addPoly(Polynomial poly1, Polynomial poly2);
Polynomial multiPoly(Polynomial poly1, Polynomial poly2);
void printPoly(Polynomial poly);
#endiflist.cpp
#include "stdafx.h"
#include "list.h"
Polynomial readPoly()
{
Polynomial poly;
poly = new PolyNode();
int n, c, e;
cin >> n;
Polynomial rear = poly,tmp = poly;
while (n--)
{
cin >> c >> e;
appendPoly(c, e, &rear);
}
poly = poly->next;
delete tmp;
return poly;
}
void appendPoly(int c,int e, Polynomial *rear)
{
Polynomial p;
p = new PolyNode();
if (p==nullptr)
{
cerr << "out of space" << endl;
}
p->coef = c;
p->expon = e;
p->next = nullptr;
(*rear)->next = p;
*rear = p;
}
Polynomial addPoly(Polynomial poly1, Polynomial poly2)
{
Polynomial sum;
sum = new PolyNode();
Polynomial p1 = poly1, p2 = poly2,rear = sum;
while (p1&&p2)
{
if (p1->expon>p2->expon)
{
appendPoly(p1->coef, p1->expon, &rear);
p1 = p1->next;
}
else if (p1->expon<p2->expon)
{
appendPoly(p2->coef, p2->expon, &rear);
p2 = p2->next;
}
else
{
if (p1->coef + p2->coef==0)
{
p1 = p1->next;
p2 = p2->next;
}
else
{
appendPoly(p1->coef + p2->coef, p2->expon, &rear);
p1 = p1->next;
p2 = p2->next;
}
}
}
while (p1)
{
appendPoly(p1->coef, p1->expon, &rear);
p1 = p1->next;
}
while (p2)
{
appendPoly(p2->coef, p2->expon, &rear);
p2 = p2->next;
}
Polynomial tmp = sum;
sum = sum->next;
delete tmp;
return sum;
}
Polynomial multiPoly(Polynomial poly1, Polynomial poly2)
{
Polynomial p1, p2, rear, multi,tmp;
int c, e;
if (!poly1 || !poly1)
{
return nullptr;
}
p1 = poly1, p2 = poly2;
multi = new PolyNode();
rear = multi;
while (p2)
{
appendPoly(p1->coef*p2->coef, p1->expon + p2->expon, &rear);
p2 = p2->next;
}
p1 = p1->next;
while (p1)
{
p2 = poly2;
rear = multi;
while (p2)
{
c = p1->coef*p2->coef;
e = p1->expon + p2->expon;
while (rear->next&&rear->next->expon>e)
{
rear = rear->next;
}
if (rear->next&&rear->next->expon == e)
{
if (rear->next->coef+c==0)
{
tmp = rear->next;
rear->next = tmp->next;
delete tmp;
}
else
{
rear->next->coef += c;
}
}
else
{
tmp = new PolyNode();
tmp->coef = c;
tmp->expon = e;
tmp->next = rear->next;
rear->next = tmp;
rear = rear->next;
}
p2 = p2->next;
}
p1 = p1->next;
}
tmp = multi;
multi = multi->next;
delete tmp;
return multi;
}
void printPoly(Polynomial poly)
{
if (poly==nullptr)
{
cout << "0 0" << endl;
}
else
{
Polynomial p = poly;
cout << p->coef << " " << p->expon;
p = p->next;
while (p)
{
cout << " " << p->coef << " " << p->expon;
p = p->next;
}
cout << endl;
}
}main.cpp
#include "stdafx.h"
#include "list.h"
int _tmain(int argc, _TCHAR* argv[])
{
Polynomial poly1, poly2, sum, multi;
poly1=readPoly();
poly2=readPoly();
sum=addPoly(poly1, poly2);
multi=multiPoly(poly1, poly2);
printPoly(multi);
printPoly(sum);
return 0;
}
四、基数排序
#include "stdafx.h"
#include<iostream>
using namespace std;
#define BASE 10
#define DIGITNUM 10
//得到整数num第pos位的数
int getPosNum(int num, int pos)
{
int tmp = 1;
for (int i = 0; i < pos-1;++i)
{
tmp *= 10;
}
return (num / tmp) % 10;
}
//实现基数排序,n为排序数组大小,所需空间大小为10*n
void radixSort(int *data, int n)
{
int index;
int *bucket[BASE + 1];//二维数组，行数为10，表示以0-9为基数，第一位存放个数
for (int i = 0; i < BASE; ++i)
{
bucket[i] = new int[n]();//每个基数最多可能需要n个元素(当所有数的某一位都相等)
}
for (int i = 1; i <= DIGITNUM; ++i)//对10位以内的数进行排序
{
int flag = 0;
if (flag == 0)
{
for (int j = 0; j < n; ++j)//对每个数求第i位数
{
index = getPosNum(data[j], i);
++bucket[index][0];//个数增加
bucket[index][bucket[index][0]] = data[j];//将这个数放入对应桶中
}
//将桶中排好序的数取出重新放入data数组中，进行下一位的排序
int m = 0;
for (int k = 0; k < BASE; ++k)
{
for (int j = 1; j <= bucket[k][0]; ++j)
{
data[m++] = bucket[k][j];
}
if (bucket[k][0] == n)
{
flag = 1;
}
bucket[k][0] = 0;//桶中元素个数置零，进入下一轮
}
}
else
break;
}
}
int _tmain(int argc, _TCHAR* argv[])
{
int n;
cin >> n;
int *data;
data = new int[n]();
for (int i = 0; i < n;++i)
{
cin >> data[i];
}
radixSort(data, n);
cout << data[0];
for (int i = 1; i < n;++i)
{
cout <<" "<< data[i];
}
cout << endl;
return 0;
}