链式表的实现

来源：互联网发布：m1216nfh 网络扫描编辑：程序博客网时间：2024/06/06 03:46

最头两天开始实现数据结构到现在，这个代码敲了三个多小时，悲剧啊，都怪当初c++很多东西都没有扎实（本来就没怎么学）；

List类实现了基本的增删改查，拷贝构造函数，重载运算符。在实现重载运算符使其支持对象赋值的过程中，一定要将数据成员完全复制！否则num数据成员就不准确了。

另外实现拷贝构造函数时，也要完全复制，另外当时突然想起来以前看 primer plus时，书上说过，内存中临时创建的对象并不会默认调用构造函数，所以可能导致num，等

数据成员为随机值。

另外我实现set_position_2（）的时候利用保留当前位置的方法定位，一定要注意当我们在添加第一个结点的时候，也要把current指针指向添加的第一个元素，否则以后就没有办法来拿current来遍历定位了。然后当我们删除中间结点时，我们肯定要定位他的前驱结点，那么此时的current指针和current_position是一个确切值然而当我删除第一个结点时，Remove（）实现中并没有定位操作，所以删除的结点在current_position位置之前，那么删除之后，current指针和current_position就不是一个确切值了，我们应该重置，使其再次确切。set_position_1（）函数在实现中并没有遇到问题。

把两个定位操作函数放在protected中是因为，两个方法都要访问数据成员，并返回一个指向Node的指针，为了数据的安全性，我们把这两个定位方法声明为不可见的，并保证他

只能作为构造List其他方法时的可用工具；

const修饰能加的地方还是尽量要加上，确实在编译的时候能爆出很多可能潜在的错误。

以下是实现代码：

List.h:

[cpp] view plain copy print?

