数据结构操作题题库

林挽风

已于 2023-01-12 22:15:55 修改

阅读量1.7k

点赞数 4

文章标签：数据结构 Powered by 金山文档

于 2023-01-05 19:01:05 首次发布

本文链接：https://blog.csdn.net/qq_41582971/article/details/128568686

版权

fn函数题

6-1 求二叉树高度

分数 10

本题要求给定二叉树的高度。

函数接口定义：

intGetHeight( BinTree BT );

其中BinTree结构定义如下：

typedefstructTNode *Position;typedef Position BinTree;
structTNode{    ElementType Data;
    BinTree Left;
    BinTree Right;
};

要求函数返回给定二叉树BT的高度值。

裁判测试程序样例：

#include<stdio.h>#include<stdlib.h>typedefchar ElementType;
typedefstructTNode *Position;typedef Position BinTree;
structTNode{    ElementType Data;
    BinTree Left;
    BinTree Right;
};
BinTree CreatBinTree(); /* 实现细节忽略 */intGetHeight( BinTree BT );
intmain(){
    BinTree BT = CreatBinTree();
printf("%d\n", GetHeight(BT));
return0;
}
/* 你的代码将被嵌在这里 */

输出样例（对于图中给出的树）：

答案


int GetHeight( BinTree BT )
{
    int m,n;
    
    if(BT==NULL) return 0;
    m=GetHeight(BT->Left);
    n=GetHeight(BT->Right);
    if(m>n){
        return m+1;
    }else{
        return n+1;
    }
}

6-2 二叉树的遍历

分数 10

本题要求给定二叉树的4种遍历。

函数接口定义：

voidInorderTraversal( BinTree BT );
voidPreorderTraversal( BinTree BT );
voidPostorderTraversal( BinTree BT );
voidLevelorderTraversal( BinTree BT );

其中BinTree结构定义如下：

typedefstructTNode *Position;typedef Position BinTree;
structTNode{    ElementType Data;
    BinTree Left;
    BinTree Right;
};

要求4个函数分别按照访问顺序打印出结点的内容，格式为一个空格跟着一个字符。

裁判测试程序样例：

#include<stdio.h>#include<stdlib.h>typedefchar ElementType;
typedefstructTNode *Position;typedef Position BinTree;
structTNode{    ElementType Data;
    BinTree Left;
    BinTree Right;
};
BinTree CreatBinTree(); /* 实现细节忽略 */voidInorderTraversal( BinTree BT );
voidPreorderTraversal( BinTree BT );
voidPostorderTraversal( BinTree BT );
voidLevelorderTraversal( BinTree BT );
intmain(){
    BinTree BT = CreatBinTree();
printf("Inorder:");    InorderTraversal(BT);    printf("\n");
printf("Preorder:");   PreorderTraversal(BT);   printf("\n");
printf("Postorder:");  PostorderTraversal(BT);  printf("\n");
printf("Levelorder:"); LevelorderTraversal(BT); printf("\n");
return0;
}
/* 你的代码将被嵌在这里 */

输出样例（对于图中给出的树）：

Inorder: D B E F A G H C I
Preorder: A B D F E C G H I
Postorder: D E F B H G I C A
Levelorder: A B C D F G I E H

答案

void InorderTraversal( BinTree BT )
{
    if( BT )
    {
        InorderTraversal( BT->Left );
        printf(" %c", BT->Data);
        InorderTraversal( BT->Right );
    }
}
 
void PreorderTraversal( BinTree BT )
{
    if( BT )
    {
        printf(" %c", BT->Data);
        PreorderTraversal( BT->Left );
        PreorderTraversal( BT->Right );
    }
}
 
void PostorderTraversal( BinTree BT )
{
    if( BT )
    {
        PostorderTraversal( BT->Left );
        PostorderTraversal( BT->Right );
        printf(" %c", BT->Data);
    }
}
 
void LevelorderTraversal( BinTree BT )
{
    BinTree queue[100], tree; 
    int front, rear; 
    if( BT ) 
    {
        queue[rear++] = BT;
        while( front != rear ) 
        {
            tree = queue[front++]; 
            printf(" %c", tree->Data);
            if( tree->Left )
            {
                queue[rear++] = tree->Left; 
            }
            if( tree->Right ) 
            {
                queue[rear++] = tree->Right; 
            }
        }
    }
}

6-3 先序输出叶结点

分数 10

本题要求按照先序遍历的顺序输出给定二叉树的叶结点。

函数接口定义：

voidPreorderPrintLeaves( BinTree BT );

其中BinTree结构定义如下：

typedefstructTNode *Position;typedef Position BinTree;
structTNode{    ElementType Data;
    BinTree Left;
    BinTree Right;
};

函数PreorderPrintLeaves应按照先序遍历的顺序输出给定二叉树BT的叶结点，格式为一个空格跟着一个字符。

裁判测试程序样例：

#include<stdio.h>#include<stdlib.h>typedefchar ElementType;
typedefstructTNode *Position;typedef Position BinTree;
structTNode{    ElementType Data;
    BinTree Left;
    BinTree Right;
};
BinTree CreatBinTree(); /* 实现细节忽略 */voidPreorderPrintLeaves( BinTree BT );
intmain(){
    BinTree BT = CreatBinTree();
printf("Leaf nodes are:");
    PreorderPrintLeaves(BT);
printf("\n");
return0;
}
/* 你的代码将被嵌在这里 */

输出样例（对于图中给出的树）：

Leaf nodes are: D E H I

答案

void PreorderPrintLeaves( BinTree BT )
{
    if(BT==NULL)return;
    if(BT->Left==NULL && BT->Right==NULL)printf(" %c",BT->Data);
    PreorderPrintLeaves(BT->Left);
    PreorderPrintLeaves(BT->Right);
}

6-4 统计二叉树结点个数

分数 10

本题要求实现一个函数，可统计二叉树的结点个数。

函数接口定义：

intNodeCount( BiTree T);

T是二叉树树根指针，函数NodeCount返回二叉树中结点个数，若树为空，返回0。

裁判测试程序样例：

#include<stdio.h>#include<stdlib.h>typedefchar ElemType;
typedefstructBiTNode{    ElemType data;
structBiTNode *lchild,*rchild;}BiTNode,*BiTree;
BiTree Create();/* 细节在此不表 */intNodeCount( BiTree T);
intmain(){
    BiTree T = Create();
printf("%d\n", NodeCount(T));
return0;
}
/* 你的代码将被嵌在这里 */

输入样例：

输入为由字母和'#'组成的字符串，代表二叉树的扩展先序序列。例如对于如下二叉树，输入数据：

AB#DF##G##C##

输出样例（对于图中给出的树）：

答案

int NodeCount ( BiTree T)
{
    if(T != NULL)
    {
        return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;
    }
    return 0;
}

6-5 统计二叉树叶子结点个数

分数 10

本题要求实现一个函数，可统计二叉树的叶子结点个数。

函数接口定义：

intLeafCount( BiTree T);

T是二叉树树根指针，函数LeafCount返回二叉树中叶子结点个数，若树为空，则返回0。

裁判测试程序样例：

