第二章 线性表

顺序表

Microsoft Visual Studio 2012实现：

头文件：顺序表基本操作函数.h

源文件：顺序表.cpp

顺序表基本操作函数.h
#include<iostream>

using namespace std;

const int LIST_INIT_SIZE=100;
const int LIST_INCREMENT=100;

typedef struct{
int *elem;
int len;
int listsize;
}sqlist;

void error_message(char *s){
cout<<s<<endl;
exit(1);
}

void increment(sqlist &L){
int *p=new int[L.listsize+LIST_INCREMENT];
if(p==nullptr)error_message("内存分配失败");
for(int i=0;i<L.len;i++)p[i]=L.elem[i];
delete[]L.elem;
L.elem=p;
L.listsize+=LIST_INCREMENT;
delete[] p;
p=nullptr;
}

void init_sqlist(sqlist &L){
L.elem=new int[LIST_INIT_SIZE];
L.len=0;
L.listsize=LIST_INIT_SIZE;
}

int locate_elem_sq(sqlist L,int e){
int i;//i表示位置，从1开始
for(i=1;i<=L.len && L.elem[i-1]!=e;++i);
if(i<=L.len)return i;
return 0;
}
//插入第i个元素之前，i从1开始
void insert_sqlist(sqlist &L,int i,int e){
if(i<1 || i>L.len+1)error_message("i值非法");
if(L.len>=L.listsize)increment(L);
for(int j=L.len-1;j>=i-1;j--)
L.elem[j+1]=L.elem[j];
L.elem[i-1]=e;
L.len++;
}

void delete_sqlist(sqlist &L,int i,int &e){
if(i<1 || i>L.len)error_message("i值非法");
e=L.elem[i-1];
for(int j=i;j<L.len;j++)
L.elem[j-1]=L.elem[j];
L.len--;
}

void destroy_sqlist(sqlist &L){
delete[] L.elem;
L.elem=nullptr;
L.len=0;
L.listsize=0;
}

顺序表.cpp
#include<iostream>
#include<cstdlib>
#include"顺序表基本操作函数.h"

using namespace std;

void print(sqlist L){
for(int i=0;i<L.len;i++){
if(i==0)cout<<L.elem[i];
else cout<<" "<<L.elem[i];
}
cout<<endl;
}

//例2.1已知两个集合A,B，求A=AUB
void _union(sqlist &A,sqlist &B){
for(int i=0;i<B.len;i++){
if(!locate_elem_sq(A,B.elem[i]))
insert_sqlist(A,A.len+1,B.elem[i]);
}
}
//例2.2把非纯集合C的纯集合用D表示
void purify_set(sqlist &A,sqlist &B){
int cnt=1;
for(int i=0;i<A.len;i++){
if(!locate_elem_sq(B,A.elem[i]))
insert_sqlist(B,cnt++,A.elem[i]);
}
}

