数据结构复习

1. 函数 GetElem实现返回单链表的第i个元素

    int GetElem(ListNode* head, int i) {

    ListNode* p = head;

    int count = 1;

while (p && count < i)

{

        p = p->next;

        count++;

   }

    return (count == i && p) ? p->val : -1;

}

1. 函数实现单链表的插入算法

ListNode *InsertElem(ListNode *head, int i, int val){

 P=L;j=0;

While(p&&j<i-1)

p=p->next:++j;

if(!p||j>i-1)return error;

s=(LinkList)malloc(sizeof(LNode));

1. >data=e;s->next=p->next;

1. >next=s;

Retuen ok;

}

1. 函数实现顺序表删除算法

 4.void DeleteElem(int* arr, int& n, int index) {

    if (index < 0 || index >= n)

       Return ERROR;

    for (int i = index; i < n - 1; i++)

{ arr[i] = arr[i + 1];}

}

1. 函数实现单链表的删除算法

Status ListDelete(SqList *L, int i, ElemType *e) {

    int k;

    if (L->length == 0||i < 1 || i > L->length)

        return ERROR;

    *e = L->data[i-1];

    if (i < L->length) {

        for (k = i; k < L->length; k++)

            L->data[k-1] = L->data[k];

    L->length--;

    return OK;

}

1. 带头结点单链表的逆置算法

void reverseLinkedList(ListNode* head) {

    {Lnode*p,*q,*r;

if(!head->next)returnERROR;

p=head->next;q=p->next;p->next=NULL;

while(q)

{r=q->next;

q->next=p;

head->next=q;

p=q;

q=r; }

1. 试编写一个算法，将一个顺序表逆置

void reverseArrayList(vector<int>& arr) {

    int left = 0;                 // 左边指针，指向表头

    int right = arr.size() - 1;    // 右边指针，指向表尾

    while (left < right) {

        // 交换左右指针所指向的元素

        int temp = arr[left];

        arr[left] = arr[right];

        arr[right] = temp;

        // 左指针向右移动，右指针向左移动

        left++;

        right--;

    }

}

1. 有两个循环链表，链头指针分别为L1和L2，要求写出算法将L2 链表链到L1链表之后，且连 接后仍保持循环链表形式。

void merge(Lnode *L1, Lnode *L2)

{

    Lnode *p, *q;

    if(L1->next == L1) // 如果L1为空链表

    {

        L1->next = L2->next;

        L2->next = L1;

    }

    else // 如果L1不为空链表

    {

        p = L1->next; // p指向L1的第一个结点

        while(p->next != L1) // 找到L1的最后一个结点

            p = p->next;

        p->next = L2->next; // 将L1的最后一个结点指向L2的第一个结点

    }

    q = L2->next; // q指向L2的第一个结点

    while(q->next != L2) // 找到L2的最后一个结点

        q = q->next;

    q->next = L1; // 将L2的最后一个结点指向L1

}

1. 设有两个集合A和集合B，要求设计生成集合C=A∩B的算法，其中集合A、B和C用链式存储结构表示

void intersection(LinkList LA, LinkList LB, LinkList& LC) {

    //带头节点两集合的交集算法(C++)

    LinkList pa = LA->link, pb = LB->link, pc = LC;

    while (pa != NULL) {

        while (pb != NULL) {

            if (pa->data == pb->data)//尾插法

            {

                LinkList s = (LinkList)malloc(sizeof(LNode));

                if (s != NULL) {

                    s->data = pa->data;

                    pc->link = s;

                    pc = s;

                    break;

                }

            }

            pb = pb->link;

        }

        pb = LB;

        pa = pa->link;

    }

    pc->link = NULL;//LC尾节点初始化为NULL

}

1. 已知栈的基本操作函数：

intInitStack(SqStack*S);//构造空栈

intStackEmpty(SqStack*S);//判断栈空

intPush(SqStack*S,ElemTypee);//入栈

intPop(SqStack*S,ElemType*e);//出栈

函数conversion 实现十进制数转换为八进制数

void conversion(){

    SqStack S;

    int N, e;

    InitStack(&S);

    scanf("%d",&N);

    while(N){

        Push(&S, N%8);

        N = N/8;

    }

    while(!StackEmpty(&S)){

        Pop(&S, &e);

        printf("%d", e);

    }

}

1. 假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾结点，但不设头指针，请写出相应的入队列算法（用函数实现）

int insert_SqQueue(SqQueue &p,Elemtype e) {

    Queue *q;

    q = (Queue*)malloc(sizeof(Queue));

    if(!q)

        return 0;

    q->date = e;

    q->next = p.rear->next;                     // 构成循环，q的下一个是队列头

    p.rear->next = q;                           // 入队,插入到表尾之后

    p.rear = q;                                 // 更新表尾指针为q指针

    return 1;

}

1. 对于一个栈，给出输入项 A,B,C,D，如果输入项序列为 A,B,C,D，试给出全部可能的输出序列

D C B A  C D B A  C B D A  C B A D  B D C A  B C D A  B C A D  B A D C  B A C DA D C B

A C D B  A C B D  A B D C  A B C D

  解答技巧：先出来的序号后面一定不能有比他本身小的从小到大排列的序列。

1. 设队列 Q=（1，3，5，2，4，6），完成队列的倒置算法

def reverse_queue(queue):

    stack = []

    # 将队列元素压入栈

    while len(queue) > 0:

        stack.append(queue.pop(0))

    # 将栈元素重新入队

    while len(stack) > 0:

        queue.append(stack.pop())

    return queue

# 测试

queue = [1, 3, 5, 2, 4, 6]

reversed_queue = reverse_queue(queue)

print(reversed_queue)  # 输出：[6, 4, 2, 5, 3, 1]

1. 函数 InOrderTraverse(Bitreebt) 实现二叉树的中序遍历

void InOrderTraverse(BiTree bt) {

    if (bt == NULL)  return 0;    //递归的结束条件----某结点为空时

    InOrderTraverse(bt->lchild);   //中序遍历根结点的左子树

    printf("%d",bt->data);      //这里用printf data表示访问结点的数据域

    InOrderTraverse(bt->rchild);   //中序遍历根结点的右子树

}

1. 函数 depth实现返回二叉树的高度

def depth(root):

    if root is None:

        return 0

    else:

        left_depth = depth(root.left)

        right_depth = depth(root.right)

        return 1+  1 + (leftdepth > rightdepth?leftdepth:rightdepth);

1. 交换二叉树结点左右子树的递归算法

void invert_tree(TreeNode* root) {

    if (root == NULL)

        return;

    // 交换左右子树

    TreeNode* temp = root->left;

    root->left = root->right;

    root->right = temp;

    // 递归调用左右子树

    invert_tree(root->left);

    invert_tree(root->right);

}

1. 编写求一棵二叉树中结点总数的算法

function sumNode(node):

    if node is NULL:

        return 0

    else:

        return sumNode(node->lchild) + sumNode(node->rchild) + 1

1. 实现图的深度优先遍历算法

void DFS(int v, int visited[], int **edge, int n) {

    // 访问顶点v

    visited[v] = 1;

    printf("%d ", v);

       for (int i = 0; i < n; ++i) { // 遍历顶点v的所有邻接顶点

        if (edge[v][i] != 0 && visited[i] == 0) {

            DFS(i, visited, edge, n);

        }

    }

}

1. 在有向图的邻接表存储结构下，从顶点V1出发，完成DFS遍历的与BFS遍历的算法
2. 写出用直接插入排序将关键字序列 {54,23,89,48,64,50,25,90,34} 排序过程的每一趟结果

23,54

23,54,89，

23,48,54,89

23,48,54,64,89

23,48,50,54,64,89

23,25,48,50,54,64,89

23,25,48,50,54,64,89,90

23,25,34,48,50,54,64,89,90

1. 设待排序序列为{10,18,4,3,6,12,1,9,15,8}请写出希尔排序每一趟的结果,增量序列为

5，3，2，1。

增量 5: 10, 1, 4, 3, 6, 12, 18, 9, 15, 8

增量 3: 8, 1, 4, 3, 6, 12, 10, 9, 15, 18

增量 2: 6, 1, 4, 3, 8, 9, 10, 12, 15, 18

增量 1: 1, 3, 4, 6, 8, 9, 10, 12, 15, 18

1. 已知关键字序列 {418，347，289，110，505，333，984，693，177}，按递增排序，求初始堆（画出初始堆的状态）。
2. 有一关键字序列（ 265，301，751，129，937，863，742，694，076，438），写出希尔排序的每 趟排序结果。（取增量为 5，3，1）
3. 对关键子序列（72，87，61，23，94，16，05，58）进行堆排序，使之按关键字递减次序排列（最小堆），请写出排序过程中得到的初始堆和前三趟的序列状态。

4. 

评价一个算法的质量涉及多个方面的考量，以下是一些主要的评估标准和方法：

正确性：确保算法在各种输入情况下能够产生正确的输出。这包括边界条件、异常情况和一般情况的处理能力。

效率：时间复杂度：评估算法在处理数据时所需的时间量级。低时间复杂度通常意味着算法更有效率。

空间复杂度：评估算法在运行时所需的内存或其他资源的量级。

可读性和可维护性：算法代码应该清晰易懂，结构良好，遵循良好的编码规范和设计模式，以便他人能够理解和修改。

健壮性：算法在面对无效输入或不可预见的情况时的表现。健壮的算法能够在错误情况下提供合理的反馈或继续执行。

可扩展性：

1. 下面程序段的功能是实现二分查找算法，请在下划线处填上正确的语句。

struct record{int key; int others;};

int bisearch(struct record r[ ], int k)

{

  int low=0,mid,high=n-1;

  while(low<=high)

{

    _mid=(low+high)/2_______________________________;

    if(r[mid].key==k) return(mid); else if(___[mid].key<k_________) high=mid-1;else low=mid+1;

  }

  return(0);

}