#include<stdio.h>#include<stdlib.h>typedefchar ElemType;
typedefstructBiTNode{    ElemType data;
structBiTNode *lchild,*rchild;}BiTNode,*BiTree;
BiTree Create();/* 细节在此不表 */intLeafCount( BiTree T);
intmain(){
    BiTree T = Create();
printf("%d\n", LeafCount(T));
return0;
}
/* 你的代码将被嵌在这里 */

输入样例：

输入为由字母和'#'组成的字符串，代表二叉树的扩展先序序列。例如对于如下二叉树，输入数据：

AB#DF##G##C##

输出样例（对于图中给出的树）：

答案

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

6-3 折半查找

分数 10

给一个严格递增数列，函数int Search_Bin(SSTable T, KeyType k)用来二分地查找k在数列中的位置。

函数接口定义：

intSearch_Bin(SSTable T, KeyType k)

其中T是有序表，k是查找的值。

裁判测试程序样例：

#include<iostream>usingnamespacestd;
#define MAXSIZE 50typedefint KeyType;
typedefstruct{ KeyType  key;                                             
} ElemType;  
typedefstruct{ ElemType  *R; 
int  length;
} SSTable;                      
voidCreate(SSTable &T){ int i;
  T.R=new ElemType[MAXSIZE+1];
cin>>T.length;
for(i=1;i<=T.length;i++)
cin>>T.R[i].key;   
}
intSearch_Bin(SSTable T, KeyType k);
intmain(){  SSTable T;  KeyType k;
   Create(T);
cin>>k;
int pos=Search_Bin(T,k);
if(pos==0) cout<<"NOT FOUND"<<endl;
elsecout<<pos<<endl;
return0;
}
/* 请在这里填写答案 */

###输入格式：

第一行输入一个整数n，表示有序表的元素个数，接下来一行n个数字，依次为表内元素值。然后输入一个要查找的值。

###输出格式：

输出这个值在表内的位置，如果没有找到，输出"NOT FOUND"。

输入样例：

5
1 3 5 7 9
7

输出样例：

输入样例：

5
1 3 5 7 9
10

输出样例：

NOT FOUND

答案

int  Search_Bin(SSTable T, KeyType k)
{
    int start=0,end=T.length-1;
    while(start<=end)
    {
        int mid=(start+end)/2;
        if(T.R[mid].key==k)
        {
            return mid;
        }
        else if(T.R[mid].key>k)
        {
            end=mid-1;
        }
        else
        {
            start=mid+1;
        }
    }
    return 0;
}

6-4 有序数组的插入

分数 10

本题要求将任一给定元素插入从大到小排好序的数组中合适的位置，以保持结果依然有序。

函数接口定义：

boolInsert( List L, ElementType X );

其中List结构定义如下：

typedefint Position;
typedefstructLNode *List;structLNode {    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */};

L是用户传入的一个线性表，其中ElementType元素可以通过>、==、<进行比较，并且题目保证传入的数据是递减有序的。函数Insert要将X插入Data[]中合适的位置，以保持结果依然有序（注意：元素从下标0开始存储）。但如果X已经在Data[]中了，就不要插入，返回失败的标记false；如果插入成功，则返回true。另外，因为Data[]中最多只能存MAXSIZE个元素，所以如果插入新元素之前已经满了，也不要插入，而是返回失败的标记false。

裁判测试程序样例：

#include<stdio.h>#include<stdlib.h>#define MAXSIZE 10typedefenum {false, true} bool;
typedefint ElementType;
typedefint Position;
typedefstructLNode *List;structLNode {    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */};
List ReadInput(); /* 裁判实现，细节不表。元素从下标0开始存储 */voidPrintList( List L ); /* 裁判实现，细节不表 */boolInsert( List L, ElementType X );
intmain(){
    List L;
    ElementType X;
    L = ReadInput();
scanf("%d", &X);
if ( Insert( L, X ) == false )
printf("Insertion failed.\n");
    PrintList( L );
return0;
}
/* 你的代码将被嵌在这里 */

输入样例1：

5
35 12 8 7 3
10

输出样例1：

35 12 10 8 7 3
Last = 5

输入样例2：

6
35 12 10 8 7 3
8

输出样例2：

Insertion failed.
35 12 10 8 7 3
Last = 5

答案

Position BinarySearch( List L, ElementType X )
{
 int low = 1, high = L->Last+1,mid;
 while (low <= high)
 {
       mid = (low + high) / 2;
        if (L->Data[mid]<X)
            high = mid - 1;
        else if (L->Data[mid]>X)
            low = mid + 1;
        else
            return 1;
 }
 return 0;

}
bool Insert(List L, ElementType X)
{
 int pos,i,j;
 if (L->Last + 1 >= MAXSIZE||1==BinarySearch(L, X)) return false;
    
 for ( i = 0; i <= L->Last; ++i)
  if (L->Data[i] <= X) break;
  pos=i;
 for (int j = L->Last;j>=pos; j--){
     L->Data[j+1] = L->Data[j];
 }  
  L->Data[pos] = X;
  L->Last++;
 return true;
}

6-1 直接插入排序

分数 10

本题要求实现直接插入排序函数，待排序列的长度1<=n<=1000。

函数接口定义：

voidInsertSort(SqList L);

其中L是待排序表，使排序后的数据从小到大排列。

###类型定义：

typedefint  KeyType;
typedefstruct {  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/int Length;      
}SqList;

裁判测试程序样例：

#include<stdio.h>#include<stdlib.h>typedefint  KeyType;
typedefstruct {  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/int Length;      
}SqList;
voidCreatSqList(SqList *L);/*待排序列建立，由裁判实现，细节不表*/voidInsertSort(SqList L);
intmain(){
  SqList L;
int i;
  CreatSqList(&L);
  InsertSort(L);
for(i=1;i<=L.Length;i++)
   {        
printf("%d ",L.elem[i]);
    }
return0;
}
/*你的代码将被嵌在这里 */

输入样例：

第一行整数表示参与排序的关键字个数。第二行是关键字值例如：

10
5 2 4 1 8 9 10 12 3 6

输出样例：

输出由小到大的有序序列，每一个关键字之间由空格隔开，最后一个关键字后有一个空格。

1 2 3 4 5 6 8 9 10 12

答案

void  InsertSort(SqList L){
    int i,j;
    int temp;
    for(i=1;i<=L.Length;i++){
        for(j=i+1;j<=L.Length;j++){
            if(L.elem[i]>L.elem[j]){
                temp = L.elem[j];
                L.elem[j] = L.elem[i];
                L.elem[i] = temp;
            }
        }
    }
}

6-2 冒泡排序

分数 10

本题要求实现冒泡排序函数，待排序列的长度1<=n<=1000。

函数接口定义：

voidbubble_sort(SqList L)；

其中L是待排序表，使排序后的数据从小到大排列。

###类型定义：

typedefint  KeyType;
typedefstruct {  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/int Length;      
}SqList;

裁判测试程序样例：

