第二章线性表

1、将两个递增有序的链表合并为一个递增有序的链表，要求仍然使用原来的空间，表中不允许有原来的数据
算法思想：
两个结点比较，使用pc指向两个结点较小的链表，如果两个链表结点相等则删除b的结点，保留a的结点，pc指向a，两个链表遍历结束后，pc指向不为空的链表。

void merge(LinkList &La,LinkList &Lb)
{pa = La->next;pb = Lb->next;pc  = Lc = La;while(pa != NULL && pb != NULL){if(pa->data < pb->data)//如果pa<pb则pc指向pa，pa后移{pc->next = pa;pc = pa;              pa = pa->next;}else if(pb->data < pb->data){pc->next = pb;pc = pb;pb = pb->next;}else{pc->next = pa;//如果两个值相等，则只保留pa的结点数据，删除pb的结点数据pc = pa;pa = pa->next;//pa后移q = pb->next;//删除结点用q记录下一个结点，防止断链。delete pb;pb = q;//pb指向pb->next;}}while(pa->next != NULL){pc->next = pa;pc = pa;pc->next = NULL;}while(pc->next != NULL){pc->next = pb;pc = pb;pc->next = NULL;}
}

2、将两个非递减的链表合并为一个非递增的有序链表，表中允许有重复数据
没看懂

void merge(LinkList &La,LinkList &Lb,LinkList &Lc)
{pa = La->next;pb = Lb->next;pc = La = Lc;Lc->next = NULL;while(pa != NULL || pb != NULL)//只要存在非空的表，用q指向待摘取的元素{if(pa == NULL){q = pb;//记录前一个指针pb = pb->next;}else if(pb == NULL){q = pa;pa = pa->next;}else if(pa->data <= pb->data)//取较小者中的元素，用q指向pa，pa后移动{q = pa;pa = pa->next;}else if(pb->data < pa->data){q = pb;pb = pb->next;}q->next = Lc->next;Lc->next = q;}delete Lb;
}

3、两个递增链表，求AB的交集（共同的元素），存放在A中
算法思想
在A中保存交集的元素，两个指针同时往后移动。
将较小的指针后移并且释放空间
若相等，则尾插到A中
若A、B有剩余则分别删除剩余元素

void meger(LinkList &La,LinkList &Lb,LinkList &Lc)
{pa = La->next;pb = Lb->next;pc = Lc;Lc->next = NULL;while(pa != NULL && pb !=NULL){if(pa->data < pb->data)//比较两个结点的数据，谁小就删除谁{q = pa;pa = pa->next;delete q;}else if(pb->data < pa->data){q = pb;pb = pb->next;delete q;}else//当相等的时候把pa尾插到pc中，pa往后移动{pc->next = pa;pc = pa;pa = pa->next;}}while(pa != NULL){q = pa;pa = pa->next;delete q;}while(pab!= NULL){q = pb;pb = pb->next;delete q;}pc->next = NULL;delete Lb;}

4、求AB两个集合的差集（在A中出现，B中没有的元素），元素递增排列，同时返回元素个数
题目应该是假设A长度大于B的长度
算法思想
在A中删除AB共有的元素，不同则保留(后移)
如果A<B则往后移动，
如果A==B则说明有交集，删除该结点

void merge(LinkList &La,LinkList &Lb,LinkList &Lcint n)
{pa = La->next;pb = Lb->next;pre = La;while(pa != NULL && pb != NULL){if(pa->data < pb->data)//如果两个元素不相同，则pre指向A中的前一个指针，pa往后移动{pre = pa;//pre用来删除指针pa = pa->data;n++;}else if(pb->data < pa->data){pb = pb->data;//为什么pre不指向pb呢？}else//如果两个元素相同{pre->next = pa->next;//pre指向相同的结点q = pa;//删除结点pa = pa->data;delete q;}}
}

5、将带头结点的链表A分解成具有相同结构的链表B、C，其中B表的结点为A表中小于零的结点，C表的结点为A表中大于0的结点，要求B、C利用A的结点

void insert(LinkList &A,LinkList &B,LinkList &C)
{B = A;B->next = NULL;C = new LNode;C->next = NULL;p = A->next;while(p != NULL){if(p->data < 0){B->next = p;B = p;}else{C->next = p;C = p:}p = p->next;}B->next = NULL;C->next = NULL;
}

6、一趟遍历确定单链表中最大的结点

LNode max_(LinkList L)
{max = L->next;p = L->next;while(p != NULL){if(p->data > max)max = p->data;p = p->next;}return p;
}

7、遍历一趟链表，将链表中结点逆置
算法思想：不断的从头结点开始头插到首元结点
头插防段链，尾插留指针

void reverse_insert(LinkList &L)
{p = L->next;L->next = NULLwhile(p != NULL){           q = p->next;//头插防断链p->next = L->next;L->next = p;p = q;     }}

8、删除递增有序表中大于min小于max的所有元素
算法思想
因为表是有序，找到第一个大于min的结点用p指向它，然后从min结点开始找第一个小于max的结点
把min和max结点之间的结点都删除掉。

void delete()
{while(p != NULL && p->data >= min)//查找第一个大于min的结点{pre = p;//用于开始删除p =p->next;}if(p != NULL)//如果p不为空说明找到了小于min的结点{while(p != NULL && p->data < max)//查找第一个大于max的结点{p = p->next;}q = pre->next;pre->next  = p;}while( q != p)//如果p！=q说明两个结点没有相遇则中间有符合条件的结点{s = q;delete s;q = q->next;}
}

//可能正确，没有验证
void del(LinkList &L,int mink,int maxk)
{p = L->next;q = p;while(p != NULL){if(p->data >mink && p->data < maxk){q = p;p = p->next;delete q;}p = p->next;}
}

9、已知p结点指向双向链表的第一个结点，交换p所指向的结点和它的前缀结点的顺序。
p是双向循环的第一个结点，将p所指结点与前驱结点进行交换

void exchange(LinkList p)
{q = p->prior;q->prior->next = p;//p的前驱的前驱指向pp->pripr = q->prior;//p的前驱指向前驱的前驱q->next = p->next;//p的前驱的后续指向p的后继q->pripr = p;//p和前驱交换p->next->prior = q;//p的后继的前驱指向p的前驱p->next = q;//p的后继指向原来的前驱
}

10、删除线性表A中所有值为item的数据元素

void del(List A0)
{while(i < j){while(i < j && A[i] != item)//如果值不为item，左移指针i++;if(i < j){while(i < j && A[j] = item)//若左端不为item，左移指针j--;}if(i < j){A[i++] = A[i--];}}
}

第三章栈和队列

1、共享栈v[m]，0号栈的栈顶指针top[0]==-1为空，1号栈的栈顶指针top[1]==m为空，判断队空、队满、进栈出栈运算算法。
算法思想
共享栈初始化左指针为-1，右指针为m
两栈顶指针相邻时为满
栈顶指针指向栈顶元素

Typedef struct
{int top[2],bot[2];SElemType *V;int maxsize;
}DblStack;//共享栈结构int Init(stk s)//初始化操作
{s.top[0] = -1;s.top[1] = m;return 1;
}
int push(stk s,int i,int x)
{if(i < 0 || i > 1)return 0;if(s.top[1]-s.top[0] == 1)return 0;//栈满switch(i){case 0:s.v[++s.top[0]] = x;return 1;break;case 1:s.v[--s.top[1]] = x;return 1;break;}
}
ElemType pop(stk s,int i)
{if(i < 0|| i > 1)return 0;switch(i){case 0:if(s.top[0] == -1)//队列空{return -1;}else{return s.v[s.top[0]--];}case 1:if(s.top[1] == m)//队列满{return -1;}else{s.v[s.top[1]++];}}
}
int Empty(stk s)
{return (s.top[0]==-1 && s.top[1] == m);
}

2、判断是否为回文字符串

#define StackSize 100
typedef char DataType
typedef struct
{DataType data[StackSize];int top;
}SeqStack;int IsHuiwen(char *t)
{seqstack s;int i,len;char temp;InitStack(&s);len = strlen(t);for(i = 0;i < len/2;i++){push(s,t[i]);}while(!EmptyStack(&s)){temp = pop(s);if(temp != s[i])return 0;elsei++;}return 1;
}

3、从键盘输入整数序列，用栈存储输入整数，当a!=-1时，a进栈，当a==-1时，出栈

#define maxsize 100
void InOuts(int s[maxsize])
{int top = 0;for(i = 1;i <= n;i++){cin>>x;if(x != -1){if(top == maxsize -1){cout << "栈满";return 0;}elses[++top] = x;}else if(top == 0){cout <<"栈空";return 0;}else{cout<<s[top--];}}
}

4、将后缀表达式转为中缀表达式
算法思想：
从左向右扫描，当扫描到数时，入栈，当扫描到运算符时连续出栈两个数，进行运算在入栈，直到遇到结束符号

算法中拼数部分是核心。若遇到大于等于‘0’且小于等于‘9’的字符，认为是数。这种字符的序号减去字符‘0’的序号得出数。对于整数，每读入一个数字字符，前面得到的部分数要乘上10再加新读入的数得到新的部分数。当读到小数点，认为数的整数部分已完，要接着处理小数部分。小数部分的数要除以10（或10的幂数）变成十分位，百分位，千分位数等等，与前面部分数相加。在拼数过程中，若遇非数字字符，表示数已拼完，将数压入栈中，并且将变量num恢复为0，准备下一个数。

float expr()
{float OPND[30];init(OPND);float num = 0;cin >> x;while(x != '$'){swtich(ch){case x>='0' && x <= "9":{while((x>='0' && x <= "9") || x == '.'){if(x != "."){num = num*10+(ord(x) - ord('0'));cin>>x;}else{scale = 10.0;cin>>x;while((x>='0' && x <= "9")){num = num+(ord(x) - ord('0'))/scale;scalse = scale * 10;cin >> x;                                                                     }}}}push(OPED,num);num = 0.0;breakcase x = ' ':break;case x='+':x1 = pop(OPND);x2 = pop(OPND);push(OPND,x1+x2));break;case x='-':x1 = pop(OPND);x2 = pop(OPND);push(OPND,x2-x1));break;case x='*':x1 = pop(OPND);x2 = pop(OPND);push(OPND,x2*x1));break;case x='/':x1 = pop(OPND);x2 = pop(OPND);push(OPND,x2/x1));break;default:}}
}

5、假设IO分别代表入栈和出栈，判断那些操作序列是合法的

int juge(char A[])
{i = 0;j = k = 0;while(A[i ] != '\0'){switch(A[i]){case 'I':j++;break;case 'O':k++;if(k > j)//说明出栈比入栈多{return 0;//出错}i++;}}if(j != k){return 0;//非法}else{return 1;//合法}
}

6、带头结点的循环队列，置空、判空、入队、出队

typedef struct queuenode
{Datatype data;struct queuenode *next;
}QueueNode;
typedef struct
{queuenode *next;
}LinkQueue;void InitQueue(LinkQueue *Q)
{QueueNode *s;Q->rear = Q->rear->next;delete s;
}
int EmptyQueue(LinkQueue *Q)
{return Q->rear->next->next == Q->rear->next;
}
void EnQUeue(LinkQueue *Q,DataType x)
{QueueNoede *p = new QUeueNode;p->data = x;p->next = Q->rear->next;Q->rear->next = p;Q->rear = p;//将当前指针置为队尾
}
DataType DeQueue(LinkQueue *Q)
{DataType t;QueueNode *p;if(EmptyQueue(Q)){return 0;}p = Q->rear-next->next;//出队元素x = p->data;if(p==Q->rear){Q->rear = Q-rear->next;//当队列中只有一个结点，出队后将队尾指针指向头结点Q->rear->next = p->next;}else{Q->rear->next = p->next;}delete p;return x;
}

7、数组Q[m]存放循环队列，设置tag0或tag1，来区别队头指针和队尾指针相等时，队列空或者满，编写入队和出队操作

SeQueue QueueInit(SeQueue Q)
{Q.front = Q.rear = 0;Q.tag = 0;return Q;
}
SeQueue QueueIn(SeQueue Q，int e)
{if((Q.tag == 1)&&(Q.rear == Q.front))return 0;//队满else{Q.rear = (Q.rear + 1) % m;Q.data[Q.rear] = e;if(Q.tag == 0)//当tag==0时表示空，队列有元素所以不空Q.tag = 1; }return Q;
}
ElemType QueueOut(SeQueue Q)
{if(Q.tag == 0){return 0;}else{Q.front = (Q.front+1)%m;e = Q.data[Q.front];if(Q.front == Q.rear)//当出队完成后判断一下队列是否为空Q.tag = 0;}return e;
}

8、循环队列两端都可以进行插入和删除，写出循环队列类型定义，写出从队尾删除，队头插入的算法

#define M
typedef struct
{Elemtp data[M];int front,rear;
}cycqueue;
elemty delqueue(cycqueue Q)
{if(Q.front == Q.rear){return 0;//空}Q.rear = (Q.rear-1+M)%M;//修改队尾，front = (front+1)%maxsizee = Q.data[(Q.rear+1+M)%M;return e;//出队列元素
}
void enqueue(cycqueue Q.elemtp x)
{if(Q.rear == (Q.front-1+M)%M)Q.data[Q.front] = x;Q.front = (Q.front-1+M)%M;//rear = (rear+1)%maxsize
}

10、f为单链表，链表中存储的都是整型的数据编写，求链表中最大整数，链表个数，整数平均值的递归算法。

int GetMax(LinkList p)
{if(p->next == NULL){return p->data;}else{int max = GetMax(p->next);return p->data >= max ? p->data:max;}
}
int GetNodecount(LinkList P)
{if(p->next == NULL){return 1;}else{return GetNodeCount(P->next)+1;}
}
double GetAverage(LinkList p,int n)
{if(p->next == NULL){return p->data;}else{double ave = GetAverage(p->next,n-1);return (ave*(n-1) + p->data)/n;}
}

第四章字符串

1、写一个算法统计在输入字符串中各个不同字符出现的频度并将结果存入文件（字符串中的合法字符为A-Z这26个字母和0-9这10个数字）
算法思想
从字符串中读出数字字符时，字符的ASCII代码值减去数字字符 ‘0’的ASCII代码值，得出其数值(0…9)，字母的ASCII代码值减去字符‘A’的ASCII代码值加上10

void count()
{int i,num[36];char ch;for(i = 0;i < 36;i++){num[i] = 0;}while((ch = getchar()) != '#'){if('0' <ch <'9'){i = ch-48;num[i]++;}else('A' <= ch <= 'Z'){i = ch-65+10;num[i]++;}}for(i = 0;i < 10;i++){cout <<num[i];//数字的个数}for(i = 10;i < 36;i++){cout << num[i];//字符的个数}
}

2、编写递归算法实现字符串逆序存储
算法思想
逆序存储，即

void InverStore(char A[])
{char ch;int i = 0;cin >> ch;if(ch != '#'){Invertstore(A);A[i++] = ch;}A[i] = "\0";
}

3、将字符串t插入到s中，插入位置为pos

[题目分析]本题是字符串的插入问题，要求在字符串s的pos位置，插入字符串t。首先应查找字符串s的pos位置，将第pos个字符到字符串s尾的子串向后移动字符串t的长度，然后将字符串t复制到字符串s的第pos位置后。
对插入位置pos要验证其合法性，小于1或大于串s的长度均为非法，因题目假设给字符串s的空间足够大，故对插入不必判溢出。

5、二维数组a[1…m,1…n]，编写算法判断a中所有元素是否互不相同；

int judgEqual(int a[m][n],int m,n)
{for(i = 0;i < m;i++){for(j = 0;j < n-1;j++){for(p = j+1;p < n;p++){if(a[i][j] = a[i][p])return 0;//相同for(k = i+1;k < m;k++){for(p = 0;p > n;p++){if(a[i][j] == a[k][p])return 0;}}}}}
}

6、编写算法将所有正数排在所有负数前面
算法思想
i和j两个指针，i从前往后搜索负数，j从后往前搜索正数，然后交换i和j，继续上述过程。

void Arrange(int A[],int n)
{int i = 0,j = n-1,x;while(i < j){while(i < j && A[i] > 0)//找负数，当A[i]不是正数时就停止i++;while(i < j && A[j] < 0)//找正数，当A[j]不是负数时就停止j--;if(i < j){x = A[i];A[i++]=A[j];//为沙是这俩呢，不是很理解A[j--] = x;}}}

第五章二叉树

1、统计二叉树叶结点个数
算法思想
如果二叉树为空，则返回0，如果二叉树不为空且左右子树为空返回1
如果二叉树不为空，却左右子树不同时为空，返回左子树上的结点加上右子树上的结点

int LeafNodeCount(BiTree T)
{if(T == NULL){return 0;}else if(T->lchild == NULL && T-rchild == NULL)return 1;elsereturn LeafNodeCount(T->lchild) + leadNodeCount(T->rchild);
}

2、判断两棵树是否相等
算法思想
需要处理空，是否都为空，是否相等
如果当前结点不相等，直接返回两棵树不相等
如果当前结点相等，那么递归的判断他们的左右孩子是否相等

int compareTree(TreeNode *T1,TreeNode *T2)
{bool T1isNull = (T1==NULL);bool T2isNill = (T2==NULL);if(T1isNUll != T2isNull){return 1;//不相等}if(T1isNull && T2isNull){return 0;//相等}if(T1-> != T2->){return 1;}return (compareTree(tree1->left,tree2->left)&&compareTree(tree1->right,tree2->right))//分别算左右子树||(compareTree(tree1->left,tree2->right)&&compareTree(tree1->right,tree2->left));}

3、交换二叉树中结点的左右孩子
算法思想
如果某结点的左右孩子为空，返回
如果不为空，交换该结点的左右孩子，递归交换

void changeLR(BiTree &T)
{BiTree temp;if(T->lchild == NULL && T->rchild ==NULL){return ;}else{temp = T->lchild;T->lchild = T->rchild;T->rchild = temp;}changeLR(T->lchild);changeLR(T->rchild);
}

4、设计二叉树的双序遍历算法，双序遍历，先访问这个结点，在按照双序遍历他的左子树，然后在一次方为这个结点，接下来按照双序遍历他的右子树。
算法思想
如果树为空返回，
如果结点为叶子结点，仅输出结点，否则先输出该结点
遍历其左子树，在输出该结点，递归遍历右子树。

void DoubleTraverse(BiTree T)
{if(T == NULL){return ;}else if(T->lchild == NULL && T->rchild == NULL){cout<<T->data;}else{cout<<T->data;}else{cout<<T->data;DoubleTraverse(T->lchild);cout<<T->data;DoubleTraverse(T-rchild);}
}

5、计算二叉树的最大宽度（每层中结点个数的最大值）

算法思想
采用层次遍历，记录下各层的结点个数

int width(BiTree Bt)
{if(T == NULL){return 0;}else{BiTree Q[];front = 1;rear = 1;last = 1;temp = 0;maxw = 0;Q[rear] = bt;while(front <= last){p = Q[front++];temp++;/记录当前层数结点个数if(p->lchild != NULL)Q[++rear] = p->lchildif(p->rchild != NULL)Q[++rear] = p->rchild;if(front > last)//一层结束{last = rear;//last指向下层最右边的元素，更新当前最大宽度if(temp > maxw)maxw = temp;temp = 0;}}}
}

6、按照层序遍历的方法，统计树中度为1的结点个数
算法思想
某个结点的左子树空右子树非空、或者、右子树空左子树非空，则该结点度为1

int Level(BiTree bt)
{int num = 0;if(bt != NUll){QueueInit(Q);QututIn(Q,bt);while(!QueueEmpty(Q)){p = QueueOut(Q);cout << p-data;if((p->lchild == NULL && p->rchild != NULL) || p->lchild != NULL && p->rchild == NULL)//度为1{numm++；}if(p->lchild != NULL){QueueIn(Q,p->lchild);}if(p->rchild != NULL){QuueueIn(Q,p->rchild);}}}return num;
}

7、求任意二叉树中最长的一条路径长度，并输出次路径上个各个结点的值
算法思想
采用后序遍历保留当前结点的祖先信息，用变量保存栈的最高栈顶指针，每当退栈时，栈顶指针高于保存最高栈顶指针时，将栈倒入辅助栈，栈始终保存最长路径的结点。

void LongestPath(BiTree bt)
{BiTree p = bt;BiTree l[],s[];int i,top = 0,tag[],longest = 0;while(p != NULL || top >0){while(p){s[++p] = p;tag[top] = 0;p=p->lchild;}if(tag[top]==1){if(s[top]->lchild == NULL && s[top]->rchild == NULL){if(top > longest){for(i = 1;i <= top;i++){l[i] = s[i];longest = top;top--;}}else{    if(top > 0){tag[top] = 1;p = s[top].rchild}}}}}
}

void postorder(BinTree BT)
{BiTree T = BT;stack 1}

8、输出二叉树每个叶子结点到根结点的路径
算法思想
采用先序遍历，当找到叶子结点时，有序叶子结点未添加到path中输出data值

void ALLpath(BTNode *b,elemtype path[],int pathlen)
{int i;if( b!= NULL){if(b->lchild == NULL && b->rchild == NULL){cout<<" " << b->data << "到根结点路径:" << b->datafor(i = pathlen-1;i >= 0;i--){cout<<i;}}else{path[pathlen] = b->data;pathlen++;ALLpath(b->lchild,path,pathlen);Allpath(b->rchild,path,pathlen);pathlen--;}}
}

9、分别以邻接矩阵和邻接，编写以下算法
增加一个新顶点v、删除顶点v以及相关的边、增加一条边、删除一条边

status insert_vex(MGraph &G,char v)//插入结点
{if(G.vexnum+1) > MAX_VERTEX_NUMreturn 0;G.vexs[++G.vexnum] = v;return OK;
}
status Delete_vex(MGraph &G,char v)
{n = G.vexnum;if((m = LocateVex(G,v)) < 0)return 0;for(i = 0;i < n;i++){G.arcs[m] = G.arcs[n];G.arcs[m] = G.arcs[n];}G.arcs[m][m].adj = 0;G.vexnum--;return OK;
}
Status Insert_Arc(MGraph &G,char v,char w)
{if((i = LocateVex(G,v)) < 0)return 0;if(j = LocateVex(G,w) < 0)return 0;if(i==j)return 0;if(G.arcs[j].adj == NULL){G.arcs[j].adj = 1;G.arcnum++;}return ok;
}
Status Delete_Arc(MGraph &G,char v,char w)//在邻接矩阵表示的图G上删除边(v,w)
{if((i=LocateVex(G,v))<0) return ERROR;if((j=LocateVex(G,w))<0) return ERROR;if(G.arcs[j].adj != NULL){G.arcs[j].adj=0;G.arcnum--;}return OK;
}//Delete_Arc

2、邻接表图实现非递归DFS

void DFSn(Graph,int v)
{Stack s;SetEmpty(s);push(s,v);while(!StackEmpty(S)){pop(s,k);if(visted[k] == NULL){visited[k] = True;visit(k);}for(w = FirstAdjvex(G,k);w!=NULL;w = NextAdjvex(G,k,w)){if(!visited[w] && w!=Getop(s)){push(s,w);}w == GetTop(s)}}}

3、求图G中距离顶点v的最短路径长度最大的一个顶点，
算法思想：利用地杰斯特拉求v0到所有顶点的最短路径，分别保存到D[i]中，求出D[i]中最大下标

int ShortestPath(AMGraph G,int v0)
{n = G.vexnum;for(v = 0;v < n;++v){S[v] = false;D[v] = G.arcs[v0][v];if(D[v] < MaxInt)path[v] = v0;elsepath[v] = -1;}s[v0] = True;D[v0] = 0;for(i = 1;i < n;i++){min = MaxInt;for(w = 0;w < n;w++){if(s[w] == NULL && D[w] < min){v = w;min = D[w];}S[w] = True;}for(w = 0;w < n;w++)if(S[w] == NULL && (D[v]+G.arcs[v][w] < D[w])){D[w] = D[v] + G.arcs[v][w];path[w] = v;}}Max = D[0];m = 0;for(i = 1;i < n;i++){if(Max < D[i])m = i;}return m;}

4、DFS判断邻接表中是否存在vi到vj的路径

int visited[MAXSIZE]
int level = 1;
int exist_path_DFS(ALGraph G,int i,int j)
{if(i==j)return 1;else{visited[i] = 1;for(p = G.vertices[i].firstarc;p;p=p->nextarc.level--){level++;k = p->adjvex;if(visited[k] == NULL && exist_path(k,j))return 1;}}if(level == 1)return 0;}

5、采用邻接表，判断无向图中任意两个顶点之间是否存在一条长度为k的简单路径

int visited[MAXSIZE]
int exist_path_len(Algraph G,int i,int j,int k)
{if(i == j && k == 0)return 1;else if(k > 0){visited[i] = 1;for(p = G.vertices[i].firstarc;p;p = p->nextarc){l = p->adjvex;if(visted[i] == NULL){if(exits_path_len(G,l,j,k-1))return 1;}}visited[i] = 0;}return 0;
}

第七章查找

1、折半查找

int Binsearch(rectype r[],int k,low,high)
{if(low < high){mid = (low+high)/2;if(r[mid].key == k)return mid;else if(r[mid].key < k)Binsearch(r,k,low,mid-1);elseBinsearch(r,k,mid+1,high);}else{return 0;}
}

2、判断是否为二叉排序树
算法思想
根据二叉排序树的中序遍历为递增的性质，在遍历中将当前结点与前驱比较，若逆序则为false

void judgeBST(BTree int flag)
{if(T != null && flag){judgeBST(T->lchild,flag);if(pre == NULL)//中序的第一个结点pre = T;//前驱指针指向当前结点else if(pre->data < T->data)pre = T://前驱指针指向当前结点else{flag = flase;}//不是完全二叉树judgeBst(T->rchild,flag);}
}

3、二叉排序树，从小到大输出小于等于x的值
算法思想
中序遍历结点，如果值小于x则输出

void printx(BSTree T)
{if(T != NULL){printx(T->lchild);cout<<T->data;printx(T->rchild)}
}
void printallx(Bstree bst,datatype x)
{p = bst;if(p != NULL){while(p != NULL && p->data < x)p= p->rchild;bst = p;if(p != NULL){f = p;p = p->lchild;while(p && p->data >= x){f = p;p = p->lchild;if(p != NULL){f->lchild = NULL;}}}}
}

4、二叉树中查找值为x的结点，如果找到count+1，否则作为新的结点插入到树中，插入后仍然为二叉排序树

void SearchBst(BiTree &T,int target)
{BiTree s,q,f;s = new BiTree;s->data.x = target;s->data.count = 0;s->lchild = s->rchild = NULL;if(T == NULL){T = s;return ;}f = NULL;q = T;while(q != NULL){if(q->data.x == target)//如果找到就+1{q->data.count++;return ;}f = q;if(q->data.x > target)//如果target比当前结点大则插入到右子树，如果比当前结点小则插入到左子树{q = q->lchild;}else{q = q->rchild;}}if(f->data.x > target)//插入新的结点{f->lchild = s;}else{f->rchild = s;}
}

5、平衡二叉树的每个就诶殿都表明了平衡因子，求平衡二叉树的高度
算法思想
因为二叉树的各个结点表明了平衡因子，根结点的层次为1，每下一层，层次加1，直到层数最大的叶子结点，是平衡二叉树的高度。
当结点的平衡因子b为0时，任选左右一分支向下查找，若b不为0，沿左（b=1）或右（b=-1）查找

int height(BSTree T)
{int level = 0,p = t;while(p != NULL){level++;if(p->bf < 0)p = p->rchild;elsep = p->lchild;          }return level;}

int Depth(BiTree T)
{if(!T)return 0;else if(!T->lchild&&!T->rchild)return 1;return Depth(T->lchild)>=Depth(T->rchild)?Depth(T->lchild)+1:Depth(T->rchild)+1;
}

6、写出在散列表中插入和删除关键字为k的算法

bool insert()
{int data;cin>.data;int ant=hash(data);LinkList p = HT[ant];while(p->next){if(p->next->data == data){return false;}p = p->next;}LinkList s;s = new LNode;s->data = data;s->next = p->next;p->next = s;
}
bool detelets()
{int data;cin>>data;int ant = hash(data);LinkList p = HT[ant];while(p->next){if(p->next->data == data){LinkList s = p->next;p->next = s->next;detelet s;return true;  }p = p->next;}return false;
}

第八章排序

1、单链表，实现简单选择排序
简单选择排序
前一个和后一个进行比较小则交换

void LinkListSelectSort(LinkList L)
{p = L->next;while(p != NUll){q = p->nextr = p;while(q != NULL){if(q->data < r->data)r = q;}q = q->next;}if(r != p){swap(r->data,p->data);}p = p->next;
}

2、带头结点的双向链表，使用双向冒泡排序法按上升序进行排序（双向冒泡排序，即相邻两趟排序相反向冒泡）

typedef struct node
{elemtype data;struct node *pripr ,*next;
}node,*DLinkList;
void TwoWayBubble(DLinkList la)
{int exchange  =1;DLinkList p ,temp,tail;head = la;tail = null;while(exchange){p = head->next;exchange = 0;while(p->next != taill){if(p->data > p->next->data){temp = p->next;exchange = 1;p->next =temp->next;temp->next->prior = p;temp->next = p;p->prior->next = temp;temp->prior = p->prior;p->prior = temp; }else{p = p->next;}tail = p;p = tail->prior;while (exchange && p->prior!=head)  {if (p->data<p->prior->data)       //交换两结点指针，涉及6条链{temp=p->prior; exchange=1;     //有交换p->prior=temp->prior;temp->prior->next=p； temp->prior=p; p->next->prior=temp; //将temp插到p结点后（右）temp->next=p->next; p->next=temp;}else{p=p->prior;  //无交换，指针前移}head=p;             //准备向下起泡}}}
}

4、对序列进行整理，所有负值在非负值前面

void process(int A[n])
{low = 0;high = n-1;while(low < high){while(low < high && A[low ] < 0)//从前往后找大于0的{low++;}while(log < high && A[high] > 0)//从后往前找小于0的{high--;}if(low < high)//找到了则交换{temp = A[low];A[low] = A[high];A[high] = x;low++;high--;}}return ;
}

5、借助快排序的思想，在无序的记录中查找key，查找成功输出位置和值，失败输出notfind

算法思想
把带查技术看作中树，由后往前一次比较，若小于中树，则从前往后直到查找成功或者返回为0

int index(rectype R[],int l,int h,data key)
{int i = l,j = h;while(i < j){while(i <= j &&R[j].key > key ){j--;}if(R[j].key == key )return j;while(i <= j && R[i].key < key){i++;}if(R[i].key == key)return i}return "Notfind";
}

6、简单排序算法，计数算法，…，统计表中有多少个记录的关键字比该记录的关键字小。

typedef stryct
{int key;datatype infor;
}rectype;void countsort(rectype a[],b[],int n)
{for(i = 0;i < n;i++){for(j = 0 ;j < i ;j++){if(a[j].key < a[i].key)cnt++;b[cnt] = a[i];}}}

数据结构课本课后题算法相关推荐

中国大学MOOC浙大数据结构PTA课后题
在这里占个坑,记录一下学习数据结构中例题目录二叉树的同构 1.建树 2.判断是否为同构 3.同类型题目是否同一棵二叉搜索树思路代码二叉树的同构题目:题目详情 - 03-树1 树的同构 ( ...
Linux课本课后题答案
一.选择题 1. Linux最早是由计算机爱好者B开发的. A. Richard Petersen B. Linus Torvalds C. Rob Pick D. Linux Sarwar 2. ...
考研数据结构历年真题(算法设计题)整理
文章目录: 2014年 1.带头双循环链表删除一个结点返回其值 2.栈入队
算法导论第十二章总结以及课后题答案
二叉搜索树总结 1.查找二叉搜索树中最大关键字元素 TREE-MAXIMUM(x)while x.right!=NILx=x.rightreturn x 2.查找二叉搜索树中最小关键字元素 TREE ...
DSt：数据结构的最强学习路线之数据结构知识讲解与刷题平台、刷题集合、问题为导向的十大类刷题算法(数组和字符串、栈和队列、二叉树、堆实现、图、哈希表、排序和搜索、动态规划/回溯法/递归/贪心/分治)总
DSt:数据结构的最强学习路线之数据结构知识讲解与刷题平台.刷题集合.问题为导向的十大类刷题算法(数组和字符串.栈和队列.二叉树.堆实现.图.哈希表.排序和搜索.动态规划/回溯法/递归/贪心/分治)总 ...
长春理工大学c语言题库word,长春理工大学DSP课本课后习题答案.docx
长春理工大学DSP课本课后习题答案习题1外设接口有通用I/O接口.串行接口.串行外设接口.CAN总线接口.外部总线接口.模数转换接口.片内外设有事件管理器模块,模数转换模块.串行通信模块.串行外 ...
软件工程案例教程答案（第三版）韩万江姜立新编著课后题答案（软件项目开发实践）
软件工程案例教程答案(第三版)韩万江姜立新编著课后题答案 (软件项目开发实践) 第一章课后答案一.填空题二.判断题三.选择题第二章课后答案一.填空题二.判断题三.选择题第三 ...
Java数据结构第一讲-排序算法
常见数据结构和算法实现(排序/查找/数组/链表/栈/队列/树/递归/海量数据处理/图/位图/Java版数据结构) 数据结构和算法作为程序员的基本功,一定得稳扎稳打的学习,我们常见的框架底层就是各类数据 ...
计算机考研数据结构真题答案,数据结构考研真题和答案
<数据结构考研真题和答案>由会员分享,可在线阅读,更多相关<数据结构考研真题和答案(14页珍藏版)>请在人人文库网上搜索. 1.一.选择题1. 算法的计算量的大小称为计算的( ...

数据结构课本课后题算法

第二章线性表

第三章栈和队列

第四章字符串

第五章二叉树

第七章查找

第八章排序

数据结构课本课后题算法相关推荐

最新文章

热门文章

数据结构课本课后题算法

第二章 线性表

第三章 栈和队列

第四章 字符串

第五章 二叉树

第七章 查找

第八章 排序

数据结构课本课后题算法相关推荐

最新文章

热门文章

第二章线性表

第三章栈和队列

第四章字符串

第五章二叉树

第七章查找

第八章排序