2021-7-24算法学习（算法笔记253-268）

一、链表

1. 动态链表：
   可看blog的数据结构专题

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

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

Node create(int Array[])
{
    Node head,p,pre;
    head=(node*)malloc(sizeof(node));
    head->next=NULL;
    pre=head;
    for(int i=0;i<5;i++)
    {
        p=(node*)malloc(sizeof(node));
        p->data=Array[i];
        p->next=NULL;
        pre->next=p;
        pre=p;
    }
    return head;
}

int main()
{
    int Array[5]={5,3,6,1,2};
    Node List=create(Array);
    Node L=List->next;
    while(L!=NULL)
    {
        printf("%d ",L->data);
        L=L->next;
    }
}

2. 静态链表
   对于一些问题，结点的地址是比较小的整数，这样直接使用静态链表即可。
   （此系列专题偏向应用于算法考试，因此推荐使用静态链表）

静态链表的实现原理是hash，即通过建立一个结构体数组，并令数组的下标直接表示结点的地址，来达到直接访问数组中的元素就能访问结点的效果。无需头结点。

例题：

PAT A1032 sharing

ps. 用map容易超时？？！

#include<stdio.h>
using namespace std;
struct Node
{
    char word;
    int next;
    bool flag=false;
};
int main()
{
    int i,N;
    int firstNode,secondNode;
    int temp1,temp2,temp;
    char tWord;
    struct Node link[100010];
    scanf("%d %d %d",&firstNode,&secondNode,&N);
    for(i=0;i<N;i++)
    {
        scanf("%d %c %d",&temp1,&tWord,&temp2);
        link[temp1].word=tWord;
        link[temp1].next=temp2;
    }
    temp=firstNode;
    while(temp!=-1)
    {
        link[temp].flag=true;
        temp=link[temp].next;
    }

    temp=secondNode;
    while(temp!=-1)
    {
        if(link[temp].flag==true)
        {
            printf("%05d",temp);
            break;
        }

        temp=link[temp].next;
    }

    if(temp==-1) printf("-1");

}

PAT A1052 Linked List Sorting

注意第一行的首地址输出也要05d%，这里是容易忘记的

count==0，也就是无法形成链表时，输出 0 -1

题目不难，但感觉我写的有点复杂？ 巨巨们写的都好简洁QAQ

#include <stdio.h>
#include <algorithm>
using namespace std;
struct Node
{
    int data;
    int address;
    int next;
} node[100010];
bool cmp(Node a, Node b)
{
    return a.data < b.data;
}
int main()
{
    int i, N, head;
    int t1, t2, t3, temp;
    scanf("%d%d", &N, &head);
    for (i = 0; i < N; i++)
    {
        scanf("%d%d%d", &t1, &t2, &t3);
        node[t1].address = t1;
        node[t1].data = t2;
        node[t1].next = t3;
    }
    struct Node result[100010];
    temp = head;
    int count = 0; //有效个数
    while (temp != -1)
    {
        result[count].address = node[temp].address;
        result[count].data = node[temp].data;
        result[count].next = node[temp].next;
        count++;
        temp = node[temp].next;
    }
    if(count==0) printf("0 -1");
    else
    {

    

    sort(result, result + count, cmp);
    for (i = 0; i < count; i++)
    {
        if (i != count - 1)
            result[i].next = result[i + 1].address;
        else if (i == count - 1)
            result[i].next = -1;
    }
    printf("%d %05d\n",count,result[0].address);
    for (i = 0; i < count; i++)
    {
        if (result[i].next == -1)
        {
            printf("%05d %d -1\n", result[i].address, result[i].data);
        }
        else
        {
            printf("%05d %d %05d\n", result[i].address, result[i].data, result[i].next);
        }
    }
    }
}

二、二叉树

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

//二叉树的存储结构
typedef struct TNode *Bintree;
struct TNode
{
    int data;
    Bintree left;
    Bintree right;
};

Bintree root = NULL;
//新建结点
TNode *newNode(int v)
{
    TNode *node = (TNode *)malloc(sizeof(struct TNode));
    node->data = v;
    node->left = NULL;
    node->right = NULL;
    return node;
}

//查找结点 并将找到的结点的数据改为指定数据
void find(Bintree root, int x, int newdata)
{
    if (root == NULL)
        return;
    if(root->data==x)
        root->data=newdata;
    find(root->left,x,newdata);
    find(root->right,x,newdata);
}

//二叉树结点的插入
void insert(Bintree &root,int x) //这里二叉树的根结点已经定义为全局变量了，引用传递进去
{
    if(root==NULL) //空树，插入位置就是这个位置
    {
        root=newNode(x);
        return;
    }
    
    if(x应该插入在左子树)
    {
        insert(root->left,x);
    }
    else
    {
        insert(root->right,x);
    }
}