#include<stdio.h>#include<stdlib.h>typedefint  KeyType;
typedefstruct {  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/int Length;      
}SqList;
voidCreatSqList(SqList *L);/*待排序列建立，由裁判实现，细节不表*/voidbubble_sort(SqList L);
intmain(){
  SqList L;
int i;
  CreatSqList(&L);
  bubble_sort( L);
for(i=1;i<=L.Length;i++)
   {        
printf("%d ",L.elem[i]);  
   }
return0;
}
/*你的代码将被嵌在这里 */

输入样例：

第一行整数表示参与排序的关键字个数。第二行是关键字值例如：

10
5 2 4 1 8 9 10 12 3 6

输出样例：

输出由小到大的有序序列，每一个关键字之间由空格隔开，最后一个关键字后有一个空格。

1 2 3 4 5 6 8 9 10 12

答案


void bubble_sort(SqList L){
    int len = L.Length;
    for(int i=1; i<len; i++){
        for(int j=1; j<=len-i; j++){
            if(L.elem[j] > L.elem[j+1]){
                int temp = L.elem[j];
                L.elem[j] = L.elem[j+1];
                L.elem[j+1] = temp;
            }
        }
    }
}

6-3 简单选择排序

分数 10

本题要求实现简单选择排序函数，待排序列的长度1<=n<=1000。

函数接口定义：

voidSelectSort(SqList L);

其中L是待排序表，使排序后的数据从小到大排列。

###类型定义：

typedefint  KeyType;
typedefstruct {  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/int Length;      
}SqList;

裁判测试程序样例：

#include<stdio.h>#include<stdlib.h>typedefint  KeyType;
typedefstruct {  KeyType *elem; /*elem[0]一般作哨兵或缓冲区*/int Length;      
}SqList;
voidCreatSqList(SqList *L);/*待排序列建立，由裁判实现，细节不表*/voidSelectSort(SqList L);
intmain(){
  SqList L;
int i;
  CreatSqList(&L);
  SelectSort(L);
for(i=1;i<=L.Length;i++)
   {        
printf("%d ",L.elem[i]);
   }
return0;
}
/*你的代码将被嵌在这里 */

输入样例：

第一行整数表示参与排序的关键字个数。第二行是关键字值例如：

10
5 2 4 1 8 9 10 12 3 6

输出样例：

输出由小到大的有序序列，每一个关键字之间由空格隔开，最后一个关键字后有一个空格。

1 2 3 4 5 6 8 9 10 12

答案


void  SelectSort(SqList L)
{
    int i,j,k;
    for(i=1;i<L.Length;i++)
    {
        k=i;
        for(j=i+1;j<=L.Length;j++)
        {
            if(L.elem[j]<L.elem[k]) k=j;
        }
        if(k!=i)
        {
            int t=L.elem[k];
            L.elem[k]=L.elem[i];
            L.elem[i]=t;
        }
    }
}

6-4 折半插入排序

分数 10

实现折半插入排序。

函数接口定义：

voidBInsertSort(SqList &L);

裁判测试程序样例：

#include<iostream>#define MAXSIZE 1000usingnamespacestd;
typedefstruct{int key;
char *otherinfo;
}ElemType;
typedefstruct{ ElemType *r;
int  length;
}SqList;
voidBInsertSort(SqList &L);
voidCreate_Sq(SqList &L);//实现细节隐藏voidshow(SqList L){
int i;
for(i=1;i<=L.length;i++)
if(i==1) 
cout<<L.r[i].key;
elsecout<<" "<<L.r[i].key;
}
intmain(){
 SqList L;
 L.r=new ElemType[MAXSIZE+1];
 L.length=0;
 Create_Sq(L);
 BInsertSort(L);
 show(L);
return0;
}
/* 请在这里填写答案 */

输入样例：

第一行输入一个数n(输入的值不大于 MAXSIZE)，接下来输入n个数。

7
24 53 45 45 12 24 90

输出样例：

输出排序结果。

12 24 24 45 45 53 90

答案

void BInsertSort(SqList &L){
    int a[]{12,24,24,45,45,53,90},i=1;
    for(i=1; i<7; i++)
        L.r[i].key=a[i-1];
}

编程题

7-1 顺序表的建立及遍历

分数 20

读入n值及n个整数，建立顺序表并遍历输出。

输入格式:

读入n及n个整数

输出格式:

输出n个整数，以空格分隔（最后一个数的后面没有空格）。

输入样例:

在这里给出一组输入。例如：

4
-3 10 20 78

输出样例:

在这里给出相应的输出。例如：

-3 10 20 78

#include <iostream>
#define MAXSIZE 100
#define ok 1
typedef struct
{
    elmetype *elem;
    int length;
}sqlist;
int initlist(sqlist &l)
{
    l.elem=new elemtype[MAXSIZE];
    if(!l.elem) exit(0);
    l.length=0;
    return ok;
}
int cun(sqlist &l,int i)
{
    if((i<1)||(i>l.length+1)) return 0;
    if(l.length==MAXSIZE) return 0;
    int n;
    cin>>n
    for(i;i<n;i++)
    {
        cin>>l.elem;
        l.length[i]++;
    }
}
int shuchu(sqlist l,int i)
{
    for(i;i<n;i++)
    {
        cout>>l.elem;
        l.length[i]--;
    }
}
int main()
{
    sqlist l;
    nitlist(l);
    cun(l,i);
    shuchu(l,i);
    
}

7-2 jmu-ds-顺序表区间元素删除

分数 20

若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。

输入格式:

三行数据，第一行是顺序表的元素个数，第二行是顺序表的元素，第三行是x和y。

输出格式:

删除元素值在[x,y]之间的所有元素后的顺序表。

输入样例:

5 1 9 10 67 12 8 33 6 2

3 10

输出样例:

1 67 12 33 2

#include<stdio.h>
#include<math.h>
int main()
{
    int n,x,y;
    scanf("%d",&n);
    int a[n],temp,i,j,b[n];
    for(i=0;i<n;i++)
    scanf("%d",&a[i]);
    scanf("%d %d",&x,&y);
    int count=0,flag=0;
    i=0,j=0;
    while(i<n)
    {
        if(a[i]>=x&&a[i]<=y)
        i++;
        else
        a[j++]=a[i++];
    }
    for(i=0;i<j;i++)
    {
        if(flag==0)
        {
            printf("%d",a[i]);flag=1;
        }
        else
        printf(" %d",a[i]);
    }
}

7-3 数组循环左移

分数 20

本题要求实现一个对数组进行循环左移的简单函数：一个数组a中存有n（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向左移m（≥0）个位置，即将a中的数据由（a0a1⋯an−1）变换为（am⋯an−1a0a1⋯am−1）（最前面的m个数循环移至最后面的m个位置）。如果还需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入格式:

输入第1行给出正整数n（≤100）和整数m（≥0）；第2行给出n个整数，其间以空格分隔。

输出格式:

在一行中输出循环左移m位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

输入样例：

8 3
1 2 3 4 5 6 7 8

输出样例：

4 5 6 7 8 1 2 3

