双向循环链表运用（2）

问题描述：一双向循环链表，每个结点除了prior,data和next三个域外，还增设了一个访问频度域freq。链表启用前，freq为0，每对链表进行一次LOCATE(L，x)的操作后，该结点的freq加1，同时调整链表中结点之间的次序，使得被频繁访问的结点总是靠近表头结点

。编写符合上述要求的LOCATE算法。

问题分析：

重新把问题打在上面，更好地理解了一遍，也提高了自己的概括能力，挺好！

 

看吧，当自己写时，总感觉有那么些别扭，可是看着别人的就豁然开朗，自己还没想到豁然开朗，思维的锻炼还不够。。。

好吧，既然你已经看懂了答案了，很清晰的逻辑。但是我不想让自己现在就根据刚看的，然后写出来，看看明天还记不记得，今天暂且到这里吧。【2013-04-22】

 实现代码：(暂存)

 

#include<stdio.h>
 #include<stdlib.h>
 typedef  struct DuLNode{
  int  data;
  int freq;
  struct  DuLNode  *prior;//前驱结点
  struct  DuLNode  *next;//后继结点
 }DuLNode,*DuLinkList;
 void add(DuLinkList &L,int value)
 {
     if(L==NULL)
     {
        L=(DuLinkList)malloc(sizeof(DuLNode));
        L->data=value;
        L->next=L;
        L->prior=L;
        L->freq=0;
     }
     else
     {
        DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));
        temp->data=value;
        temp->freq=0;
        L->prior->next=temp;
        temp->prior=L->prior;
        temp->next=L;
        L->prior=temp;//这下应该明白为什么是在这里插入。      
     }
 }
 void print(DuLinkList L)
 {
     if(L==NULL)
         printf("链表为空！");
     else
         if(L->prior==L)//只有一个结点的情况
             printf("%d",L->data);
         else//循环链表中多个结点的情况
         {
             DuLinkList cur=L;
             printf("%d",cur->data);
             while((cur=cur->next)!=L)
                 printf("%d",cur->data);
         }
 }
 void ListLocate_Dul(DuLinkList  &L, int e)
 {
      DuLinkList p,q;
      p=L;
      while(p->data!=e)
      {
        p=p->next;
        if((p==L)&&(p->data!=e)) //有待改进
        {
           printf("没有找到你要找的数：%d\n",e);
           return;
          //exit(0);//这个用的挺危险的。。。会结束程序，而不是此函数的返回值
        }
      }
      p->freq++;//p指向找到的数据
      p->prior->next=p->next;//将此结点抽离出来
      p->next->prior=p->prior;
      //插入到合适的位置
      q =L;
      while(true) 
      {
          if(p->freq>=q->freq)
                break;
          else
             q=q->next; 
      }
       // if(q==L)
       //{
       //     p->next=q->next;
       //       q->next=p;
       //       p->prior=q->prior;
       //        q->prior=p;  
       // }
       // else
       //{
              q->prior->next=p;
              p->prior=q->prior;
              p->next=q;
              q->prior=p;//这还是插入之前呢。
       //}
 }
 int main()
 {
    DuLinkList L=NULL,pt;
    int temp;
    printf("创建循环链表：\n");
    while(scanf("%d",&temp)&&(temp!=-1))
    {
      add(L,temp);
    }
    printf("输入你要访问的数：\n");
    while(true){
    scanf("%d",&temp);
    if(temp==-1)
        break;
    else
       ListLocate_Dul(L,temp);
    }
    printf("访问后，链表数据调整为：\n");
    pt=L;
    int i=0;
   // while(i<3)
    //{
       printf("数据元素为：%d,频率为：%d\n",pt->data,pt->freq);
       pt=pt->next;
    
    //}
 }