//例2.3判断A,B两个集合是否相等
bool isequal(sqlist A,sqlist B){
if(A.len!=B.len)return false;
sqlist C;
init_sqlist(C);
for(int i=0;i<A.len;i++)
insert_sqlist(C,i+1,A.elem[i]);
bool flag=true;
for(int i=0;i<B.len;i++){
int loc=locate_elem_sq(C,B.elem[i]);
if(loc){
int tmp;
delete_sqlist(C,loc,tmp);
}
else{
flag=0;
break;
}
}
if(C.len==0 && flag){
destroy_sqlist(C);
return true;
}
else{
destroy_sqlist(C);
return false;
}
}
//例2.4比较两个集合的字典序大小，类似于字符串大小比较，A>B返回1，A=B返回0，A<B返回-1
int compare(sqlist A,sqlist B){
for(int i=0;i<A.len && i<B.len;i++){
if(A.elem[i]>B.elem[i])return 1;
else if(A.elem[i]<B.elem[i])return -1;
}
if(A.len>B.len)return 1;
else if(A.len==B.len)return 0;
else return -1;
}
//例2.5交换E(E1,E2,E3,E4)两个序列的位置,(1,2,)(3,4,5)变为(3,4,5,)(1,2)
//例2.5（方案一）
void exchange1(sqlist &A,int m,int n){
int *p=new int[m+n+5];
if(p==nullptr)error_message("内存分配失败");
int cnt=0;
for(int i=m;i<m+n;i++)
p[cnt++]=A.elem[i];
for(int i=0;i<m;i++)
p[cnt++]=A.elem[i];
for(int i=0;i<A.len;i++){
A.elem[i]=p[i];
}
delete[] p;
p=nullptr;
}
//例2.5（方案二）先写右移一位的函数，再执行n次，达到效果
void right_move(sqlist &A){
int tmp=A.elem[A.len-1];
for(int i=A.len-2;i>=0;i--)
A.elem[i+1]=A.elem[i];
A.elem[0]=tmp;
}
void exchange2(sqlist &A,int m,int n){
for(int i=0;i<n;i++)
right_move(A);
}
//例2.5（方案三）一步到位右移n位
void exchange3(sqlist &A,int m,int n){
int *p=new int[m+n+5];
if(!p)error_message("内存分配失败");
for(int i=0;i<A.len;i++)
p[(i+n)%(m+n)]=A.elem[i];
int tmp;
while(A.len){
delete_sqlist(A,A.len,tmp);
}
for(int i=1;i<=m+n;i++)
insert_sqlist(A,i,p[i-1]);
delete[] p;p=nullptr;
}
//例2.5（方案四）逆置三次（类似于第一章 解题指导与示例7的方案四算法）
void invert(sqlist &A,int i,int j){
for(int k=i;k<=(i+j)/2;k++)
swap(A.elem[i+j-k],A.elem[k]);
}
void exchange4(sqlist &A,int m,int n){
invert(A,0,m-1);
invert(A,m,m+n-1);
invert(A,0,m+n-1);
}
//把两个非减表合并为一个非减表
void merge_sqlist(sqlist L1,sqlist L2,sqlist &L){
int i=0,j=0;
int cnt=1;
while(i<L1.len && j<L2.len){
if(L1.elem[i]<L2.elem[j]){
insert_sqlist(L,cnt++,L1.elem[i++]);
}
else{
insert_sqlist(L,cnt++,L2.elem[j++]);
}
}
while(i<L1.len)insert_sqlist(L,cnt++,L1.elem[i++]);
while(j<L2.len)insert_sqlist(L,cnt++,L2.elem[j++]);
}

//向有序表(非减)中插入元素后，仍然有序
void sqlist_insert_order(sqlist &L,int e){
int i=L.len-1;
while(i>=0 && e<L.elem[i]){
L.elem[i+1]=L.elem[i];
i--;
}
L.elem[i+1]=e;
L.len++;
}

//将有序顺序表中重复的元素，保留一个，其余删除
void sqlist_purify(sqlist &L){
int i=-1,j=0;
while(j<L.len){
if(j==0 || L.elem[i]!=L.elem[j])
L.elem[++i]=L.elem[j];
j++;
}
L.len=i+1;
}

//筛选顺序表中的非负数
void sqlist_filter(sqlist &L){
int i=0,j=0;
for(;i<L.len;i++){
if(L.elem[i]>=0){
if(i!=j)
L.elem[j]=L.elem[i];
j++;
}
}
L.len=j;
}

//删除线性表中第i个元素起的k个元素
void sqlist_delete_k(sqlist &L,int i,int k){
if(!(i>=1 && i<=L.len && k>=0 && i-1+k<=L.len))
error_message("删除元素的位置或者个数错误");
int e;
while(k--){
delete_sqlist(L,i,e);
}
}