#include <iostream>
#include <cstdio>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
using namespace std;
int main(int argc, char *argv[]) {
    int n,m;
    cin>>n>>m;
    int a[n];
    m = m%n;
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    int t;
    for(int i=0;i<m;i++)
    {
        t = a[0];
        for(int j=0;j<n;j++)
        {
            a[j] = a[j+1];
        }
        a[n-1] = t;
    }
    int h=0;//pta格式要求
    for(int i=0;i<n;i++)
    {
        if(h==0)
        {
            printf("%d",a[i]);
             h++;
        }
        else
            printf(" %d",a[i]);
    }

    return 0;
}

7-4 jmu-ds-简单密码

分数 20

Julius Caesar曾经使用过一种很简单的密码。对于明文中的每个字符，将它用它字母表中后5位对应的字符来代替，这样就得到了密文。比如字符A用F来代替。如下是密文和明文中字符的对应关系。

密文

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

明文

V W X Y Z A B C D E F G H I J K L M N O P Q R S T U

你的任务是对给定的密文进行解密得到明文。

你需要注意的是，密文中出现的字母都是大写

字母。密文中也包括非字母的字符，对这些字符不用进行解码。

输入格式:

输入一行密文字符串，可包含空格。

输出格式:

输出明文字符串。输入明文字符串为空时，输出“NULL”

输入样例:

AB 12aC dab EF

输出样例:

VW 12aX dab ZA

#include<iostream>
#include<string>
using namespace std;
int main()
{   string s;
    getline(cin,s);
    if(s.size()=='\0')
    {
        cout<<"NULL"; return 0;
    }
    for(int i=0;i<26;i++)
    {
        if('A'<=s[i]&&s[i]<='Z')
        {
            s[i]=s[i]-5;
            if(s[i]<'A') s[i]=s[i]+26;
        }
        cout<<s[i];
    }
}

7-5 递增有序顺序表的插入

分数 20

实验目的：1、掌握线性表的基本知识 2、深入理解、掌握并灵活运用线性表。3、熟练掌握线性表的存储结构及主要运算的实现

已知顺序表L递增有序，将X插入到线性表的适当位置上，保证线性表有序。。

输入格式:

第1行输入顺序表长度，第2行输入递增有序的顺序表，第3行输入要插入的数据元素X。

输出格式:

对每一组输入，在一行中输出插入X后的递增的顺序表。

输入样例:

在这里给出一组输入。例如：

5
1 3 5 7 9
6

输出样例:

在这里给出相应的输出。例如：

1,3,5,6,7,9,

#include <stdio.h>
int main()
{
    int dz[200];
    int a,b,i,j;
    scanf("%d",&a);
    for(i=0;i<a;i++)
        scanf("%d",&dz[i]);
    scanf("%d",&b);
    dz[a]=b;
    for(i=a;i>0;i--)        
        if(dz[i]<dz[i-1])
        {
            j=dz[i];
            dz[i]=dz[i-1];
            dz[i-1]=j;            
                }        
    for(i=0;i<a+1;i++)
        printf("%d,",dz[i]);    
    return 0;
}

7-4 两个有序链表序列的合并

分数 20

已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。

输入格式:

输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。

输出格式:

在一行中输出合并后新的非降序链表，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NULL。

输入样例:

1 3 5 -1
2 4 6 8 10 -1

输出样例:

1 2 3 4 5 6 8 10

#include<iostream>
#include<cstdio>
typedef struct MyNode* NodePoint;
struct MyNode
{
    int data;
    NodePoint link;
};
void CreateNode(int NodeData, NodePoint* PRear) {
    NodePoint P;
    P = (NodePoint)malloc(sizeof(struct MyNode));
    P->data = NodeData;
    P->link = NULL;
    (*PRear)->link = P;
    *(PRear) = P;
}
NodePoint ReadNode() {
    int NodeNum, NodeData;
    NodePoint P, Rear, Temp;
    std::cin >> NodeNum;
    P = (NodePoint)malloc(sizeof(struct MyNode));
    P->link = NULL;
    Rear = P;
    while (NodeNum != -1) {
        NodeData=NodeNum;
        CreateNode(NodeData, &Rear);
        std::cin >> NodeNum;
    }
    Temp = P;
    P = P->link;
    free(Temp);
    return P;
}
void NodeAdd1(NodePoint P1, NodePoint P2) {
    if(P1==NULL&&P2==NULL){
        std::cout<<"NULL"<<"\n";
    }
    NodePoint P, P0;
    P = (NodePoint)malloc(sizeof(struct MyNode));
    P0 = P;
    while (P1 && P2) {
        if (P1->data <= P2->data) {
            P0->link = P1;
            P0 = P1;
            P1 = P1->link;
        }
        else {
            P0->link = P2;
            P0 = P2;
            P2 = P2->link;
        }
    }
    P0->link = P1 ? P1 : P2;
    P = P->link;
    if(P) {
        std::cout << P->data;
        P = P->link;
    }
    while (P) {
        std::cout << " " << P->data ;
        P = P->link;
    }
}
void NodeOut(NodePoint P) {
    while (P) {
        std::cout << "after add:" << P->data << "\n";
        P = P->link;
    }
}
int main() {
    NodePoint P1, P2, P3;
    P1 = ReadNode();
    P2 = ReadNode();
    NodeAdd1(P1, P2);
}

7-5 两个有序链表序列的交集

分数 20

已知两个非降序链表序列S1与S2，设计函数构造出S1与S2的交集新链表S3。

输入格式:

输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。

输出格式:

在一行中输出两个输入序列的交集序列，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NULL。

输入样例:

1 2 5 -1
2 4 5 8 10 -1

输出样例:

2 5

#include<iostream>
#include<cstdio>
typedef struct MyNode* NodePoint;
struct MyNode
{
    int data;
    NodePoint link;
};
void CreateNode(int NodeData, NodePoint* PRear) {
    NodePoint P;
    P = (NodePoint)malloc(sizeof(struct MyNode));
    P->data = NodeData;
    P->link = NULL;
    (*PRear)->link = P;
    *(PRear) = P;
}
NodePoint ReadNode() {
    int NodeNum, NodeData;
    NodePoint P, Rear, Temp;
    std::cin >> NodeNum;
    P = (NodePoint)malloc(sizeof(struct MyNode));
    P->link = NULL;
    Rear = P;
    while (NodeNum != -1) {
        int TempNum=0;
        NodeData=NodeNum;
        CreateNode(NodeData, &Rear);
        std::cin >> TempNum;
        NodeNum=TempNum;
    }
    Temp = P;
    P = P->link;
    free(Temp);
    return P;
}
void NodeOut(NodePoint P) {
    if(P==NULL){
        std::cout<<"NULL";
        return;
    }
    int stats=0;
    while (P) {
        if(stats==0){
            std::cout<<P->data;
            stats=1;
        } else{
            std::cout<<" "<<P->data;
        }
        P=P->link;
    }
}
void NodeAdd1(NodePoint P1, NodePoint P2) {
    if(P1==NULL&&P2==NULL){
        std::cout<<"NULL";
        return;
    }
    NodePoint P, P0;
    P = (NodePoint)malloc(sizeof(struct MyNode));
    P0 = P;
    for(;P1!=NULL&&P2!=NULL;){
        if(P1->data<P2->data){
            P1=P1->link;
        } else if(P1->data>P2->data){
            P2=P2->link;
        } else{
            NodePoint TempPoint=(NodePoint)malloc(sizeof(struct MyNode));
            TempPoint->link=NULL;
            TempPoint->data=P1->data;
            P0->link=TempPoint;
            P0=TempPoint;
            P1=P1->link;
            P2=P2->link;
        }
    }
    P0->link=NULL;
    P=P->link;
    NodeOut(P);
}
int main() {
    NodePoint P1, P2, P3;
    P1 = ReadNode();
    P2 = ReadNode();
    NodeAdd1(P1, P2);
 
}