/*=============================================================================
#
# Author: liangshu - cbam
#
# QQ : 756029571
#
# School : 哈尔滨理工大学
#
# Last modified: 2015-10-28 14:50
#
# Filename: 链式表的实现 - 副本.cpp
#
# Description:
# The people who are crazy enough to think they can change the world, are the ones who do !
=============================================================================*/
#
using namespace std;
enum Error_code {success, overflow, underflow, Range_error};
template<class Node_entry>
struct Node{
Node_entry Entry;
Node<Node_entry> * next;
Node();
Node(const Node_entry &item, Node<Node_entry> *link = NULL):Entry(item), next(link){}
};
template<class Node_entry>
Node<Node_entry>::Node(){
next = NULL;
}
template<class List_entry>
class List{
public:
List();
List(const List<List_entry> &Copy);
int Size_list()const{
return num;
}
bool Empty_list()const{
return num == 0;
}
void Clear();
Error_code retrieve(int position, List_entry &item)const;
Error_code Remove(int position, List_entry &item);
Error_code Replace(int position, const List_entry &item);
Error_code Insert(int position, const List_entry &item);
void operator = (const List<List_entry> &Copy);
void Print_list()const;
protected:
mutable int current_position;
mutable Node<List_entry> *current;
Node<List_entry>*head;
Node<List_entry>*set_position_1(int postion)const;
Node<List_entry>*set_position_2(int postion)const;
int num;
};
template<class List_entry>
List<List_entry>::List(){
num = current_position = 0;
head = NULL;
current = head;
}
template<class List_entry>
void List<List_entry>::Clear(){
while(!Empty_list()){
Node<List_entry> *old_head = head;
head = head -> next;
num--;
delete old_head;
}
current = NULL;
current_position = 0;
}
template<class List_entry>
List<List_entry>::List(const List<List_entry> &Copy){
Node<List_entry> *new_copy, *old_node = Copy.head;
if(old_node == NULL){
head = NULL;
}
else{
head = new_copy = new Node<List_entry>(old_node -> Entry,old_node -> next);
while(old_node -> next != NULL){
old_node = old_node -> next;
new_copy -> next = new Node<List_entry>(old_node -> Entry,old_node -> next);
new_copy = new_copy -> next;
}
}
num = Copy.num;
current = Copy.current;
current_position = Copy.current_position;
}
template<class List_entry>
Error_code List<List_entry>::retrieve(int position, List_entry &item)const{
if(position < 0 || position > num){
return Range_error;
}
Node<List_entry> *new_node = set_position_2(position);
item = new_node -> Entry;
return success;
}
template<class List_entry>
Error_code List<List_entry>::Remove(int position, List_entry &item){
if(position < 0 || position > num){
return Range_error;
}
Node<List_entry>*previous, *old_node;
if(position > 0){
old_node = previous = set_position_1(position - 1);
old_node = old_node -> next;
item = old_node -> Entry;
previous -> next = previous-> next -> next;
delete old_node ;
}
else{
old_node = head;
head = old_node -> next;
item = old_node -> Entry;
delete old_node;
current = head;
current_position = 0;
}
num--;
return success;
}
template<class List_entry>
Error_code List<List_entry>::Replace(int position, const List_entry &item){
if(position < 0 || position > num){
return Range_error;
}
List_entry x;
Remove(position, x);
Insert(position, item);
return success;
}
template<class List_entry>
void List<List_entry>::operator = (const List<List_entry> &Copy){
Node<List_entry> *new_head, *new_copy, *old_node = Copy.head;
if(old_node == NULL){
head = NULL;
}
else{
new_head = new_copy = new Node<List_entry>(old_node -> Entry,old_node -> next);
while(old_node -> next != NULL){
old_node = old_node -> next;
new_copy -> next = new Node<List_entry>(old_node -> Entry,old_node -> next);
new_copy = new_copy -> next;
}
}
while(!Empty_list()){
Node<List_entry> *old_head = head;
head = head -> next;num--;
delete old_head;
}
current = Copy.current;
current_position = Copy.current_position;
num = Copy.num;
head = new_head;
}
template<class List_entry>
Node<List_entry>* List<List_entry>::set_position_1(int position)const{
Node<List_entry> *q = head;
for(int i = 0; i < position; i++){
q = q -> next;
}
return q;
}
template<class List_entry>
Node<List_entry>* List<List_entry>::set_position_2(int position)const{
if(position < current_position){
current_position = 0;
current = head;
}
for(;current_position != position; current_position++){
current = current -> next;
}
return current;
}
template<class List_entry>
void List<List_entry>:: Print_list()const{
cout<<"| -- ";
Node<List_entry> *old_head = head;
while(old_head != NULL){
cout<<old_head -> Entry<<" -- ";
old_head = old_head -> next;
}
cout<<" |"<<endl;
}
template<class List_entry>
Error_code List<List_entry>::Insert(int position, const List_entry &item){
if(position < 0 || position > num){
return Range_error;
}
Node<List_entry> * new_node , *previous, *following;
if(position > 0){
previous = set_position_1(position - 1);
// previous = current;
following = previous -> next;
}
else{
following = head;
}
new_node = new Node<List_entry>(item, following);
if(new_node == NULL){
return overflow;
}
if(position == 0){
head = new_node;
current = head;
}
else{
previous -> next = new_node;
}
num ++;
return success;
}

Test.cpp:

[cpp] view plain copy print?

#include<iostream>
#include"List.h"
using namespace std;
int main()
{
List<int>list_1, list_2, list_3;
for(int i = 1; i <= 5; i++){
list_1.Insert(i - 1, i);
}
int x;
list_1.Print_list();
cout<<list_1.Size_list()<<endl;
list_1.retrieve(1, x);
cout<<x<<endl;
list_1.Remove(2, x);
cout<<"Remove ="<<x<<endl;
list_1.Print_list();
cout<<list_1.Size_list()<<endl;
list_1.Replace(2, 100);
list_1.Print_list();
list_1.Remove(0, x);
cout<<"Remove2 = "<<x<<endl;
list_1.Print_list();
cout<<list_1.Size_list()<<endl;
list_1.Insert(3,123456);
list_1.Print_list();
cout<<list_1.Size_list()<<endl;
list_1.Clear();
list_1.Print_list();
cout<<list_1.Size_list()<<endl;
for(int i = 1; i <= 9; i++){
list_1.Insert(i - 1, i);
}
list_1.Print_list();
list_2 = list_1;
list_2.Print_list();
cout<<"ci = "<<endl;
list_3 = List<int>(list_2);
list_3.Print_list();
list_3.Remove(3,x);
list_3.Print_list();
list_3.Insert(0,19999);
list_3.Insert(7, 1000009);
list_3.retrieve(9, x);
cout<<"x ="<<x<<endl;
list_3.Print_list();
return 0;
}

0 0