int main()
{
int a[5]={1,2,3};
int b[5]={4,5};
int c[10]={1,2,2,3,4,5,5,6,7,7};
sqlist A,B,C,D,E1,E2,E3,E4,F,G;
init_sqlist(A);
init_sqlist(B);
init_sqlist(C);
init_sqlist(D);
init_sqlist(E1);init_sqlist(E2);init_sqlist(E3);init_sqlist(E4);
init_sqlist(F);
init_sqlist(G);

for(int i=1;i<=3;i++)insert_sqlist(A,i,a[i-1]);
for(int i=1;i<=2;i++)insert_sqlist(B,i,b[i-1]);
for(int i=1;i<=10;i++)insert_sqlist(C,i,c[i-1]);
for(int i=1;i<=5;i++)insert_sqlist(E1,i,i);
for(int i=1;i<=5;i++)insert_sqlist(E2,i,i);
for(int i=1;i<=5;i++)insert_sqlist(E3,i,i);
for(int i=1;i<=5;i++)insert_sqlist(E4,i,i);
for(int i=1;i<=3;i++)insert_sqlist(F,i,i+2);

//例2.1求两个集合的并集
cout<<"A: ";print(A);
cout<<"B: ";print(B);
_union(A,B);
cout<<"A(AUB): ";
print(A);

cout<<endl;
//例2.2把非纯集合C的纯集合用集合D表示
cout<<"C(非纯集合): ";print(C);
purify_set(C,D);
cout<<"D(C的纯集合): ";
print(D);

cout<<endl;
//例2.3判断A,B两个集合是否相同
cout<<"A"<<(isequal(A,B)?"=":"!=")<<"B"<<endl;
cout<<"B"<<(isequal(B,B)?"=":"!=")<<"B"<<endl;

cout<<endl;
//例2.4比较A,C两个集合字典序的大小，类似于字符串比较大小
int tmp=compare(A,C);
if(tmp==1)cout<<"A>C"<<endl;
else if(tmp==0)cout<<"A=C"<<endl;
else cout<<"A<C"<<endl;

cout<<endl;
//例2.5交换E(E1,E2,E3,E4)两个序列的位置,(1,2,)(3,4,5)变为(3,4,5,)(1,2)
//例2.5（方案一）
exchange1(E1,2,3);
print(E1);
//例2.5（方案二）
exchange2(E2,2,3);
print(E2);
//例2.5（方案三）一步到位右移n位
exchange3(E3,2,3);
print(E3);
//例2.5（方案四）逆置三次（类似于第一章 解题指导与示例7的方案四算法）
exchange4(E4,2,3);
print(E4);

cout<<endl;
//把两个有序的顺序表B，F合并成一个有序的顺序表G
cout<<"B,F有序合并："<<endl;
merge_sqlist(B,F,G);
cout<<"G: ";
print(G);

//G中插入2，仍然有序
cout<<"G中插入2，仍然有序"<<endl;
cout<<"G: ";
sqlist_insert_order(G,2);
print(G);

//去除G中的重复元素
cout<<"把G净化为集合，G: ";
sqlist_purify(G);
print(G);

//G中插入几个负数
for(int i=5;i<=8;i++)
insert_sqlist(G,i,i-100);
cout<<"G插入几个负数后，G:";
print(G);
cout<<"筛出G中的负数后，G：";
sqlist_filter(G);
print(G);

//删除G中第2个元素开始的2个元素
cout<<"删除G中第2个元素开始的2个元素后，G: ";
sqlist_delete_k(G,2,2);
print(G);

}

链表

Microsoft Visual Studio 2012实现：

头文件：链表.h

源文件：链表.cpp

输入方式：重定向，文件内容如下，

5 4 3 2 1

1 2 3 3 3 4 5

7 8 9

12 13 14 15 16 17

链表.h
#include<iostream>
#include<string>

using namespace std;

typedef int elemtype;

typedef struct Node{
elemtype data;
struct Node *next;
}node,*linklist;

//定义双向链表类型
typedef struct dnode{
elemtype data;
struct dnode *prior,*next;
}dnode,*dlinklist;