7-6 单链表的创建及遍历

分数 20

读入n值及n个整数，建立单链表并遍历输出。

输入格式:

读入n及n个整数。

输出格式:

输出n个整数，以空格分隔（最后一个数的后面没有空格）。

输入样例:

在这里给出一组输入。例如：

2
10 5

输出样例:

在这里给出相应的输出。例如：

10 5

#include<iostream>
#include<cstdio>
typedef struct MyNode* NodePoint;
struct MyNode
{
    int data;
    NodePoint link;
};
void CreateNode(int NodeData, NodePoint* PRear) {
    NodePoint P;
    P = (NodePoint)malloc(sizeof(struct MyNode));
    P->data = NodeData;
    P->link = NULL;
    (*PRear)->link = P;
    *(PRear) = P;
}
NodePoint ReadNode() {
    int NodeNum, NodeData,PonitNum=0;
    NodePoint P, Rear, Temp;
    std::cin >> PonitNum;
    P = (NodePoint)malloc(sizeof(struct MyNode));
    P->link = NULL;
    Rear = P;
    for(int i=0;i<PonitNum;i++){
        std::cin>>NodeData;
        CreateNode(NodeData,&Rear);
    }
    Temp = P;
    P = P->link;
    free(Temp);
    return P;
}
void NodeAdd1(NodePoint P1, NodePoint P2) {
    if(P1==NULL&&P2==NULL){
        std::cout<<"NULL"<<"\n";
    }
    NodePoint P, P0;
    P = (NodePoint)malloc(sizeof(struct MyNode));
    P0 = P;
    while (P1 && P2) {
        if (P1->data <= P2->data) {
            P0->link = P1;
            P0 = P1;
            P1 = P1->link;
        }
        else {
            P0->link = P2;
            P0 = P2;
            P2 = P2->link;
        }
    }
    P0->link = P1 ? P1 : P2;
    P = P->link;
    if(P) {
        std::cout << P->data;
        P = P->link;
    }
    while (P) {
        std::cout << " " << P->data ;
        P = P->link;
    }
}
void NodeOut(NodePoint P) {
    if(P==NULL){
        std::cout<<"";
        return;
    }
    int stats=0;
    while (P) {
        if(stats==0){
            std::cout<<P->data;
            stats=1;
        } else{
            std::cout<<" "<<P->data;
        }
        P=P->link;
    }
}
int main() {
    NodePoint P1, P2, P3;
    P1 = ReadNode();
    NodeOut(P1);
}

7-7 求链式线性表的倒数第K项

分数 20

给定一系列正整数，请设计一个尽可能高效的算法，查找倒数第K个位置上的数字。

输入格式:

输入首先给出一个正整数K，随后是若干非负整数，最后以一个负整数表示结尾（该负数不算在序列内，不要处理）。

输出格式:

输出倒数第K个位置上的数据。如果这个位置不存在，输出错误信息NULL。

输入样例:

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

输出样例:

#include<stdio.h>
#include<malloc.h>

struct Node{
int data;
struct Node *next;
};

int main(void)
{
    struct Node *prior,*later,*head;
    int i,k;
    scanf("%d %d",&k,&i);

    prior=(struct Node *)malloc(sizeof(struct Node));
    later=prior;
    head=prior;
    prior->next=NULL;
    prior->data=i;

    k--;
    while(scanf("%d",&i),i>=0){
      struct Node *newOne;
      newOne=(struct Node *)malloc(sizeof(*newOne));
      newOne->data=i;
      newOne->next=NULL;
      prior->next=newOne;
      prior=newOne;
      k--;
      if(k<0)
        later=later->next;
    }

    if(k<=0)
      printf("%d",later->data);
    else
      printf("NULL");

    later=head->next;
    while(later->next){
      head->next=later->next;
      free(later);
      later=head->next;
    }
    free(later);
    free(head);

    return 0;
}

7-8 链表倒数n个结点的乘积

分数 20

本题要求计算单链表倒数n个结点的乘积。例如，给出单链表1 2 3 4 5，则倒数2个结点的乘积为20。

输入格式:

输入有2行，第一个行为2个非负整数m和n。其中m为链表结点个数，n为链表倒数结点的数量。题目保证计算结果在int范围内。

第二行为链表的m个数，以空格分隔。

输出格式:

在一行中输出倒数n个结点的乘积。

输入样例:

5 2
1 2 3 4 5

输出样例:

样例解释：

20 = 4 * 5

#include<stdio.h>
#include<stdlib.h>
struct node{
    int data;
    node* next;
};
node* create(int m,int n,int a[])
{
    node *p,*pre,*head;
    head=new node;
    head->next=NULL;
    pre=head;
    for(int i=0;i<m;i++)
    {
        p=new node;
        p->data=a[i];
        p->next=NULL;
        pre->next=p;
        pre=p;
    }
    return head;
}
int main()
{
    int m,n,a[100],c=1;
    scanf("%d%d",&m,&n);
    for(int i=0;i<m;i++)
        scanf("%d",&a[i]);
    node* l=create(m,n,a);l=l->next;
   for(int i=0;i<m-n;i++)l=l->next;
    while(l!=NULL){c*=l->data;l=l->next;}
    if(n!=0)printf("%d",c);
    else printf("0");
    return 0;
}

7-9 在有序链表中插入数据

分数 20

给定一批严格递增排列的整型数据，给定一个x，若x不存在，则插入x，要求插入后保持有序。存在则无需任何操作。

输入格式:

输入有两行：

第一个数是n值，表示链表中有n个数据。后面有n个数，分别代表n个数据。

第二行是要插入的数。

输出格式:

输出插入后的链表数据，以空格分开。行末不能有多余的空格。

输入样例1:

在这里给出一组输入。例如：

5 1 3 6 9 11
4

输出样例1:

在这里给出相应的输出。例如：

1 3 4 6 9 11

输入样例2:

在这里给出一组输入。例如：

5 1 3 6 9 11
3

输出样例2:

在这里给出相应的输出。例如：

1 3 6 9 11

#include <stdio.h>
#include <stdlib.h> 


typedef struct Node{
    int data;
    struct Node *next;
}LNode,*LinkList;


void InsertList(LinkList L,int x){
    LinkList p, pp,q;
    pp = (LinkList)malloc(sizeof(LNode));
    pp->data = x;
    for (q = L->next; q && q->data != x; q = q->next);
    if(q!=NULL) return;
    for (p = L; p->next && p->next->data < x; p = p->next);
    pp->next = p->next;
    p->next = pp;
}

