C++常用数据结构
数据结构
1. 线性表
由n个具有相同性质的数据元素
1.1 顺序表(数组)
定义：用一组地址连续的存储单元依次存储线性表中每个数据元素
特点：逻辑关系相邻的两个元素在物理位置上也相邻
# c++实现
template<typename T>
class sqlist{
public:
sqlist(int maxsize=10):Maxsize(maxsize)
{
elements=new T[maxsize];
length=0;
}
private:
int Maxsize;//最大容量
T *elements;//元素初始地址
int length;//当前有效长度
}
基本操作
# 初始化顺序表
//初始化顺序表，表的长度设置为0
void InitList(SqList *L)
{
L->length=0;
}
# 求顺序表中当前元素的个数
//顺序表的长度
int ListLength(SqList * L)
{
return L->length;
}
# 判断顺序表是否为空
//判断顺序表是否为空
bool ListEmpty(SqList *L)
{
if(L->length==0)
return true;
else
return false;
}
# 向顺序表中插入数据元素
//向顺序表中插入数据元素
bool ListInsert(SqList *L,int pos,int item)
{
int i;
if(L->length==LISTSIZE)
{
printf("顺序列表已满，无法进行插入操作");
return false;
}
if(pos<1||pos>L->length+1)
{
printf("插入位置不合法");
return false;
}
for(i=L->length-1;i>=pos-1;i--)
{
L->items[i+1]=L->items[i];
}
L->items[pos-1]=item;
L->length++;
return true;
}
# 删除顺序表中的元素
bool ListDelete(SqList *L,int pos,int *item)
{
int i;
if(L->length==0)
{
printf("顺序表为空表");
return false;
}
if(pos<1||pos>L->length)
{
printf("删除位置无效");
}
*item=L->items[pos-1];
for(int i=pos-1;i<L->length-1;i++)
{
L->items[i]=L->items[i+1];
}
L->length--;
return true;
}
# 查找制定元素在顺序表中的位置
int Find(SqList L,int item)
{
int pos=0;
if(ListEmpty(&L))
{
printf("顺序表为空表，无法进行查找操作");
return 0;
}
while(pos<L.length&&L.items[pos]!=item)
{
pos++;
}
if(pos<L.length)
return pos+1;
else
return 0;
}
# //获得顺序表中指定位置上的数据元素
int GetElem(SqList *L,int pos,int *item)
{
if(ListEmpty(L))
return 0;
if(pos<1||pos>L->length)
return 0;
*item=L->items[pos-1];
return 1;
}
# //遍历顺序表
void TravereList(SqList *L)
{
int pos =0;
while(pos<L->length)
{
printf("item1: %d",L->items[pos]);
pos++;
}
}
C++版本
#include <iostream>
using namespace std;
class ListNode{
public:
ListNode * next;
int data;
};
class LinkList
{
public:
LinkList()
{
node=new ListNode;
node->next=NULL;
}
~LinkList()
{
delete node;
}
void CreateLinkListBack(int n);
void CreateLinkListHead(int n);
void InsertNode(int position,int elem);
void removeNode(ListNode* p);
ListNode* findNode(int value);
void PrintLinkList();
public:
ListNode *node;
};
//头插
void LinkList::CreateLinkListHead(int n)
{
while(n--)
{
//插入的数据
ListNode* l=new ListNode;
cin>>l->data;
l->next=node->next;
node->next=l;
}
}
//尾插
void LinkList::CreateLinkListBack(int n)
{
ListNode* r=node;
while(n--)
{
ListNode* l=new ListNode;
cin>>l->data;
l->next=NULL;
r->next=l;
r=l;
}
}
//在第i个位置插入元素
void LinkList::InsertNode(int position,int elem)
{
int j;
ListNode* p=node->next;
for(j=1;j<position-1;j++)
{
p=p->next;
if(p==NULL)
break;
}
if(p==NULL &&j<(position-1))
return ;
// while(p)
// {
// j++;
// if(j==position)
// break;
// p=p->next;
// }
ListNode* q=new ListNode;
q->data=elem;
q->next=p->next;
p->next=q;
}
//移除节点
void LinkList::removeNode(ListNode* p)
{
if(p==NULL)
return;
ListNode* temp=node;
while(temp->next!=p)
{
temp=temp->next;
}
temp->next=p->next;
delete p;
}
//寻找某节点
ListNode* LinkList::findNode(int value)
{
ListNode* temp=node->next;
while(temp)
{
if(temp->data==value)
return temp;
temp=temp->next;
}
return NULL;
}
//打印链表
void LinkList::PrintLinkList()
{
ListNode* temp=node->next;
while(temp)
{
cout<<temp->data<<"->";
temp=temp->next;
}
std::cout<<std::endl;
}
int main()
{
LinkList list;
list.CreateLinkListHead(5);
list.PrintLinkList();
list.InsertNode(4,9);
list.PrintLinkList();
ListNode* address=list.findNode(2);
list.removeNode(address);
list.PrintLinkList();
return 0;
}
1.2 链表
定义：用一组任意的存储单元存储线性表中的数据元素
特点：
相比顺序存储结构，链式存储结构中，除了需要存储数据元素信息之外，还需要存储它的后继元素的存储地址(指针)。
单链表结点的物理位置不一定连续，单链表逻辑上通过指针实现连续。
单链表有一个头结点和一个尾结点，并且只有尾结点没有后继结点，其他结点有且仅有一个后继结点。
只要知道了链表的头结点，就可以遍历整个链表。
c++定义
class ListNode{
public:
ListNode * next;
int data;
};
class LinkList
{
public:
LinkList()
{
node=new ListNode;
node->next=NULL;
}
~LinkList()
{
delete node;
}
void CreateLinkListBack(int n);
void CreateLinkListHead(int n);
void InsertNode(int position,int elem);
void removeNode(ListNode* p);
ListNode* findNode(int value);
void PrintLinkList();
public:
ListNode *node;
};
C++版本
#include <iostream>
using namespace std;
class ListNode{
public:
ListNode * next;
int data;
};
class LinkList
{
public:
LinkList()
{
node=new ListNode;
node->next=NULL;
}
~LinkList()
{
delete node;
}
void CreateLinkListBack(int n);
void CreateLinkListHead(int n);
void InsertNode(int position,int elem);
void removeNode(ListNode* p);
ListNode* findNode(int value);
void PrintLinkList();
public:
ListNode *node;
};
//头插
void LinkList::CreateLinkListHead(int n)
{
while(n--)
{
//插入的数据
ListNode* l=new ListNode;
cin>>l->data;
l->next=node->next;
node->next=l;
}
}
//尾插
void LinkList::CreateLinkListBack(int n)
{
ListNode* r=node;
while(n--)
{
ListNode* l=new ListNode;
cin>>l->data;
l->next=NULL;
r->next=l;
r=l;
}
}
//在第i个位置插入元素
void LinkList::InsertNode(int position,int elem)
{
int j;
ListNode* p=node->next;
for(j=1;j<position-1;j++)
{
p=p->next;
if(p==NULL)
break;
}
if(p==NULL &&j<(position-1))
return ;
// while(p)
// {
// j++;
// if(j==position)
// break;
// p=p->next;
// }
ListNode* q=new ListNode;
q->data=elem;
q->next=p->next;
p->next=q;
}
//移除节点
void LinkList::removeNode(ListNode* p)
{
if(p==NULL)
return;
ListNode* temp=node;
while(temp->next!=p)
{
temp=temp->next;
}
temp->next=p->next;
delete p;
}
//寻找某节点
ListNode* LinkList::findNode(int value)
{
ListNode* temp=node->next;
while(temp)
{
if(temp->data==value)
return temp;
temp=temp->next;
}
return NULL;
}
//打印链表
void LinkList::PrintLinkList()
{
ListNode* temp=node->next;
while(temp)
{
cout<<temp->data<<"->";
temp=temp->next;
}
std::cout<<std::endl;
}
int main()
{
LinkList list;
list.CreateLinkListHead(5);
list.PrintLinkList();
list.InsertNode(4,9);
list.PrintLinkList();
ListNode* address=list.findNode(2);
list.removeNode(address);
list.PrintLinkList();
return 0;
}
2. 栈
定义：栈（stack）是一种元素满足后进先出（Last in first out， LIFO）规则的线性表。
特点：
- 栈的本质是一种线性表， 但是具有其特殊的操作要求——元素后进先出。这种要求也决定了栈的操作是在表尾进行
- 栈底（bottom）：栈的表头
- 栈顶（top）：将栈的表尾，所以栈的所有操作都是在栈顶进行的。
- 添加元素，称为入栈（push）；删除元素，称为出栈（pop）
栈可以用顺序存储实现，也可以用链式存储实现，分别成为顺序栈和链栈。但一般使用顺序存储实现，因为栈不允许在栈中间进行插入和删除，需要准寻栈特有的规则。
动态实现
typedef struct SqStack_dynamic{
int* base;//栈底
int* top;//栈顶
}SqStack_dynamic;
静态实现
typedef struct SqStack_static{
int data[Maxsize];
int top;//栈顶
}SqStack_static;
c++实现
class stack_static{
public:
stack_static()
{
MaxSize=10;
top=0;
data= new int[MaxSize];
}
void push(int e);
void pop(int &e);
void GetTop(int &e);
private:
int MaxSize;
int top;
int *data;
};
浙公网安备 33010602011771号