//错误提示函数
void error_message(string s){
cout<<s<<endl;
exit(-1);
}

//头插法建立链表
void create_linklist1(linklist &L,int n){
L=new node;
if(L==nullptr)error_message("分配内存失败");
L->next=nullptr;
for(int i=0;i<n;i++){
node *p=new node;
if(p==nullptr)error_message("分配内存失败");
cin>>p->data;
p->next=L->next;L->next=p;
}
}

//尾插法建立链表
void create_linklist2(linklist &L,int n){
L=new node;
if(L==nullptr)error_message("分配内存失败");
L->next=nullptr;
node *rear=L;
for(int i=0;i<n;i++){
node *p=new node;
if(p==nullptr)error_message("分配内存失败");
p->next=nullptr;//忘记写这句，程序崩溃！
cin>>p->data;
rear->next=p;
rear=p;//rear始终指向链表的最后一个节点
}
}

//尾插法建立双向循环链表
void create_dlinklist2(dlinklist &L,int n){
L=new dnode;
if(L==nullptr) error_message("分配内存失败");
L->next=nullptr;
L->prior=nullptr;
dnode *rear=L;
for(int i=0;i<n;i++){
dnode *p=new dnode;
if(p==nullptr) error_message("分配内存失败");
cin>>p->data;
p->next=nullptr;
p->prior=rear;
rear->next=p;
rear=p;
}
rear->next=L;
}

//销毁链表
void linklist_destroy(linklist &L){
node *p=nullptr,*head=L->next;
while(head){
p=head->next;
delete head;
head=p;
}
}

//清空链表
void linklist_clear(linklist &L){
node *p=L->next;
node *q=nullptr;
while(p){
q=p->next;
delete p;
p=q;
}
L->next=nullptr;
}

//遍历链表，输出所有数据值
void linklist_traverse(linklist L){
node *p=L->next;
while(p!=nullptr){
cout<<p->data<<" ";
p=p->next;
}
cout<<endl;
}

//遍历双向链表，输出所有数据值
void dlinklist_traverse(dlinklist L,int n){
dnode *p=L->next;
int i=0;
while(p!=nullptr && i<n){
cout<<p->data<<" ";
p=p->next;
i++;
}
cout<<endl;
}

//求链表长度
int linklist_length(linklist L){
node *p=L->next;
int cnt=0;
while(p!=nullptr){
cnt++;
p=p->next;
}
return cnt;
}

//查找链表中第i个元素，并存放在e中
bool get_elem(linklist L,int i,elemtype &e){
if(i<1 || i>linklist_length(L))return false;
node *p=L;
while(i--){
p=p->next;
}
e=p->data;
return true;
}

//查找链表中第一个与e相等的节点的位置
int locate_elem(linklist L,elemtype e){
int i=1;
node *p=L->next;
while(p!=nullptr && p->data!=e){
i++;
p=p->next;
}
if(p!=nullptr)return i;
else return 0;
}

//查找链表中与e相等的节点的个数
int e_num(linklist L,elemtype e){
int cnt=0;
node *p=L->next;
while(p){
if(p->data==e)cnt++;
p=p->next;
}
return cnt;
}

//在链表的第i个元素之前插入新节点
void linklist_insert(linklist &L,int i,elemtype e){
node *pi=L;
int j=0;
while(pi && j<i-1){
j++;
pi=pi->next;
}
if(!pi || j>i-1){   //若pi=nullptr，则插入节点的位置大于了链表的长度加1，j>i-1，则i<=1
//i=1，表明插入第一个位置，i<1，表明插入位置不存在
error_message("插入位置不存在");

}
node *p=new node;
if(p==nullptr)error_message("内存分配失败");
p->data=e;
p->next=pi->next;
pi->next=p;
}