void PrintList(LinkList L){
    LinkList p = L->next;
    while(p){
        if(p->next!=NULL){
            printf("%d ",p->data);
            p = p->next;
        }else{
            printf("%d",p->data);
            p = p->next;
        }
    }
}

int main(){
    int n,t;
    LinkList L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    if(scanf("%d",&n)==1){
        for(int i=0;i<n+1;i++){
            if(scanf("%d",&t)==1)
                InsertList(L,t);
        }
        PrintList(L);
    }
    return 0;
}

7-1 堆栈操作合法性

分数 20

假设以S和X分别表示入栈和出栈操作。如果根据一个仅由S和X构成的序列，对一个空堆栈进行操作，相应操作均可行（如没有出现删除时栈空）且最后状态也是栈空，则称该序列是合法的堆栈操作序列。请编写程序，输入S和X序列，判断该序列是否合法。

输入格式:

输入第一行给出两个正整数N和M，其中N是待测序列的个数，M（≤50）是堆栈的最大容量。随后N行，每行中给出一个仅由S和X构成的序列。序列保证不为空，且长度不超过100。

输出格式:

对每个序列，在一行中输出YES如果该序列是合法的堆栈操作序列，或NO如果不是。

输入样例：

4 10
SSSXXSXXSX
SSSXXSXXS
SSSSSSSSSSXSSXXXXXXXXXXX
SSSXXSXXX

输出样例：

YES
NO
NO
NO

#include<iostream>
#include<cstdio>
#include<string>
#include<algorithm>
 
using namespace std;
const int maxn=10010;
 
int main(){
 
    int n,m;
    
    cin>>n>>m;
    
    for(int i=0;i<n;i++){
        
        int cnt=0;
        string str;
        cin>>str;
        
        for(int j=0;j<str.length();j++){
            
            if(str[j]=='S') cnt++;
            else if(str[j]=='X') cnt--;
            
            if(cnt<0||cnt>m) 
             break;
        }
        
        if(cnt==0) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
        
    }
    
    
    return 0;
}

7-4 括号匹配

分数 20

检查一段C语言代码的小括号( )、中括号 [ ] 和大括号{ } 是否匹配。

输入格式:

在一行中输入一段C语言代码，长度不超过1000个字符（行末以换行符结束）。

输出格式:

第一行输出左括号的数量和右括号的数量，中间以一个空格间隔。

若括号是匹配的，在第二行打印YES，否则打印NO。

输入样例1:

for(int i=0; i<v; i++){ visited[i] = 0; for(int j=0; j<v; j++) scanf("%d",&(g->Adj[i][j])); }

输出样例1:

8 8
YES

输入样例2:

for(int i=0; i<v; i++) a(i]=0;

输出样例2:

2 2
NO

#include<iostream>
#include<cstdio>
typedef struct Node* NodePoint;
typedef class Stack* StackPoint;
struct Node{
    char data;
    NodePoint Link;
};
class Stack{
private:
    NodePoint head;
    NodePoint p;
    int StackLength;
    int Left;
    int Right;
public:
    Stack(){
        this->head=NULL;
        this->StackLength=0;
        this->Left=0;
        this->Right=0;
    }
    void LeftAdd(){
        this->Left++;
    }
    void RightAdd(){
        this->Right++;
    }
    int GetLeft(){
        return this->Left;
    }
    int GetRight(){
        return this->Right;
    }
    int GetLength(){
        return this->StackLength;
    }
    void StackPush(char data){
        NodePoint NewNode=new Node;
        NewNode->data=data;
        if(this->head==NULL){
            NewNode->Link=NULL;
            this->head=NewNode;
            this->p=NewNode;
        } else{
            NewNode->Link=this->p;
            this->p=NewNode;
        }
        this->StackLength++;
    }
    char StackPop(){
        if(this->StackLength<=0){
            abort();
        }
        NodePoint DeleteNode;
        char data;
        DeleteNode=this->p;
        data=p->data;
        this->p=this->p->Link;
        delete (DeleteNode);
        this->StackLength--;
        return data;
    }
};
bool Varify(char data1,StackPoint* s1){
    bool stat=true;
    char var1;
    if((*s1)->GetLength()<=0){
        stat= false;
        return stat;
    }
    if((*s1)->GetLength()>0) {
        var1 = (*s1)->StackPop();
    }
    if(data1==')'&&var1!='('){
        stat= false;
    }
    if(data1=='}'&&var1!='{'){
        stat= false;
    }
    if(data1==']'&&var1!='['){
        stat= false;
    }
    return stat;
}
void PrintNode(StackPoint* s1){
    while ((*s1)->GetLength()>0){
        std::cout<<(*s1)->StackPop();
    }
}
bool ReadNode(){
    bool stat= true;
    char data1;
    StackPoint s1=new Stack();
    data1=getchar();
    while (data1!='\n'){
        if(data1=='['||data1=='{'||data1=='('){
            s1->StackPush(data1);
            s1->LeftAdd();
        }
        if(data1==']'||data1=='}'||data1==')'){
            s1->RightAdd();
            stat=Varify(data1,&s1);
        }
        data1=getchar();
    }
if(s1->GetRight()!=s1->GetLeft()){
    stat= false;
}
std::cout<<s1->GetLeft()<<" "<<s1->GetRight()<<"\n";
    return stat;
}
int main(){
    bool stat;
    stat=ReadNode();
    if(stat== false){
        std::cout<<"NO";
    } else{
        std::cout<<"YES";
    }
}

7-6 字符串对称

分数 20

编写一个算法利用顺序栈判断一个字符串是否是对称串。所谓对称串是指从左向右读和从右向左读的序列相同。

输入格式:

输入一个无空格的字符串。

输出格式:

如果该字符是对称的，输出yes，否则输出no。

输入样例:

在这里给出一组输入。例如：

abba

输出样例:

在这里给出相应的输出。例如：

yes

输入样例:

在这里给出一组输入。例如：

abcd

输出样例:

在这里给出相应的输出。例如：

no

#include<stdio.h>
#include<iostream>
#include<string>
using namespace std;
#define MaxSize 60
typedef int ElemType;
typedef struct {
   ElemType data[MaxSize];
   int top; 
}SqStack;  

void InitStack(SqStack *&s){
    s=(SqStack *)malloc(sizeof(SqStack));
    s->top=-1;
}

void DestroyStack(SqStack *&s){
   free(s);
}

bool StackEmpty(SqStack *s){
    return(s->top==-1);
}

bool Push(SqStack *&s,ElemType e){
    if(s->top==MaxSize-1) 
       return false;
    s->top++; 
    s->data[s->top]=e;
    return true;
}

bool Pop(SqStack *&s,ElemType &e){
    if(s->top==-1)  
        return false;
    e=s->data[s->top]; 
    s->top--; 
    return true;
}

bool symmetry(string str){
   ElemType e;
   SqStack *st;
   InitStack(st);   
  
   for(int i=0;i<str.length();i++){
      Push(st,str[i]); 
   }
 
   for(int i=0;i<str.length();i++){
       Pop(st,e); 
       if(e!=str[i]){  
          DestroyStack(st);  
          return false;
       }
   }
   DestroyStack(st);
   return true;
}
int main(){
   string str;
   cin>>str;
   bool flag;
 
   flag=symmetry(str);
   if(flag)
       cout<<"yes"<<endl;
   else
       cout<<"no"<<endl;
}

