数据结构(严蔚敏版）习题集第二章课后标新号习题答案

#include<iostream>
#include<stdio.h>
#include<cmath>
#include<string.h>
using namespace std;
/****预定义****/
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
/****类型定义****/
typedef int ElemType;
typedef int Status;
typedef int * Position;
typedef struct{
ElemType *elem;
int length;
int listsize;
}Sqlist;
struct LNode;
typedef struct Node * PtrToNode;
typedef struct LNode * PToNNode;
typedef PtrToNode List;
typedef PtrToNode Location;
typedef PToNNode ListL;
typedef struct Node {//单链表
ElemType Date;
Location Next;
};
typedef struct LNode {//双向链表结点
ElemType Date;
ListL Next;
ListL prior;
ElemType freq;
};
typedef struct {
int coef;
int exp;
}PolyTerm;
typedef struct {
PolyTerm *data;
int length;
} SqPoly;
typedef struct PolyNode * Polyposition;
typedef struct PolyNode * PolyNode_L;
typedef struct PolyNode {
PolyTerm data;
Polyposition Next;
}PolyNode;
/****构建一个一元多项式的链表L****/
void CreatePolyn_L(PolyNode_L &L)
{
int num=0, coef=0, exp=0;
const char * order[7] = { "First", "Second", "Third", "Fourth", "Fifth", "Sixth", "Seventh" };
cout << "Please cin the num of the Poly: "; cin >> num;
PolyNode_L tmp,position;
L = (PolyNode_L)malloc(sizeof(PolyNode)); L->Next = NULL; position = L;
for (int i = 0; i < num; i++)
{
tmp = (PolyNode_L)malloc(sizeof(PolyNode));
cout << "The " << order[i] << " coef: "; cin >> coef;
cout << "and exp: "; cin >> exp;
tmp->data.coef = coef; tmp->data.exp = exp;
L->Next = tmp; L = L->Next;
}
L->Next = NULL;
L = position;
}
/****展示一个一元多项式的链表L****/
void Show_SqPolyn(const PolyNode_L &L)
{
PolyNode_L position; position = L;
position = position->Next;
cout << "The Sqpoly is: ";
while (position->Next != NULL)
{
cout << position->data.coef << "x^" << position->data.exp;
cout << "+";
position = position->Next;
}
cout << position->data.coef<<endl;
}
/****构建一个一元多项式的线性表L****/
Status CreatePolyn(SqPoly &L,ElemType n)
{
L.data = (PolyTerm*)malloc(n*sizeof(PolyTerm));
if (!L.data) exit(OVERFLOW);
L.length = 0;
return OK;
}
/****对一元多项式的线性表进行初始化****/
void Init_Polyn(SqPoly &L)
{
int num,coef,exp;
const char * order[7]={"First", "Second", "Third", "Fourth", "Fifth", "Sixth", "Seventh" };
cout << "Please cin the num of the Poly: "; cin >> num;
CreatePolyn(L, num);
for (int i = 0; i < num; i++)
{
cout << "The " << order[i] << " coef: "; cin >> coef;
cout << "and data: ";cin >> exp;
L.data[i].coef = coef; L.data[i].exp = exp;
L.length++;
}
}
/****构建一个空的线性表L****/
Status InitList_Sq(Sqlist &L)
{
L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
if (!L.elem) exit(OVERFLOW);
L.length = 0;
L.listsize = LIST_INIT_SIZE;
return OK;
}
/****展示线性表中的内容****/
void Show_Sq(const Sqlist &L)
{
for (int i = 0; i < L.length; i++)
{
cout << L.elem[i] <<" ";
}
}
/****展示单链表中的内容****/
void Show_List(List &L,int n)
{
Location P=L;
for (int i = 0; i < n; i++)
{
P = P->Next;
cout << P->Date << endl;
}
}
void Show_List(List &L)
{
Location P = L;
while(P->Next!=NULL)
{
P = P->Next;
cout << P->Date << endl;
}
}
/****展示双向链表中的内容****/
void Show_LList(ListL &L)
{
ListL P = L,original=L;
while (P->Next != original)
{
P = P->Next;
cout << P->Date << endl;
}
}
/*********删除单链表********/
void DeleteList(List &L) //使用说明：传入的要求是头结点
{
Location p,tmp;
p = L->Next;
L->Next = NULL;
while(p->Next!=NULL)
{
tmp = p->Next;
free(p);
p = tmp;
}
}
/******线性表删除特定位置元素的值******/
Status Delete_Sq(Sqlist &L, int num)//num为链表元素中的第num个
{
if ((num < 1) || (num > L.length))return ERROR;
for (int i = num-1; i < L.length-1; i++)
{
L.elem[i] = L.elem[i + 1];
}
L.length--;
return OK;
}
/*********线性表初始化**********/
void Sq_init(Sqlist &L,int n=0)
{
int num[10] = { 0 };
int num1[10] ={ 2, 2, 8, 12,13, 14, 17, 18, 20, 22 };
int num2[10] = { 2, 2, 2, 5, 10, 15, 16, 18, 20, 30 };
int num3[10] = { 2,4,6,8,10,12,14,16,18,20 };
if (n == 1)
{
for (int i = 0; i < 10; i++)
{
num[i] = num1[i];
}
}
if (n == 2)
{
for (int i = 0; i < 10; i++)
{
num[i] = num2[i];
}
}
if (n == 3)
{
for (int i = 0; i < 10; i++)
{
num[i] = num3[i];
}
}
for (int i = 0; i < 10; i++)
{
L.elem[i] = num[i];
L.length++;
}
}
/**********单链表初始化******/
void L_init(List &L,int n=1)
{
int num[10] ={ 2,2,3,4,5,6,7,8,9,10 };
int num1[10] = { 2, 2, 8, 12,13, 14, 17, 18, 20, 22 };
int num2[10] = { 2, 2, 2, 5, 10, 15, 16, 18, 20, 30 };
int num3[10] = { 2,4,6,8,10,12,14,16,18,20 };
if (n == 1)
{
for (int i = 0; i < 10; i++)
{
num[i] = num1[i];
}
}
if (n == 2)
{
for (int i = 0; i < 10; i++)
{
num[i] = num2[i];
}
}
if (n == 3)
{
for (int i = 0; i < 10; i++)
{
num[i] = num3[i];
}
}
Location tmp, original;
L = (PtrToNode)malloc(sizeof(Node));//创建头结点;
original = L;
L->Next = NULL;
for (int i = 0; i < 10; i++)
{
tmp = (PtrToNode)malloc(sizeof(struct Node));
tmp->Date = num[i];
//if (i == 0) { L->Next = tmp; p = tmp; tmp->Next = NULL; }//建立表的另一种方法。
//else { p->Next = tmp; p = tmp; tmp->Next = NULL; }
L->Next = tmp;
L = L->Next;
}
L->Next = NULL;
L = original;
}
/**********双向链表初始化******/
void LL_init(ListL &L, int n = 1)
{
int num[10] = { 2,2,3,4,5,6,7,8,9,10 };
int num1[10] = { 2, 2, 8, 12,13, 14, 17, 18, 20, 22 };
int num2[10] = { 2, 2, 2, 5, 10, 15, 16, 18, 20, 30 };
int num3[10] = { 2,4,6,8,10,12,14,16,18,20 };
if (n == 1)
{
for (int i = 0; i < 10; i++)
{
num[i] = num1[i];
}
}
if (n == 2)
{
for (int i = 0; i < 10; i++)
{
num[i] = num2[i];
}
}
if (n == 3)
{
for (int i = 0; i < 10; i++)
{
num[i] = num3[i];
}
}
ListL tmp, original,privious;
L = (PToNNode)malloc(sizeof(LNode));//创建头结点;
original = L;
L->Next = NULL; L->freq = 0;
for (int i = 0; i < 10; i++)
{
tmp = (PToNNode)malloc(sizeof(struct LNode));
tmp->Date = num[i]; tmp->prior = L; tmp->freq = 0;
L->Next = tmp;  L = L->Next;
}
L->Next = original; original->prior = L;
L = original;
}
/********2.11********/
void va_init(Sqlist &L)
{
int num[10] = { 2,5,6,8,10,15,16,18,20,30 };
for (int i = 0; i < 10; i++)
{
L.elem[i] = num[i];
L.length++;
}
}
Status XInsert_Sq(Sqlist &L, int X) //在线性表中插入X;
{
ElemType *newbase;
int temp=0,num=0;
if (L.length >= L.listsize) {
newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
if (!newbase)exit(OVERFLOW);
L.listsize += LISTINCREMENT;
}
for (int i = 0; i < L.length; i++)
{
if (L.elem[i] >= X)
{
num = i;
break;
}
}
for (int i = L.length-1; i >= num; i--)
{
L.elem[i+1] = L.elem[i];
}
L.elem[num] = X;
L.length++;
return OK;
}
/********2.12********/
void A_init(Sqlist &A)
{
int num[6] ={ 'x','y','y','z','x','z' };
for (int i = 0; i < 6; i++)
{
A.elem[i] = num[i];
A.length++;
}
}
void B_init(Sqlist &B)
{
int num[8] = { 'x','y','y','z','y','x','x','z' };
for (int i = 0; i<8; i++)
{
B.elem[i] = num[i];
B.length++;
}
}
int Compare_Sq(const Sqlist &A,const Sqlist &B)//比较两个线性表
{
int length=0,num=0;
Sqlist A1, B1;
InitList_Sq(A1);
InitList_Sq(B1);
length = A.length < B.length ? A.length : B.length;
for (int i = 0; i < length; i++)
{
if (A.elem[i] == B.elem[i])
{
num++;
}
else break;
}
/*也可以通过直接判断A.elem[num+1]与B.elem[num+1]来实现*/
if (num == A.length) A1.length = 0; //建立A'；
for (int i = num; i < A.length; i++)
{
A1.elem[i - num] = A.elem[i];//A1.length=A.length-num;
A1.length++;
}
if (num == B.length) B1.length = 0; //建立B'；
for (int i = num; i < B.length; i++)
{
B1.elem[i - num] = B.elem[i];//B1.length=B.length-num;
B1.length++;
}
if (A1.length == 0 && B1.length == 0)
{
return 0;//A=B;
}
else if(A1.elem[0]<B1.elem[0])
{
return 1;//A<B;
}
else if (A1.elem[0] > B1.elem[0])
{
return -1;//A>B;
}
}
/********2.13********/
Location LOCATE(List &L, ElemType &e)
{
Location original;
while (L->Next != NULL && L->Date != e)
{
L = L->Next;
}
return L;
}
/********2.14*********/
ElemType LENGTH(List &L)//返回链表长度
{
int num=0;
Location original;
original = L;
while (L->Next != NULL)
{
num++;
L = L->Next;
}
L = original;
return num;
}
/********2.15*******/
List Connect(List &a, List &b,int m,int n)//m为链表a的长度，n为链表b的长度
{//将a链表与b链表链接起来给c
List c;
if (m <= n)
{
c = a;
while (a->Next != NULL)
{
a = a->Next;
}
a->Next = b->Next;
}
else
{
c = b;
while (b->Next != NULL)
{
b = b->Next;
}
b->Next = a->Next;
}
return c;
}
/*********2.19*********/
void deleteMN(List &L,const int mink,const int maxk)//删除表中所有大于mink并且小于maxk的元素
{
Location P = L, tmp;
while ( mink < maxk && P->Next != NULL)
{
tmp = P->Next;//保留前驱
if (tmp->Date > mink)
{
if (tmp->Date < maxk)
{
P->Next = tmp->Next;
free(tmp);
}
else {
break;
}
}
else {
P = P->Next;
}
}
}
/************2.21************/
void Sq_inversion(Sqlist &L)//实现线性表的就地逆置
{
ElemType temp;
for (int i = 0; i < L.length/2; i++)
{
temp = L.elem[i];
L.elem[i] = L.elem[L.length - 1 - i];
L.elem[L.length - 1 - i] = temp;
}
}
/************2.22************/
void List_inversion(List &L)//实现链表的就地逆置
{
List P = L->Next,Privious=L,temp=L,First=P;
while (P->Next != NULL)
{
L->Next = P;
temp = P->Next;
P->Next = Privious;//记住先前的位置
Privious = P;
P = temp;
}
P->Next = L->Next;
L->Next = P;
First->Next = NULL;
}
/************2.24************/
List Merge(List &A, List &B)//A,B都为递增序列，故返回合并的序列也为递增序列;
{
List C=A,original=A;
A = A->Next; B = B->Next;
while (A != NULL && B != NULL)
{
if (A->Date <= B->Date)
{
C->Next = A;
A = A->Next;
}
else {
C->Next = B;
B = B->Next;
}
C = C->Next;
}
if (A != NULL) { C->Next = A; }
if (B != NULL) { C->Next = B; }
return original;
}
/************2.27************/
Sqlist gatherSq(Sqlist &A, Sqlist &B) //顺序表求A与B的交集
{
Sqlist C; InitList_Sq(C); C.elem[0] = -1;//定义C的第一个成员让其与A不一样
ElemType i = 0, j = 0, num = 0, index = 0;
while (i < A.length && j < B.length)
{
if(A.elem[i] == B.elem[j] && C.elem[index]!= A.elem[i])
{ 
C.elem[num] = A.elem[i]; num++; 
index = num - 1;
C.length++; i++;
}
if((A.elem[i] < B.elem[j])
|| (A.elem[i] == B.elem[j] && C.elem[index] == A.elem[i])) 
{  i++; } //为了避免C的元素重复一次
if (B.elem[j] < A.elem[i]) { j++; }
}
return C;
}
/************2.28************/
List gatherL(List &A, List&B)//线性表求A与B的交集，释放A中无用的结点,B执行完后会回到原结点
{
List C = A, originalA = A,originalB=B,tmp; C->Date = -1;//定义C的一个特征值方便下面进行
A = A->Next; B = B->Next;
while (A != NULL && B != NULL)
{
if (A->Date == B->Date && C->Date != A->Date)
{
C->Next=A;
C = C->Next;
C->Date = A->Date;
A = A->Next;
}
if(A != NULL && B != NULL)
{
if (A->Date < B->Date  || (A->Date == B->Date && C->Date == A->Date)) { tmp = A->Next; free(A); A = tmp; }
if (A->Date > B->Date) { tmp = B->Next; B = tmp; } //free(B);
}
}
C->Next = NULL;
B = originalB;
return originalA;
}
/************2.29************/
Sqlist delete_mixSq(Sqlist &A, Sqlist &B, Sqlist &C)
{
ElemType i=0,j=0;
B = gatherSq(B, C); 
B = gatherSq(A, B);
if (B.length == 0)
{
return A;
}
else
{
while (j < B.length && i < A.length)
{
if (A.elem[i] == B.elem[j] )
{
Delete_Sq(A, i+1); //删除时elem会迁移一个单位;
if (A.elem[i] != B.elem[j])
j++;
}
else i++;
}
}
return A;
}
/************2.30************/
List delete_mixL(List &A, List &B, List &C) //除去A中B与C的交集;
{
List temp,previous,original;
original = A;
B = gatherL(C, B);
B = gatherL(B, A);
Show_List(A);
if (B->Next == NULL)
{
return A;
}
else
{
B = B->Next; previous = A; A = A->Next;
while (B != NULL && A != NULL)
{
if (B->Date == A ->Date)
{
temp = A->Next; previous->Next = temp; 
free(A); A = temp;
if (B->Date != A->Date)//为了防止错过下一个值的判断，所以应在确保这次A里面的元素全删
{   //完了之后，将B指向下一个驱动元
B = B->Next;
}
}
else { previous = A; A = A->Next; }//这里一定要留有前驱，才方便后面删去
}
}
A->Next = NULL;
A = original;
return A;
}
/************2.38************/
ListL LOCATE_L(ListL &L, ElemType &e)//返回访问元素e的位置，并且记录访问频度，使得被访问多的结点
{ // 总是靠近头结点
ListL original=L,tmp,position;
while (L->Next != original && L->Date != e)
{
L = L->Next;
}
L->freq++; position = L;
while (L->prior!= original)
{
if (L->freq > L->prior->freq)//需解决的问题涉及三个节点
{
tmp = L->prior; L->prior = tmp->prior; tmp->Next = L->Next;
L->Next->prior = tmp;
tmp->prior->Next = L;//这个很关键，经常会漏掉
tmp->prior = L; L->Next = tmp;
}
else L = L->prior;
}
L = position;
return L;
}
/************2.39************/
ElemType Caculate_Polyn(const SqPoly &L,ElemType x0)//计算一元多项式x0的值
{
int value=0;
for (int i = 0; i < L.length; i++)
{
value = value + L.data[i].coef*pow(x0, L.data[i].exp);
}
return value;
}
/************2.41************/
PolyNode_L derivation(PolyNode_L &L)//求一元多项式的导数
{
PolyNode_L Position = L,original=L; L = L->Next;
while (L->Next != NULL)
{
L->data.coef = L->data.exp*L->data.coef;
L->data.exp--;
Position = L;
L = L->Next;
}
free(L); Position->Next = NULL;
L = original;
return L;
}
void main()
{
/****2.11****/
/* Sqlist va;
InitList_Sq(va);
va_init(va);
XInsert_Sq(va, 15);
Show_Sq(va);*/


/****2.12****/
/*Sqlist A, B;
InitList_Sq(A);
InitList_Sq(B);
A_init(A);
B_init(B);
int result = Compare_Sq(A, B);
cout << result << endl;*/


/****2.13****/
/*List L;
int e = 5;
L_init(L);
Show_List(L, 10);
Location p=LOCATE(L, e);
cout << p->Next->Date;*/

/****2.14****/
/*List L;
L_init(L);
int num = LENGTH(L);
cout << num << endl;
DeleteList(L);*/


/****2.15****/
/*List a, b, c;
L_init(a,1); L_init(b);
c = Connect(a, b, 10, 10);
Show_List(c);*/


/****2.19****/
/*List a; L_init(a);
deleteMN(a, 10, 30);
Show_List(a);*/


/****2.21****/
/*Sqlist L; InitList_Sq(L); Sq_init(L);
Sq_inversion(L);
Show_Sq(L);*/

/****2.22****/
/*List L; L_init(L);
List_inversion(L);
Show_List(L);*/


/****2.24****/
/*List A, B; L_init(A); L_init(B,2);
A = Merge(A, B);
List_inversion(A);
Show_List(A);*/


/****2.27****/
/*Sqlist A, B;
InitList_Sq(A); InitList_Sq(B);
Sq_init(A,1); Sq_init(B,2);
A=gatherSq(A, B); Show_Sq(A);*/


/****2.28****/
/*List A, B; L_init(A); L_init(B, 2);
A = gatherL(A, B); Show_List(A);*/


/****2.29****/
/*Sqlist A, B,C;
InitList_Sq(A); InitList_Sq(B); InitList_Sq(C);
Sq_init(A, 1); Sq_init(B, 2); Sq_init(C,3);
delete_mixSq(A, B, C);
Show_Sq(A);*/


/****2.30****/
/*List A, B, C;
L_init(A, 1); L_init(B, 2); L_init(C, 3);
delete_mixL(A, B, C);
Show_List(A);*/


/****2.33****/
/*ListL A,original; LL_init(A, 3);
original = A;
ElemType e = 18;
LOCATE_L(A, e); 
A = original;
Show_LList(A);*/


/****2.39****/
/*SqPoly L; ElemType x0,value; Init_Polyn(L);
cout << "Please enter x0: "; cin >> x0;
value=Caculate_Polyn(L,x0);
cout << "You will get the value: " << value << endl;*/


/****2.41****/
PolyNode_L L;
CreatePolyn_L(L);
Show_SqPolyn(L);
derivation(L);
Show_SqPolyn(L);
system("pause");
}