数据结构代码题

豆奶特浓6

已于 2024-09-29 21:48:26 修改

阅读量238

点赞数 3

分类专栏： 408数据结构文章标签：数据结构

于 2024-09-07 23:26:49 首次发布

本文链接：https://blog.csdn.net/m0_61049985/article/details/142006467

版权

408数据结构专栏收录该内容

9 篇文章 1 订阅

订阅专栏

文章目录

（2009）查找链表中倒数第k个节点
数组循环左移
找到两组升序序列的中位数
找到两个链表共同后缀的起始位置
寻找一个整数序列中的主元素
求二叉树的带权路径长度
删除链表中绝对值相同的元素
子集划分后求和做差取最小
给定表达式树转化等价中缀表达式
找到整数数组中未出现的最小正整数
重排单链表
三个三元组中计算最小距离
判断EL路径
判断线性存储的数是否为二叉排序树
统计出度大于入度的顶点

（2009）查找链表中倒数第k个节点

利用双指针的思想。

让快指针先走k步，然后快慢指针同时向后移动，直到快指针为空，此时慢指针指向的就是倒数第k个结点。

typedef struct Node
{
    int data;
    struct Node *link;
}LinkNode,*LinkList;

int find_k(LinkList L,int k)
{
    if (L->next==NULL || k<=0){return NULL;}
    Node *slow=L->next, *fast=L->next;
    slow=L->next;
    fast=slow;
    while(k>0 && fast!=NULL)
    {
        fast=fast->next;
        k--;
    }
    if(fast==NULL){return NULL;}
    while(fast!=NULL){
        fast=fast->next;
       	slow=slow->next;
    }
    return slow->data;
}

数组循环左移

利用数组反转的思想。

对数组元素先整体反转，再根据左移位数，划分两部分反转。

void Reverse(int a[],int left,int right)
{
    while(left<right)
    {
        int temp=a[left];
        a[left]=a[right];
        a[right]=temp;
        left++;
        right--;
    }
}

void RotateLeft(int R[],int n,int p)
{
    Reverse(R,0,n-1);
    Reverse(R,0,p-1);
    Reverse(R,p,n-1);
}

找到两组升序序列的中位数

采用类似二分查找的思想。

找出每组序列的中位数，进行比较，相等则返回，不等则舍去相同数量的元素后再进行寻找中位数。

int FindMiddle(int A[],int B[],int n)
{
    int al=0,ar=n-1,bl=0,br=n-1;
    while(al!=ar || bl!=br)
    {
        int am=(al+ar)/2;
        int bm=(bl+br)/2;
        
        if(A[am]==B[bm])
           return A[am];
        
        if(A[am]<B[bm])
        {
            if((ar-al+1)%2==0)
                br=bm+1;
            else
                br=bm;
            al=am;
        }
        else
        {
            if((br-bl+1)%2==0)
                bl=bm+1;
            else
                bl=bm;
            ar=am;
        }
    }
    return A[am]<B[bm]?A[am]:B[bm];
}

找到两个链表共同后缀的起始位置

采取尾部对齐的方法。

先求出两个链表的长度，让长链表指针先移动差值步，再两者一起移动，边移动边比较是否地址相同。

另法：不求出长度，循环让两个链表移动，当一个链表指针走到空时，让其指向另一个链表的表头结点，继续移动，知道找到两个地址相同的结点。

typedef struct ListNode
{
    char data;
    strcut ListNode *next;
}Node;

int GetLength(Node* str)
{
    int len=0;
    Node *p=str->next;
    while(p!=NULL)
    {
        p=p->next;
        len++;
    }
    return len;
}

Node* FindCommonNode(Node* str1,Node* str2)
{
    Node *p=str1->next,*q=str2->next;
    if(p==NULL || Q==NULL)
        return NULL;
    
    int len_1=GetLength(str1);
    int len_2=GetLength(str2);
    int offset=len_1>len_2;
    if(len_1<len_2)
    {
        offset=len_2-len_1;
        p=str2->next;
        q=str1->next;
    }
    while(offset--)
        q=q->next;
    while(p!=NULL)
    {
        if(p==q)
            return p;
        p=p->next;
        q=q->next;
    }
    return NULL;
}

另法代码

Node* FindCommonNode2(Node* str1,Node* str2)
{
    Node *p=str1->next,*q=str2->next;
    if(p==NULL || Q==NULL)
        return NULL;
    
   while(p!=q)
   {
       p=(p==NULL?str2->next:p->next);
       q=(q==NULL?str1->next:q->next);
   }
    return NULL;
}

寻找一个整数序列中的主元素

采取贪心的思想。

投票法。假定当前元素是序列中的主元素，出现次数为1。遍历数组，若与当前元素相同则次数加一，不同则减一，次数为零，说明该元素不是主元素，更换假定的主元素。