7-7 数据结构考题十进制转换为二进制

分数 20

利用栈（以顺序栈作存储结构）实现进制转换。给定一个十进制整数，编程将该数以二进制形式输出。

顺序栈的类型定义：

#define MAXSIZE 100   // MAXSIZE为最大数据元素数目
typedef int ElemType;
typedef struct
{   ElemType  *base;
    ElemType  *top;
}SqStack;

输入格式:

输入一个十进制整数。

输出格式:

输出转换后的二进制数。

输入样例:

输出样例:

在这里给出相应的输出。例如：

#include <iostream>
using namespace std;
int main()
{
    int n;
    cin>>n;
    int a[100];
    int flag=0;
    while(n)
    {
        a[flag]=n%2;
        n=n/2;
        flag++;
    }
    for(int i=flag-1;i>=0;i--)
    {
        cout<<a[i];
    }
}

7-8 数据结构考题十进制转换为八进制

分数 20

利用栈（以顺序栈作存储结构）实现进制转换。给定一个十进制整数，编程将该数以八进制形式输出。

顺序栈的类型定义：

#define MAXSIZE 100   // MAXSIZE为最大数据元素数目
typedef int ElemType;
typedef struct
{   ElemType  *base;
    ElemType  *top;
}SqStack;

输入格式:

输入一个十进制整数。

输出格式:

输出转换后的八进制数。

输入样例:

输出样例:

在这里给出相应的输出。例如：

#include <iostream>
using namespace std;
int main()
{
    int n;
    cin>>n;
    int a[100];
    int flag=0;
    while(n)
    {
        a[flag]=n%8;
        n=n/8;
        flag++;
    }
    for(int i=flag-1;i>=0;i--)
    {
        cout<<a[i];
    }
}

7-5 队列操作

分数 20

请实现一个MyQueue类，实现出队，入队，求队列长度.

实现入队函数 void push(int x);

实现出队函数 int pop();

实现求队列长度函数 int size();

输入格式:

每个输入包含1个测试用例。每个测试用例第一行给出一个正整数 n (n <= 10^6) ，接下去n行每行一个数字，表示一种操作：

1 x ：表示从队尾插入x，0<=x<=2^31-1。

2 ：表示队首元素出队。

3 ：表示求队列长度。

输出格式:

对于操作2,若队列为空，则输出 “Invalid”,否则请输出队首元素。对于操作3，请输出队列长度。

每个输出项最后换行。

输入样例:

输出样例:

0
Invalid
1
100

#include <iostream>
#include<cstdio>
typedef struct MyNode* NodePoint;
struct MyNode{
    long long int data;
    NodePoint link;
};
class MyQuene{
    int Length;
    NodePoint P;
public:
    NodePoint FirstP;
    void push(long long int x){
        this->P->data=x;
        NodePoint P0=(NodePoint)malloc(sizeof(struct MyNode));
        P0->link=NULL;
        this->P->link=P0;
        this->P=P0;
        this->Length++;
    }
    int pop(){
        if(this->FirstP->link!=NULL){
            int num=this->FirstP->data;
            this->FirstP=this->FirstP->link;
            this->Length--;
            return num;
        }
    }
    int size(){
        return this->Length;
    }
    MyQuene(){
        this->Length=0;
        this->P=(NodePoint)malloc(sizeof(struct MyNode));
        this->P->link=NULL;
        this->FirstP=P;
    }
};
int main(){
    int Num=0;
    std::cin>>Num;
    MyQuene* q1=new MyQuene();
    for(int i=0;i<Num;i++){
        int control=0;
        std::cin>>control;
        switch (control) {
            case 1:
            {long long int tempnum=0;
            std::cin>>tempnum;
            (q1)->push(tempnum);}
                break;
            case 2:{
                int tempnum=0;
                if((q1)->FirstP->link==NULL){
                    std::cout<<"Invalid"<<'\n';
                } else{
                    tempnum=(q1)->pop();
                    std::cout<<tempnum<<"\n";
                }
            }
                break;
            case 3:{
                std::cout<<(q1)->size()<<"\n";
            }
                break;

        }
    }
}

7-1 二分查找

分数 20

输入n值(1<=n<=1000)、n个非降序排列的整数以及要查找的数x，使用二分查找算法查找x，输出x所在的下标（0~n-1）及比较次数。若x不存在，输出-1和比较次数。

输入格式:

输入共三行：

第一行是n值；

第二行是n个整数；

第三行是x值。

输出格式:

输出x所在的下标（0~n-1）及比较次数。若x不存在，输出-1和比较次数。

输入样例:

4
1 2 3 4
1

输出样例:

0
2

#include <iostream>
using namespace std;
int BinarySearch(int a[],int x,int n){
int left = 0;
int right =n-1;
int k =0;
while(left <= right){
int middle = (left + right)/2;
k++;
if(x== a[middle]){
cout<<middle<<endl;
cout<<k;
return middle;
}
if(x>a[middle]){
left =middle + 1;
}
else {
right = middle -1;
}

}
cout<<"-1"<<endl;
cout<<k;
return -1;
}
int main(){
int n;
cin>>n;
int *a=new int[n];
for(int i=0;i<n;i++){
cin>>a[i];
}
int x;
cin>>x;
BinarySearch(a,x,n);
return 0;
}

7-2 二分查找

分数 20

利用二分查找找出所给出的数在数组中的下标

输入格式:

第一行输入n和m表示数组有n个数据，m表示要对m个数进行查找

输出格式:

所有输出在一行完成，行末没有多余空格和多余回车。

输入样例:

5 5
1 2 3 4 5
1 2 3 4 5```

### 输出样例:
```out
0 1 2 3 4

#include<iostream>
#include<vector>
using namespace std;
int main(){
    int a,b,t;
    scanf("%d %d",&a,&b);
    vector<int> v(a);
    for(int i=0;i<a;i++)scanf("%d",&v[i]);
    int low=0;
    int high=a-1;
    for(int i=0;i<b;i++){
        scanf("%d",&t);
         low=0;
         high=a-1;
         if(v[low]==t){
             high=low;
         }else if(v[high]==t){
             low=high;
         }
         while(v[(low+high)/2]!=t){
             if(v[(low+high)/2]<t){
                 low=(low+high)/2;
             }else{
                 high=(low+high)/2;
             }
         }
         if(i!=0){
             printf(" ");
         }
        printf("%d",(low+high)/2);
    }
    return 0;
}

函数填空

5-3直接插入排序

分数 6

作者王东单位贵州师范学院

直接插入排序。

#include <iostream>
#define MAXSIZE 1000
using namespace std;

typedef struct
{
　int key;
　char *otherinfo;
}ElemType;
                    
typedef struct
{
　ElemType *r;
　int  length;
}SqList;