//双向链表的第i个元素之前插入新节点
void dlinklist_insert(dlinklist &L,int i,elemtype e){
dnode *pi=L;
int j=0;
while(pi && j<i-1){
j++;
pi=pi->next;
}
if(!pi || j>i-1){
error_message("插入位置不存在");
}
dnode *p=new dnode;
if(p==nullptr) error_message("内存分配失败");
p->data=e;
p->next=pi->next;
p->prior=pi;
pi->next->prior=p;
pi->next=p;
}

//逆置链表
void linklist_reverse(linklist &L){
node *p=L->next;
node *post=nullptr;
node *pre=nullptr;
while(p){
post=p->next;
p->next=pre;
pre=p;
p=post;
}
L->next=pre;
}

//删除链表中第i个节点，保存在e中
void linklist_delete(linklist &L,int i,elemtype &e){
node *p=L;
int j=0;
while(p->next && j<i-1){
p=p->next;
j++;
}
if(!p->next || j>i-1){          //若p->next=nullptr，则删除的节点要么不存在，要么是nullptr，j>i-1表明i<=0
error_message("要删除的元素位置错误");
}
node *tmp=p->next;
e=tmp->data;
p->next=tmp->next;
delete tmp;
}

//删除链表中的偶数序号的结点
void linklist_delete_even(linklist &L){
node *p=L->next;
node *q=nullptr;
while(p && p->next){
q=p->next;
p->next=q->next;
p=q->next;
delete q;
}
}

//删除双向循环链表中的第i个元素，保存在e中
void dlinklist_delete(dlinklist &L,int i,elemtype &e){
dnode *p=L;
int j=0;
while(p->next && j<i){
p=p->next;
j++;
}
if(!p || j>i){
error_message("要删除的元素位置错误");
}
e=p->data;
p->prior->next=p->next;
p->next->prior=p->prior;
delete p;
}

//两个有序链表合并成一个有序表
void linklist_merge(linklist L1,linklist L2,linklist &L3){
L3=new node;
if(L3==nullptr)
error_message("内存分配失败");
L3->next=nullptr;
node *p1=L1->next;
node *p2=L2->next;
node *rear=L3;
while(p1 && p2){
if(p1->data < p2->data){
node *tmp=new node;
if(tmp==nullptr)
error_message("内存分配失败");
tmp->next=nullptr;
tmp->data=p1->data;
rear->next=tmp;
rear=tmp;
p1=p1->next;
}
else{
node *tmp=new node;
if(tmp==nullptr)
error_message("内存分配失败");
tmp->next=nullptr;
tmp->data=p2->data;
rear->next=tmp;
rear=tmp;
p2=p2->next;
}
}
while(p1){
node *tmp=new node;
if(tmp==nullptr)
error_message("内存分配失败");
tmp->next=nullptr;
tmp->data=p1->data;
rear->next=tmp;
rear=tmp;
p1=p1->next;
}
while(p2){
node *tmp=new node;
if(tmp==nullptr)
error_message("内存分配失败");
tmp->next=nullptr;
tmp->data=p2->data;
rear->next=tmp;
rear=tmp;
p2=p2->next;
}
}

//链表求两个集合A,B的并集A=AUB
void linklist_union(linklist &A,linklist B){
//求A的最后一个节点的地址pre,最后用rear11表示
node *rear11=A->next;
node *pre=A;
while(rear11){
pre=pre->next;
rear11=rear11->next;
}
rear11=pre;

node *rear2=B->next;
while(rear2){
bool flag=false;
node *rear1=A->next;
while(rear1){
if(rear1->data==rear2->data){
flag=true;
break;
}
rear1=rear1->next;
}
if(!flag){
node *tmp=new node;
if(tmp==nullptr)error_message("内存分配失败");
tmp->next=nullptr;
tmp->data=rear2->data;
rear11->next=tmp;
rear11=tmp;
}
rear2=rear2->next;
}
}

//把链表改成单循环链表
void to_circle_linklist(linklist &L){
node *p=L;
while(p->next!=nullptr){
p=p->next;
}
p->next=L;
}