这个代码遇到的问题，访问第一个结点的处理方法跟其他位置的结点不同，为什么当p为第一个结点时，L没有抽离出第一个结点，但是其他位置却可以，按照分析，应该可以分离出第一个结点，以至于后面是第一个结点时要特殊处理，但是我却认为可以不用，这个地方就出现问题。。。。         p->freq++;//p指向找到的数据
      p->prior->next=p->next;//将此结点抽离出来
      p->next->prior=p->prior;
      //插入到合适的位置

 用C#实现的链表的代码，没调整过来。。。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace SqList
{
    class Program
    {
        #region 链表结点的数据结构
        public class Node
        {
            public int data;//结点数据域
            public int freq;//访问频率
            public Node next;
        }
        #endregion
        public class SqL
        {
            #region 将节点添加到链表的末尾
            public Node ChainListAddEnd(Node  head, int data)
            {
                Node node = new Node();//申请一个新的结点
                node.data = data;
                node.freq = 0;
                node.next = null;
                //头为空，说明是一个空链表
                if (head == null)
                {
                    head = node;
                    return head;
                }
                //获取当前链表的最后一个结点
                ChainListGetLast(head).next = node;
                return head;
            }
            #endregion

            #region 得到当前链表的最后一个结点
            public Node ChainListGetLast(Node head)
            {
                if (head.next == null)
                    return head;
                return ChainListGetLast(head.next);//用递归返回当前链表中的最后一个结点
            }
            #endregion

            #region 将节点添加到链表的开头
            public  Node ChainListAddFirst(Node head, int data)
            {
                Node node = new Node();
                node.data = data;
                node.freq = 0;
                node.next = head;
                head = node;
                return head;
            }
            #endregion

            #region 将节点插入到指定位置
            public Node ChainListInsert(Node head, int key, int data)
            {
                if (head == null)
                    return null;
                if (head.data==key)
                {
                    Node node = new Node();
                    node.data = data;
                    node.freq = 0;
                    node.next = head.next;
                    head.next = node;
                }
                ChainListInsert(head.next, key, data);
                return head;
            }
            #endregion

            #region 删除结点
            public Node ChainListDelete(Node head, int key)
            {
                if (head == null)
                    return null;
                //这里针对只有一个结点的解决方案
                if (head.data==key)
                {
                    if (head.next != null)
                        head = head.next;
                    else
                        return head = null;
                }
                else
                {
                    //判断一下此节点是否是要删除的结点的前一结点
                    while (head.next != null &&head.next.data==key)
                    {
                        head.next = head.next.next;
                    }//删除的方法有点奇怪
                }
                ChainListDelete(head.next, key);//又用到了递归。。。
                return head;
            }
            #endregion

            #region 通过关键字查找指定的结点
            public Node ChainListFindByKey(Node head, int key)
            {
                if (head == null)
                    return null;
                if (head.data == key)
                {
                    head.freq++;
                    return head;
                }
                return ChainListFindByKey(head.next, key);
            }
            #endregion

            #region 获取链表的长度
            public int ChanListLength(Node head)
            {
                int count = 0;
                while (head != null)
                {
                    count++;
                    head = head.next;
                }
                return count;
            }
            #endregion
        }

        static void Main(string[] args)
        {
            SqL mysql = new SqL();
            Node mynode = null;
           mynode=mysql.ChainListAddFirst(mynode, 1);
           mynode=mysql.ChainListAddEnd(mynode, 2);
           mynode=mysql.ChainListAddEnd(mynode, 3);
           mynode=mysql.ChainListAddEnd(mynode, 4);
           Display(mynode);
           mynode = mysql.ChainListInsert(mynode, 3, 5);
           Console.WriteLine("增加结点后，显示的值为：");
           Display(mynode);
           mynode = mysql.ChainListDelete(mynode, 2);
           Console.WriteLine("删除结点2后，显示的值为：");
           Display(mynode);
           mynode = mysql.ChainListFindByKey(mynode,1);
          // mynode = mysql.ChainListDelete(mynode, 1);
           Console.WriteLine("查找结点1后，显示的值为：");
           Display(mynode);
           Console.ReadKey();
        }
        public static void Display(Node head)
        {
           Console.WriteLine("****链表数据如下*****"); 
            var tempNode=head;
            while(tempNode!=null)
            {
                Console.WriteLine("数据值为："+tempNode.data+"频率为："+tempNode.freq);
                tempNode=tempNode.next;
            }
        }
       }
 }

问题描述：

带头结点的双向循环链表表示的线性表L=(a1,a2,...,an). 写一时间复杂度为O(n)的算法，将L改造为L=(a1,a3,....,an,.....a4,a2);

问题分析：

 傻了，按照刚才那道题的分析虽然有点眉目，可是做不下去了，思路断了。我的想法就是给这个链表两个指针p,q. 然后再遍历线性表L，遍历的同时给它一整形变量 COUNT,判断是奇数还是偶数，当是奇数是将这个值赋值给p;然后下一个奇数再赋值给p是怎么赋值的呢？是不是指针p往后移，(对哦，做完后面的题，思路是相近的)然后赋值就行？同样的办法得到q，最后再将q的表头插入到p的表尾，整合成循环链表。(或许这些是靠经验？没做过的题，自己有些想法，但是不知道具体怎么做，但愿自己在这些经验中多多吸取精华，思路是最重要的，以后自己不可能总是碰到自己以前做过的题，你不能下次碰到类似的题又不会了，举一反三啊)

呀呀，看了答案后，恍然大悟呀，作者真是聪明。参考算法：

 代码实现：

 

#include<stdio.h>
#include<stdlib.h>
typedef  struct DuLNode{
 int  data;
 int freq;
 struct  DuLNode  *prior;//前驱结点
 struct  DuLNode  *next;//后继结点
}DuLNode,*DuLinkList;

void add(DuLinkList &L,int value)
{
    if(L==NULL)
    {
       L=(DuLinkList)malloc(sizeof(DuLNode));
       L->data=value;
       L->next=L;
       L->prior=L;
       L->freq=0;
    }
    else
    {
       DuLinkList temp=(DuLinkList)malloc(sizeof(DuLNode));
       temp->data=value;
       temp->freq=0;
       L->prior->next=temp;
       temp->prior=L->prior;
       temp->next=L;
       L->prior=temp;//这下应该明白为什么是在这里插入。      
    }
}
void print(DuLinkList L)
{
    if(L==NULL)
        printf("链表为空！");
    else
        if(L->prior==L)//只有一个结点的情况
            printf("%d",L->data);
        else//循环链表中多个结点的情况
        {
            DuLinkList cur=L;
            printf("%d",cur->data);
            while((cur=cur->next)!=L)
                printf("%d",cur->data);
        }
}
void ListChange_Dul(DuLinkList &L)
{
  int i=1;
  DuLinkList p,q,r;
  p=L;
  r=L->prior;
  while(p!=r)
  {
     if(i%2==0)
     {
         q=p;
         p=p->next;
         //将此节点分离出来
         q->prior->next=q->next;
         q->next->prior=q->prior;
         //将此节点插到头结点的左面
         q->prior=r->next->prior;
         r->next->prior=q;
         q->next=r->next;
         r->next=q;

         
     }
     else
         p=p->next;
     i++;
  }
}
int main()
{
   DuLinkList L=NULL,pt;
   int temp;
   printf("创建循环链表：\n");
   while(scanf("%d",&temp)&&(temp!=-1))
   {
     add(L,temp);
   }
   ListChange_Dul(L);
   print(L);//现在能访问了
}