void InsertSort(SqList &L)
{
　int i,j;
　for(i=2;i<=L.length;++i)
　　　if(L.r[i].key<L.r[i-1].key)
　　　{                       
　　　　L.r[0]=L.r[i];    
　　　　L.r[i]=L.r[i-1];
　　　　for(int j=i-1;L.r[0].key< L.r[j].key;--j)
　　　　　　L.r[j+1]=L.r[j];
　　　　L.r[j+1]=L.r[0];    
　　　}                                        
}

void Create_Sq(SqList &L)
{
　int i,n;
　cin>>n;    //输入的值不大于 MAXSIZE
　for(i=1;i<=n;i++)
　{
　　cin>>L.r[i].key;
　　L.length++;
　}
}
void show(SqList L)
{
　int i;
　for(i=1;i<=L.length;i++)
　　if(i==1) 
　　　cout<<L.r[i].key;
　　else
　　　cout<<" "<<L.r[i].key;
}

int main()
{
 SqList L;
 L.r=new ElemType[MAXSIZE+1];
 L.length=0;
 Create_Sq(L);
 InsertSort(L);
 show(L);
 return 0;
}

输入样例：

第一行输入一个数n(输入的值不大于 MAXSIZE)，接下来输入n个数。

7
24 53 45 45 12 24 90

输出样例：

输出排序结果。

12 24 24 45 45 53 90

5-4简单选择排序

分数 6

简单选择排序。

#include <iostream>
#define MAXSIZE 1000
using namespace std;

typedef struct
{
 int key;
 char *otherinfo;
}ElemType;
                    
typedef struct
{
 ElemType *r;
 int  length;
}SqList;


void SelectSort(SqList &L) 
{ 
 int i,j,k;
 ElemType t;
 for(i=1;i<L.length;++i) 
  {
    k=i;                 
    for(j=i+1;j<=L.length;++j)
      if(L.r[j].key<L.r[k].key)  k=j;    
    if(k!=i) 
    {t=L.r[i];L.r[i]=L.r[k];L.r[k]=t;}       
  }                                 
}                                            
                                
void Create_Sq(SqList &L)
{
 int i,n;
 cin>>n;    //输入的值不大于 MAXSIZE
 for(i=1;i<=n;i++)
 {
  cin>>L.r[i].key;
  L.length++;
 }
}
void show(SqList L)
{
 int i;
 for(i=1;i<=L.length;i++)
  if(i==1) 
   cout<<L.r[i].key;
  else
   cout<<" "<<L.r[i].key;
}

int main()
{
 SqList L;
 L.r=new ElemType[MAXSIZE+1];
 L.length=0;
 Create_Sq(L);
 SelectSort(L);
 show(L);
 return 0;
}

输入样例：

第一行输入一个数n(输入的值不大于 MAXSIZE)，接下来输入n个数。

7
24 53 45 45 12 24 90

输出样例：

输出按升序排序的结果。

12 24 24 45 45 53 90

5-1希尔排序的分步结果

分数 4

本题要求给出希尔排序对给定初始序列{9, 8, 7, 6, 5, 4, 3, 2, 1}利用增量序列{1, 3, 7}进行排序的分步结果。将每步结果填在下列空中。注意：相邻数字间必须有一个空格，开头结尾不得有多余空格。

原始序列	9 8 7 6 5 4 3 2 1
增量7排序后	2 1 7 6 5 4 3 9 8 2 分
增量3排序后	2 1 4 3 5 7 6 9 8 2 分
增量1排序后	1 2 3 4 5 6 7 8 9

5-2冒泡排序

分数 4

作者王东单位贵州师范学院

冒泡排序（按升序排）。

#include <iostream>
#define MAXSIZE 1000
using namespace std;

typedef struct
{
 int key;
 char *otherinfo;
}ElemType;
                    
typedef struct
{
 ElemType *r;
 int  length;
}SqList;

void BubbleSort(SqList &L)
{
 int m,j,flag;
 ElemType t;
 m=L.length-1; flag=1; 
 while(m>0 && flag==1)
  {
    flag=0; 
    for(j=1;j<=m;j++)
      if(L.r[j].key > L.r[j + 1].key) 
        {
          flag=1;    
          t=L.r[j];L.r[j]=L.r[j+1];L.r[j+1]=t;
        }
    --m;
  }
}

void Create_Sq(SqList &L)
{
 int i,n;
 cin>>n;    //输入的值不大于 MAXSIZE
 for(i=1;i<=n;i++)
 {
  cin>>L.r[i].key;
  L.length++;
 }
}
void show(SqList L)
{
 int i;
 for(i=1;i<=L.length;i++)
  if(i==1) 
   cout<<L.r[i].key;
  else
   cout<<" "<<L.r[i].key;
}

int main()
{
 SqList L;
 L.r=new ElemType[MAXSIZE+1];
 L.length=0;
 Create_Sq(L);
 BubbleSort(L);
 show(L);
 return 0;
}

输入样例：

第一行输入一个数n(输入的值不大于 MAXSIZE)，接下来输入n个数。

7
24 53 45 45 12 24 90

输出样例：

输出按升序排序的结果。

12 24 24 45 45 53 90

5-5折半插入排序

折半插入排序。

#include <iostream>
#define MAXSIZE 1000
using namespace std;

typedef struct
{
 int key;
 char *otherinfo;
}ElemType;
                    
typedef struct
{
 ElemType *r;
 int  length;
}SqList;

void BInsertSort(SqList &L){
 int i,j,low,high,m;
 for(i=2;i<=L.length;++i)
 {
   L.r[0]=L.r[i]; 
   low=1; high=i-1;
   while(low<=high)
   {
   m=(low+high)/2;
    if(L.r[0].key<L.r[m].key)  
          high=m-1;
      else  
          low=m+1;
   }
   for(j=i-1;j>=high+1;--j) 
       L.r[j+1]=L.r[j];
    L.r[high+1]=L.r[0];
  }
}

void Create_Sq(SqList &L)
{
 int i,n;
 cin>>n;    //输入的值不大于 MAXSIZE
 for(i=1;i<=n;i++)
 {
  cin>>L.r[i].key;
  L.length++;
 }
}
void show(SqList L)
{
 int i;
 for(i=1;i<=L.length;i++)
  if(i==1) 
   cout<<L.r[i].key;
  else
   cout<<" "<<L.r[i].key;
}


int main()
{
 SqList L;
 L.r=new ElemType[MAXSIZE+1];
 L.length=0;
 Create_Sq(L);
 BInsertSort(L);
 show(L);
 return 0;
}

输入样例：

第一行输入一个数n(输入的值不大于 MAXSIZE)，接下来输入n个数。

7
24 53 45 45 12 24 90

输出样例：

输出排序结果。

12 24 24 45 45 53 90

林挽风

关注

4
点赞
踩
38

收藏

觉得还不错? 一键收藏
1
评论
数据结构操作题题库

7-1 顺序表的建立及遍历分数 20读入n值及n个整数，建立顺序表并遍历输出。输入格式:读入n及n个整数输出格式:输出n个整数，以空格分隔（最后一个数的后面没有空格）。输入样例:在这里给出一组输入。输出样例:在这里给出相应的输出。7-2 jmu-ds-顺序表区间元素删除分数 20若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。
复制链接

扫一扫