C++博客-lwch-随笔分类-数据结构

堆结构的实现2

lwch — Tue, 22 Feb 2011 09:29:00 GMT

继上篇《简单堆结构的实现》之后修改了下代码,使内存的分配效率更高.
首先将HeapApplyed和HeapUsed包含进一个结构体HEAPATTR,各占1位.

1     struct HEAPATTR
2     {
3         BYTE HeapApplyed : 1;
4         BYTE HeapUsed : 1;
5     }*HeapAttr;

然后添加了一个HeapCurrent变量用于提高检索速度.

1 int HeapCurrent;

相应的构造函数和析构函数修改为.

1     Heap(const int Size = 1024 * 300)
2         : HeapLength(Size),HeapCurrent(0),HeapLeft(Size)
3     {
4         HeapData = new CHAR[HeapLength];
5         HeapAttr = new HEAPATTR[HeapLength];
6         memset(HeapData,0,HeapLength);
7         memset(HeapAttr,0,HeapLength);
8     }
9
10     ~Heap()
11     {
12         delete[] HeapData;
13         delete[] HeapAttr;
14     }

注意:一个HEAPATTR结构占1个字节,实际上使用的只有2位,编译器自动为其补齐6位形成1字节(既然只有TRUE和FALSE没理由要用HeapLength*2字节)
修改GetEmptyAddr算法,使其提升效率.

1     CHAR* GetEmptyAddr(const int Size)
2     {
3         int Left = 0;
4         for(int i=HeapCurrent;i<HeapLength;i++)
5         {
6             if(HeapAttr[i].HeapApplyed && !HeapAttr[i].HeapUsed) Left++;
7             else Left = 0;
8             if(Left == Size) return HeapData + i - Left + 1;
9         }
10         if(HeapCurrent > 0 && HeapCurrent > Size)
11         {
12             Left = 0;
13             for(int i=0;i<HeapCurrent;i++)
14             {
15                 if(HeapAttr[i].HeapApplyed && !HeapAttr[i].HeapUsed) Left++;
16                 else Left = 0;
17                 if(Left == Size) return HeapData + i - Left + 1;
18             }
19         }
20         return 0;
21     }

同时也将GetEmptyLeft修改为.

1     inline int GetEmptyLeft(int Size)
2     {
3         int Left = 0;
4         for(int i=HeapCurrent;i<HeapLength;i++)
5         {
6             if(!HeapAttr[i].HeapApplyed) Left++;
7             else Left = 0;
8             if(Left == Size) return i - Left + 1;
9         }
10         if(HeapCurrent > 0 && HeapCurrent > Size)
11         {
12             Left = 0;
13             for(int i=0;i<HeapCurrent;i++)
14             {
15                 if(!HeapAttr[i].HeapApplyed) Left++;
16                 else Left = 0;
17                 if(Left == Size) return i - Left + 1;
18             }
19         }
20         return 0;
21     }

添加DumpFile函数生成Dump文件.

1     BOOL DumpFile(CHAR* FileName)
2     {
3         FILE* fp = fopen(FileName,"wt+");
4         fwrite(HeapData,HeapLength,sizeof(CHAR),fp);
5         fclose(fp);
6         return TRUE;
7     }

最后给出完整代码

lwch 2011-02-22 17:29 发表评论

简单的堆结构实现

lwch — Tue, 15 Feb 2011 12:59:00 GMT

我们知道对于一个数据堆,有申请内存块,释放内存块等操作.

应此我们给出3个数组,分别为内存堆,标记数组,使用是否数组和一个变量用于表示内存堆内剩余空间数.

1     CHAR HeapData[HEAP_LENGTH];
2     CHAR HeapApplyed[HEAP_LENGTH];
3     CHAR HeapUsed[HEAP_LENGTH];
4
5     int HeapLeft;                            // 剩余Heap大小

初始化时将3个数组全部设为0.

1         memset(HeapData,0,HEAP_LENGTH);
2         memset(HeapApplyed,0,HEAP_LENGTH);
3         memset(HeapUsed,0,HEAP_LENGTH);

然后我们需要一个New操作来申请一块尚未使用的内存块.

1     CHAR* New(const int Size)
2     {
3         if(Size > HeapLeft) throw HEAP_OVERFLOW;
4         int iEmpty = GetEmptyLeft(Size);
5
6         memset(HeapApplyed + iEmpty,1,Size); // 将内存块标记
7
8         HeapLeft -= Size;
9         return HeapData + iEmpty;
10     }

一个Free操作来释放一个内存块.

1     BOOL Free(const int Offset,const int Size)
2     {
3         if(!Apply(Offset,Size)) throw HEAP_NOTAPPLY;
4         memset(HeapApplyed + Offset,0,Size);    // 设置为未标记
5         memset(HeapUsed + Offset,0,Size);        // 标记为未使用
6         HeapLeft += Size;
7         return TRUE;
8     }

一个GetEmptyAddr操作来获得第一个符合指定大小的空闲内存卡块.

1     CHAR* GetEmptyAddr(const int Size)
2     {
3         for(int i=0;i<HEAP_LENGTH;i++)
4             if(HeapApplyed[i] && !HeapUsed[i]) // 已标记并未使用
5             {
6                 BOOL bContinue = FALSE;
7                 for(int j=i;j<Size;j++)
8                     if(!HeapApplyed[j] || HeapUsed[j]) // 未标记或已使用
9                     {
10                         bContinue = TRUE;
11                         break;
12                     }
13                 if(bContinue) continue;
14                 return HeapData + i;
15             }
16         return 0;
17     }

和一个SetData操作来设置数据.