void FindMajor(int A[],int n)
{
    int i;
    int key,count,sum;
    key=A[0];
    sum=1;
    for(i=1;i<n;i++)
    {
        if(key==A[i])
            sum++;
        else
            if(--sum==0)
            {
                key=A[i];
                sum=1;
            }
    }
    for(i=0;i<n;i++)
    {
        if(A[i]==key)
            count++;
    }
    if(count>n/2)
        printf("%d",key);
    else
        printf("-1");
}

求二叉树的带权路径长度

采用先序遍历的思想。

参数传递需要传递当前层次，若当前结点为叶结点，则返回当前结点的带权路径长度。若非叶结点，则递归遍历左右子树。

typedef struct BTNode
{
    int weight;
    struct BTNode* left;
    struct BTNode* right;
}

int CalcWPL(BTNode *root,int level)
{
    if(root==NULL)
        return 0;
    if(root->left==NULL && root->right==NULL)
        return root->weight*level;
    int left_wpl=CalcWPL(root->left,level+1);
    int right_wpl=CalcWPL(root->right,level+1);
    return left_wpl+right_wpl;
}

删除链表中绝对值相同的元素

采用哈希映射的思想。

申请一个数组统计当前元素绝对值是否出现过，出现过则删除该元素，若数组元素为0，则说明是第一次出现，遍历下一个。

typedef struct LinkNode
{
    int data;
    strtuct LinkNode *link;
}LinkNode;

int abs(int a)
{
    return a>0?a:-a;
}

void Remove(LinkNode *head,int n)
{
    if(head->link==NULL || head->link->link==NULL)
        return ;
    int i;
    int *hash=(int *)malloc(sizeof(int)*(n+1));
    for(i=0;i<n+1;i++)
    {
        hash[i]=0;
    }
    LinkNode *p,*q;
    p=head->link,q=p->link;
    while(p!=NULL)
    {
        if(hash[abs(p->data)])
        {
            p->link=q->link;
            free(q);
            q=p->link;
        }
        else
        {
            hash[abs(p->data)]=1;
            p=q;
            q=p->link;
        }
    }
}

子集划分后求和做差取最小

采用快速排序的思想。

但是不必对整个数组进行划分，只需要排序到使用的枢轴点为数组元素的中间位置即可，左右两边不必全部有序。

int SpliceArray(int A[],int n)
{
    int i;
    int left=0,right=n-1;
    int low=left,high=right;
    int key=A[low];
    int mid=n/2-1;
    int s1=0,s2=0;
    
    while(1)
    {
        while(low<high)
        {
            while(low<high && A[high]>=key)
                high++;
            A[low]=A[high];
            while(low<high && A[low]<=key)
                low++;
            A[high]=A[low];
        }
        A[low]=key;
        if(low==mid)
            break;
        if(low<mid)
        {
            left=++low;
            high=right;
        }
        if(low>mid)
        {
            right=--high;
            low=left;
        }
    }
    
    for(i=0;i<=mid;i++)
    {
        s1+=A[i];
        s2+=A[i+mid+1];
    }
    
    return s2-s1;
}

给定表达式树转化等价中缀表达式

采用中序遍历的思想。

注意括号的添加。当前结点为叶子结点不用添加括号，若为分支结点且不为根结点，遍历前后添加括号。对于根节点，利用当前层次作为参数去限制括号输出。

typedef struct node
{
    char data[10];
    struct node *left,*right;
}BTree;

void BTreeToExp(BTree *root,int level)
{
    if(root!=NULL)
    {
        if(root->left==NULL && root->right==NULL)
            printf("%s",root->data);
        else
        {
            if(level>0)
                pritnf("(");
            BTreeToExp(root->left,level+1);
            printf("%s",root->data);
            BTreeToExp(root->right,level+1);
            if(level>0)
                printf(")");
        }
        
    }
}

找到整数数组中未出现的最小正整数

采用哈希映射的思想。

注意到n个元素的整数数组，未出现的最小整数只可能是[1,n+1]，利用一个辅助数组，大小为n+1，记录该下标的正整数是否出现。最后再遍历辅助数组。

int FindMinInt(int a[],int n)
{
    int i;
    int *hash=(int *)malloc(sizeof(int)*(n+1));
    
    for(i=0;i<n+1;i++)
        hash[i]=0;
    
    for(i=0;i<n;i++)
        if(a[i]>0 && a[i]<=n)
            hash[a[i]]=1;
    
    for(i=1;i<=n;i++)
        if(hash[i]==0)
            return i;
    
    return n+1;
}

重排单链表

采用链表逆置的思想。

先利用快慢指针，找到中间结点，对后半部分链表逆置，然后两个链表进行合并。

