noj6；双向循环链表LOCATE操作

最新推荐文章于 2022-06-17 15:20:44 发布

原创最新推荐文章于 2022-06-17 15:20:44 发布 · 725 阅读

15 ·

CC 4.0 BY-SA版权

noj 专栏收录该内容

33 篇文章

订阅专栏

本文详细介绍了使用链表实现字符频率计数与排序的过程。通过两次遍历链表，第一次遍历更新字符出现频率，第二次遍历根据频率进行排序，确保了高频字符靠前。代码实现了链表的添加、节点交换等操作，适用于需要统计字符频率并排序的场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述

//LOCATE操作
#include "stdlib.h"
#include "stdio.h"

typedef struct Node{
    struct Node *pre;
    char data;
    int freq;
    struct Node *next;
}Node,*NodePtr,List,*ListPtr;//含头节点。


void List_Add(ListPtr L,char s){
    ListPtr p;
    p = (ListPtr)malloc(sizeof(List));
    p->data = s;
    p->freq = 0;

    p->next = L;
    p->pre = L->pre;
    L->pre->next = p;
    L->pre = p;
}
void Node_Change(NodePtr p,NodePtr q){
    NodePtr m;
    q->pre->next =q->next;
    q->next->pre =q->pre;

    p->pre->next = q;
    q->pre =p->pre;
    p->pre = q;
    q->next = p;

}
void List_Locate(ListPtr L,char s){
    ListPtr p,q,m;
    p = L->next;
    while(p != L)
    {
        if(p->data == s)
        {
            (p->freq)++;
        }
        p = p->next;
    }

    //sort
    p = L->next;
    while(p != L)
    {
        q = p->next;
        while(q != L)
        {
            if(p->freq < q->freq)
            {
                m = q->next;
                Node_Change(p,q);
                p = q;
                q = m;
            }
            else
            {
                q = q->next;
            }  
        }
        p = p->next;
    }
}

int main(){
    ListPtr la;
    la = (ListPtr)malloc(sizeof(List));
    la->next = la;
    la->pre = la;
    la->freq = 0;

    int m,n,flag;
    char c;
    scanf("%d%d",&m,&n);
    flag = 0;
    while(1)
    {   
        c = getchar();
        if(c!=' ' && c!='\n' )
        {
            List_Add(la,c);
            flag++;
        }
        if(flag == m)
        break;
    }
    flag =0;
    while(1){
        c = getchar();
        if(c!=' ' && c!='\n' )
        {
            List_Locate(la,c);
            flag++;
        }
        if(flag == n)
        break;
    }

    ListPtr p;
    p = la->next;
    while(p != la)
    {
        printf("%c ",p->data);
        p = p->next;
    }

    return 0;
}

下面是我第二次做的时候写的，这次把freq修改操作和排序放在了一起，即当修改某个freq后，将它与前面节点进行比较，将其查到大于等于这个freq的后面，另外链表的定义也有所改变。

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

typedef struct Node
{
	char data;
	int freq;
	struct Node *pre,*next;
}Node,*PNode;

typedef struct LinkList{
	int num;
	PNode head;
}LinkList,*PLinkList;

void InitList(PLinkList L){
	PNode p,q;
	q = L->head;
	getchar();
	for(int i = 0;i < L->num;i++)
	{
		p = (PNode)malloc(sizeof(Node));
		scanf("%c",&p->data);
		p->freq = 0;
		getchar();

		p->next = q->next;
		q->next->pre = p;
		q->next = p;
		p->pre = q;
		q = p;
	}
}
void Locate(PLinkList L,char c){
	PNode p,q,r;
	p = L->head->next;
	for(int i = 0;i < L->num;i++){
		if(p->data == c){
			p->freq++;
			//修改顺序
			q = p->pre;
			while(1){
				if(q == L->head) break;
				if(q->freq < p->freq)
				{
					q = q->pre;
				}
				else
				{
					break;
				}
			}
			r = p;
			p = p->next;
			//将节点取出
			r->pre->next = p;
			p->pre = r->pre;
			//将节点插入到q后面
			r->next = q->next;
			q->next->pre = r;
			q->next = r;
			r->pre = q;
		}
		else
		{
			p = p->next;
		}
	}
}

void PrintList(PLinkList L){
	PNode p = L->head->next;
	for(int i = 0;i < L->num;i++){
		printf("%c ",p->data);
		p = p->next;
	}
}
int main(){
	PLinkList L;
	L = (PLinkList)malloc(sizeof(LinkList));
	L->head = (PNode)malloc(sizeof(Node));
	L->head->next = L->head;
	L->head->pre = L->head;
	scanf("%d",&L->num);//头节点保存节点数目
	int n;
	scanf("%d",&n);
	InitList(L);
	
	for(int i = 0; i < n;i++)
	{
		char c;
		scanf("%c",&c);
		Locate(L,c);
		getchar();
	}

	PrintList(L);
	return 0;
}