//合并两个链表
void linklist_combine(linklist &L1,linklist &L2){
node *p=L1;
while(p->next!=nullptr){
p=p->next;
}
p->next=L2->next;
}

链表.cpp
//下面是一个链表基本操作的测试用的程序

//下面是一个链表基本操作的测试用的程序

#include<iostream>
#include"链表.h"

using namespace std;

int main()
{
freopen("input.txt","r",stdin);

linklist list1=nullptr;
linklist list2=nullptr;
linklist list3=nullptr;
linklist list4=nullptr;
dlinklist list5=nullptr;

//头插法创建一个长度是5的链表：1,2,3,4,5
cout<<"下面头插法创建链表list1，请输入5，4，3，2，1"<<endl;
create_linklist1(list1,5);
cout<<"list1: ";
linklist_traverse(list1);//输出链表

//尾插法创建一个长度为5的链表：1,2,3,3,3,4,5
cout<<"下面尾插法创建链表list2，请输入1，2，3，3，3，4，5"<<endl;
create_linklist2(list2,7);
cout<<"list2: ";
linklist_traverse(list2);
//尾插法创建链表list3: 7,8,9
create_linklist2(list3,3);
cout<<"list3: ";
linklist_traverse(list3);
cout<<endl;

//求链表长度
cout<<"list1的长度是"<<linklist_length(list1)<<endl;

//查找
elemtype e1;
get_elem(list1,5,e1);
cout<<"list1中第5个元素是"<<e1<<endl;
cout<<endl;

cout<<"list2中第1个3的位置是"<<locate_elem(list2,3)<<endl;
cout<<"list2中与3相等的节点的个数是"<<e_num(list2,3)<<endl;

//插入
cout<<"list2中第4个节点之前插入6后的list2: "<<endl;
linklist_insert(list2,4,6);
linklist_traverse(list2);

//逆置链表
cout<<"list2逆置后：";
linklist_reverse(list2);
linklist_traverse(list2);

//删除操作
elemtype e2;
linklist_delete(list2,2,e2);
cout<<"删除list2的第2个元素"<<e2<<"后，list2: ";
linklist_traverse(list2);
cout<<endl;

//两个有序表合并成一个有序表
cout<<"list1和list3合并为list4: ";
linklist_merge(list1,list3,list4);
linklist_traverse(list4);
cout<<endl;

//求两个集合A，B的并集A（A=AUB）
linklist_union(list1,list3);
cout<<"list1,list3两个集合的并集为list1(list1 U list3)：";
linklist_traverse(list1);

cout<<endl;
cout<<"***************************************************************************"<<endl;
cout<<"目前四个链表如下"<<endl;
cout<<"list1:";linklist_traverse(list1);
cout<<"list2:";linklist_traverse(list2);
cout<<"list3:";linklist_traverse(list3);
cout<<"list4:";linklist_traverse(list4);
cout<<endl;

//把list1,list2改成单循环链表，并合并成一个链表
cout<<"list1,list2合并成list1"<<endl;
linklist_combine(list1,list2);
cout<<"list1:";linklist_traverse(list1);
cout<<endl;

//建立双向链表list5:12,13,14,15,16,17
cout<<"创建双向循环链表list5"<<endl;
create_dlinklist2(list5,6);
cout<<"list5:";
dlinklist_traverse(list5,6);
cout<<endl;

//双向循环链表list5的第3个元素之前插入666
cout<<"list5的第3个元素之前插入666"<<endl;
dlinklist_insert(list5,3,666);
cout<<"list5: ";
dlinklist_traverse(list5,7);
cout<<endl;

//双向循环链表list5删除第4个元素
elemtype e3;
dlinklist_delete(list5,4,e3);
cout<<"删除list5中的第4个元素"<<e3<<"后，list5: ";
dlinklist_traverse(list5,6);
cout<<endl;

//删除list1中偶数序号结点
cout<<"删除偶数序号结点后，list1: ";
linklist_delete_even(list1);
linklist_traverse(list1);
return 0;
}