1     BOOL SetData(const int Offset,const Type* Data,const int Size)
2     {
3         if(!Apply(Offset,Size)) throw HEAP_NOTAPPLY;
4         memcpy(HeapData + Offset,Data,Size);    // 拷贝数据
5         memset(HeapUsed + Offset,1,Size);        // 标记为已使用
6         return TRUE;
7     }

最后我们来测试一下这个堆结构.

1     try
2     {
3         Heap<CHAR> heap;
4         heap.New(9000);
5
6         int i = 1000;
7         heap.Free(0,100);
8         printf("EmptyAddr:%X\n",heap.GetEmptyAddr(sizeof(int)));
9
10         int* Addr1 = (int*)heap.GetEmptyAddr(sizeof(int));
11         heap.SetData((CHAR*)Addr1 - *heap,(CHAR*)&i,sizeof(int));
12
13         printf("The Data In Heap:%d\n",*Addr1);
14
15         heap.New(100);
16         printf("EmptyAddr:%X\n",heap.GetEmptyAddr(sizeof(int)));
17
18         CHAR str[] = "aaaaa";
19         CHAR* Addr2 = heap.GetEmptyAddr(strlen(str));
20         heap.SetData(Addr2 - *heap,str,strlen(str));
21
22         printf("The Data In Heap:%s\n",Addr2);
23
24         printf("EmptyAddr:%X\n",heap.GetEmptyAddr(sizeof(int)));
25     }
26     catch(int i)
27     {
28         switch(i)
29         {
30         case HEAP_OVERFLOW:
31             printf("堆溢出\n");
32             break;
33         case HEAP_NOTAPPLY:
34             printf("错误的地址\n");
35             break;
36         }
37     }

测试结果:

1 EmptyAddr:4EFB0
2 The Data In Heap:1000
3 EmptyAddr:4EF4C
4 The Data In Heap:aaaaa
5 EmptyAddr:4EF51

下面给出完整代码

lwch 2011-02-15 20:59 发表评论

简单的Hash表实现

lwch — Tue, 10 Aug 2010 15:37:00 GMT

  1 #include <iostream>
  2
  3 template <typename _Type>
  4 class HashTable
  5 {
  6 public:
  7     HashTable(int Length)
  8     {
  9         Element = new _Type[Length];
10         for(int i=0;i<Length;i++)
11             Element[i] = -1;
12         this->Length = Length;
13         Count = 0;
14     }
15
16     ~HashTable()
17     {
18         delete[] Element;
19     }
20
21     // Hash函数
22     virtual int Hash(_Type Data)
23     {
24         return Data % Length;
25     }
26
27     // 再散列法
28     virtual int ReHash(int Index,int Count)
29     {
30         return (Index + Count) % Length;
31     }
32
33     // 查找某个元素是否在表中
34     virtual bool SerachHash(_Type Data,int& Index)
35     {
36         Index = Hash(Data);
37         int Count = 0;
38         while(Element[Index] != -1 && Element[Index] != Data)
39             Index = ReHash(Index,++Count);
40         return Data == Element[Index] ? true : false;
41     }
42
43     virtual int SerachHash(_Type Data)
44     {
45         int Index = 0;
46         if(SerachHash(Data,Index)) return Index;
47         else return -1;
48     }
49
50     // 插入元素
51     bool InsertHash(_Type Data)
52     {
53         int Index = 0;
54         if(Count < Length && !SerachHash(Data,Index))
55         {
56             Element[Index] = Data;
57             Count++;
58             return true;
59         }
60         return false;
61     }
62
63     // 设置Hash表长度
64     void SetLength(int Length)
65     {
66         delete[] Element;
67         Element = new _Type[Length];
68         for(int i=0;i<Length;i++)
69             Element[i] = -1;
70         this->Length = Length;
71     }
72
73     // 删除某个元素
74     void Remove(_Type Data)
75     {
76         int Index = SerachHash(Data);
77         if(Index != -1)
78         {
79             Element[Index] = -1;
80             Count--;
81         }
82     }
83
84     // 删除所有元素
85     void RemoveAll()
86     {
87         for(int i=0;i<Length;i++)
88             Element[i] = -1;
89         Count = 0;
90     }
91
92     void Print()
93     {
94         for(int i=0;i<Length;i++)
95             printf("%d ",Element[i]);
96         printf("\n");
97     }
98 protected:
99     _Type* Element;        // Hash表
100     int Length;                // Hash表大小
101     int Count;                // Hash表当前大小
102 };
103
104 void main()
105 {
106     HashTable<int> H(10);
107     printf("Hash Length(10) Test:\n");
108     int Array[6] = {49,38,65,97,13,49};
109     for(int i=0;i<6;i++)
110         printf("%d\n",H.InsertHash(Array[i]));
111     H.Print();
112     printf("Find(97):%d\n",H.SerachHash(97));
113     printf("Find(49):%d\n",H.SerachHash(49));
114     H.RemoveAll();
115     H.SetLength(30);
116     printf("Hash Length(30) Test:\n");
117     for(int i=0;i<6;i++)
118         printf("%d\n",H.InsertHash(Array[i]));
119     H.Print();
120     printf("Find(97):%d\n",H.SerachHash(97));
121     printf("Find(49):%d\n",H.SerachHash(49));
122     system("pause");
123 }

运行结果:

由上图可知给定的Hash表长度越长越不容易产生冲突,性能也就越高.

lwch 2010-08-10 23:37 发表评论

数据结构

lwch — Wed, 07 Jul 2010 16:12:00 GMT

《数据结构之线性表》
本文阐述了线性表中的顺序存储结构和链接存储结构，其中主要介绍了单链表和循环双链表结构，线性表乃最基本的数据结构。
《数据结构之栈》
本文阐述了线性表的一种特殊形式栈，其中主要介绍了栈的顺序存储结构和连接存储结构，压栈与出栈操作。

lwch 2010-07-08 00:12 发表评论