void ReOrder(NODE *head)
{
    NODE *fast,*slow;
    slow=fast=head->next;
    while(fast!=NULL)
    {
        fast=fast->next;
        slow=slow->next;
        if(fast->next!=NULL)
            fast=fast->next;
    }
    
    NODE *cur,*pre,post;
    pre=NULL;
    cur=slow->next;
    post=cur->next;
    while(cur!=NULL)
    {
        cur->next=pre;
        pre=cur;
        cur=post;
        post=post-next;
    }
    
    NODE *h1,*h2,*p;
    h1=head->next;
    p=h2=pre;
    while(h2!=NULL)
    {
        p=p->next;
        h2->next=h1->next;
        h1->next=h2;
        h1=h2->next;
        h2=p;
    }
}

三个三元组中计算最小距离

采用三路归并的思想。

利用线段法推导易知，最小距离为三个数中最大数与最小数距离的两倍。只需找到三个数中的最小值，逐步让其靠近最大值即可。

int abs(int a)
{
    if(a<0)	return -a;
    else	return a;
}

bool is_min(int a,int b,int c)
{
    if(a<=b && a<=c)	return ture;
    return false;
}
int FindMinDist(int S1[],int S2[],int S3[])
{
    int n1=sizeof(S1)/sizeof(S1[0]);
    int n2=sizeof(S2)/sizeof(S2[0]);
    int n3=sizeof(S3)/sizeof(S3[0]);
    
    int min_dist=INT_MAX;
    int dist;
    int i,j,k;
    i=j=k=0;
    while(i<n1 && j<n2 && k<n3)
    {
        dist=abs(S1[i]-S2[j])+abs(S2[j]-S3[k])+abs(S[k]-S[i]);
        if(dist<min_dist)
            min_dist=dist;
        if(is_min(S1[i],S2[j],S3[k]))
            i++;
        else if(is_min(S2[j],S3[k],S1[i]))
            j++;
        else
            k++;
    }
    
    return min_dist;
}

判断EL路径

采用双重循环遍历的思想。

代码没啥难度，纯送分。

typedef struct{
    int numVertices,numEdges;
    char VerticesList[MAXV];
    int Edge[MAXV][MAVX];
}MGraph;

int IsExistEL(MGraph G)
{
    int count,sum;
    int i,j
    int n=numVertices;
    count=0;
    for(i=0;i<n;i++)
    {
        degree=0;
        for(j=0;i<n;i++)
            if(G.Edge[i][j]!=0)
                degree++;
        if(degree%2!=0)
            count++;
    }
    if(count==0 || count==2)
        return 1;
    return 0;
}

判断线性存储的数是否为二叉排序树

采用中序遍历的思想。

法一，根据二叉排序树的遍历特性，中序遍历得到一个升序序列，对二叉树进行中序排序，将得到的数据保存在数组中，遍历数组看是否满足升序要求。、

法二，根据二叉排序树的树的特性，左子树小于根小于右子树。递归遍历数组进行判断。

typedef struct{
    int SqBiTNode[MAX_SIZE];
    int ElemNum;
}SqBiTree;

static int k=0;

void InOrder(SqBiTree *t,int *temp,int i)
{
    if(t->SqBiTNode[i]!=-1 && i<t->ElemNum)
    {
        InOrder(t,temp,2*i+1);
        temp[k++]=t->SqBiTNode[i];
        InOrder(t,temp,2*i+2);
    }
}

bool JudgeBST(SqBiTree *t)
{
    int i,n;
    n=t->ElemNum;
    int *temp=(int *)malloc(sizeof(int)*n);
    for(i=0;i<n;i++)
        temp[i]=0;
    InOrder(t,temp,0);
    for(i=1;i<k;i++)
        if(temp[i-1]<=temp[i])
        {
            continue;
        }else
            return false;
    return true;
}

另法

bool JudgeBST(SqBiTree *t,int k,int *val)
{
    if(k<t->ElemNum && t->SqBiTNode!=-1)
    {
        if(!JudegerBST(t,2*k+1,val))	return false;
        if(t->SqBiTNode[k]<=*val)	return false;
        *val=t->SqBiTNode[k];
        if(!JudgeBST(t,2*k+2,val))	return false;
    }
}

统计出度大于入度的顶点

采用双重循环遍历的思想。

没啥难度，纯送。

int printVertices(MGraph G)
{
    int n=G.numVertices;
    int inDegree,outDegree;
    int k_num;
    int i,j;
    for(i=0;i<n;i++)
    {
        inDegree=outDegree=0;
        for(j=0;j<n;j++)
        {
            if(G.Edge[i][j]!=0)
                outDegeree++;
            if(G.Edeg[j][i]!=0)
                inDegree++;
        }
        if(inDegree>outDegree)
        {
            printf("%c ",G.VerticesList[i]);
            k_num++;
        }
    }
    return k_num++;
}