算法与数据结构(10): 线性表(1)——顺序表(数组)

算法与数据结构(10): 线性表(1)——顺序表(数组)_第1张图片

文章目录

  • 1 线性表简介
  • 2 顺序表的基本操作
    • (1) 顺序表——插入, 删除, 清空, 遍历等操作
    • (2) 顺序表——指定元素的前驱 和 后继
  • 3 链表的基本操作
  • 4 链表应用——通讯录
  • 参考资料

注:转载请标明原文出处链接:https://xiongyiming.blog.csdn.net/article/details/100848417


1 线性表简介

线性表(linear list)是最基本、最简单、也是最常用的一种数据结构。
一个线性表是n个具有相同特性的数据元素的有限序列。
线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的(注意,这句话只适用大部分线性表,而不是全部。比如,循环链表逻辑层次上也是一种线性表(存储层次上属于链式存储),但是把最后一个数据元素的尾指针指向了首位结点)。
(以上均来自百度百科)


线性表分为顺序表和链表,如下图所示:

链表有:静态链表,单链表,循环链表 和 双向链表。

算法与数据结构(10): 线性表(1)——顺序表(数组)_第2张图片



2 顺序表的基本操作

(1) 顺序表——插入, 删除, 清空, 遍历等操作


要求:

线性表——顺序表
3 5 7 2 9 1 8
前驱 后继

  1. List(int size);//创建线性表——构造函数
  2. ~List(); //销毁线性表——析构函数
  3. void ClearList();//清空线性表
  4. bool ListEmpty();//判断线性表是否为空
  5. int ListLength(); //获取线性表长度
  6. bool GetElem(int i, int *e); //获取指定元素
  7. int LocateElem(int *e); //寻找第一个满足e的数据元素的位序
  8. bool PriorElem(int *currentElem, int *preElem); //获取指定元素的前驱
  9. bool NextElem(int *currentElem, int *nextElem); //获取指定元素的后继
  10. bool ListInsert(int i, int *e); //在第i个位置插入元素
  11. bool ListDelete( int i, int *e); //删除第i个位置的元素
  12. void ListTraverse(); //遍历线性表

List.h

#pragma once

class List
{
public:
	List(int size);//创建线性表——构造函数
	~List();      //销毁线性表——析构函数
	void ClearList();//清空线性表
	bool ListEmpty();//判断线性表是否为空
	int ListLength(); //获取线性表长度
	bool GetElem(int i, int *e); //获取指定元素
	int LocateElem(int *e); //寻找第一个满足e的数据元素的位序
	bool PriorElem(int *currentElem, int *preElem); //获取指定元素的前驱
	bool NextElem(int *currentElem, int *nextElem); //获取指定元素的后继
	bool ListInsert(int i, int *e); //在第i个位置插入元素
	bool ListDelete( int i, int *e); //删除第i个位置的元素
	void ListTraverse(); //遍历线性表

private:
	int *m_pList;
	int m_iSize;
	int m_iLength;

};

List.cpp

#include
#include"List.h"

using namespace std;

List::List(int size)
{
	m_iSize = size;
	m_pList = new int[m_iSize];
	m_iLength = 0;
}


List::~List()
{
	delete[]m_pList;
	m_pList = NULL;
}

//清空线性表
void List::ClearList()
{
	m_iLength = 0;
}

//判断线性表是否为空
bool List::ListEmpty()
{
	if (m_iLength==0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//获取线性表长度
int List::ListLength()
{
	return m_iLength;
}

//获取指定元素
bool List::GetElem(int i, int *e)
{
	if (i<0 || i>m_iSize)
	{
		return false;
	}
	
	*e = m_pList[i];
	return true;
}


//寻找第一个满足e的数据元素的位序
int List::LocateElem(int *e)
{
	for (int i = 0; i < m_iLength; i++)
	{
		if (m_pList[i] == *e)
		{
			return i;
		}
	}
	return -1;
}


//获取指定元素的前驱
bool List::PriorElem(int *currentElem, int *preElem)
{
	int temp = LocateElem(currentElem);
	if (temp == -1)
	{
		return false;
	}
	else
	{
		if (temp == 0)
		{
			return false;
		}
		else
		{
			*preElem=m_pList[temp - 1];
			return true;
		}
	}

}


//获取指定元素的后继
bool List::NextElem(int *currentElem, int *nextElem)
{
	int temp = LocateElem(currentElem);
	if (temp == -1)
	{
		return false;
	}
	else
	{
		if (temp == m_iLength-1)
		{
			return false;
		}
		else
		{
			*nextElem = m_pList[temp + 1];
			return true;
		}
	}

}

//在第i个位置插入元素
bool List::ListInsert(int i, int *e)
{
	if (i < 0 || i > m_iLength)
	{
		return false;
	}
	
	for (int k = m_iLength-1; k >=i; k--)
	{
		m_pList[k + 1] = m_pList[k];
	}

	m_pList[i] = *e;
	m_iLength++;
	return true;
}

//删除第i个位置的元素
bool List::ListDelete(int i, int *e)
{
	*e = m_pList[i];

	if (i<0||i>=m_iLength)
	{
		return false;
	}

	for (int k = i+	1; k < m_iLength; k++)
	{
		m_pList[k - 1] = m_pList[k];
	}


	m_iLength--;
	return true;

}

//遍历线性表
void List::ListTraverse()
{
	for (int i=0; i < m_iLength; i++)
	{
		cout<<m_pList[i] << endl;
	}
}

main.cpp

#include
#include"List.h"

using namespace std;

/**********************************************************************
线性表——顺序表
	3 5 7 2 9 1 8
	前驱  后继

	List(int size);//创建线性表——构造函数
	~List();      //销毁线性表——析构函数
	void ClearList();//清空线性表
	bool ListEmpty();//判断线性表是否为空
	int ListLength(); //获取线性表长度
	bool GetElem(int i, int *e); //获取指定元素
	int LocateElem(int *e); //寻找第一个满足e的数据元素的位序
	bool PriorElem(int *currentElem, int *preElem); //获取指定元素的前驱
	bool NextElem(int *currentElem, int *nextElem); //获取指定元素的后继
	bool ListInsert(int i, int *e); //在第i个位置插入元素
	bool ListDelete( int i, int *e); //删除第i个位置的元素
	void ListTraverse(); //遍历线性表

**********************************************************************/


int main()
{
	int e1 = 3;
	int e2 = 5;
	int e3 = 7;
	int e4 = 2;
	int e5 = 9;
	int e6 = 1;
	int e7 = 8;

	int temp = 0;
	List *list1 = new List(10);

	//插入元素 3 5 7 2 9 1 8
	list1->ListInsert(0, &e1);
	list1->ListInsert(1, &e2);
	list1->ListInsert(2, &e3);
	list1->ListInsert(3, &e4);
	list1->ListInsert(4, &e5);
	list1->ListInsert(5, &e6);
	list1->ListInsert(6, &e7);

	//遍历
	list1->ListTraverse();

	cout << "--------------------" << endl;


	//删除元素
	list1->ListDelete(0, &temp);//删除第一个元素
	//遍历
	list1->ListTraverse();
	cout << "删除的元素为:" << temp << endl;
	cout << "--------------------" << endl;



	//判断线性表是否为空
	if (!list1->ListEmpty())
	{
		cout << "not empty" << endl;
	}
	cout << "--------------------" << endl;

	//清空线性表
	list1->ClearList();//清空线性表
	//遍历
	list1->ListTraverse();

	//判断线性表是否为空
	if (list1->ListEmpty())
	{
		cout << "empty" << endl;
	}
	cout << "--------------------" << endl;


delete list1;
	cin.get();
	return 0;
}

运行结果

算法与数据结构(10): 线性表(1)——顺序表(数组)_第3张图片



(2) 顺序表——指定元素的前驱 和 后继

main.cpp文件出现改动,其他文件不做改变

main.cpp

#include
#include"List.h"

using namespace std;

/**********************************************************************
线性表——顺序表
	3 5 7 2 9 1 8
	前驱  后继

	List(int size);//创建线性表——构造函数
	~List();      //销毁线性表——析构函数
	void ClearList();//清空线性表
	bool ListEmpty();//判断线性表是否为空
	int ListLength(); //获取线性表长度
	bool GetElem(int i, int *e); //获取指定元素
	int LocateElem(int *e); //寻找第一个满足e的数据元素的位序
	bool PriorElem(int *currentElem, int *preElem); //获取指定元素的前驱
	bool NextElem(int *currentElem, int *nextElem); //获取指定元素的后继
	bool ListInsert(int i, int *e); //在第i个位置插入元素
	bool ListDelete( int i, int *e); //删除第i个位置的元素
	void ListTraverse(); //遍历线性表

**********************************************************************/


int main()
{
	int e1 = 3;
	int e2 = 5;
	int e3 = 7;
	int e4 = 2;
	int e5 = 9;
	int e6 = 1;
	int e7 = 8;

	int temp = 0;
	List *list1 = new List(10);

	//插入元素 3 5 7 2 9 1 8
	list1->ListInsert(0, &e1);
	list1->ListInsert(1, &e2);
	list1->ListInsert(2, &e3);
	list1->ListInsert(3, &e4);
	list1->ListInsert(4, &e5);
	list1->ListInsert(5, &e6);
	list1->ListInsert(6, &e7);

	//遍历
	list1->ListTraverse();

	cout << "--------------------" << endl;


	//获取指定元素的值
	list1->GetElem(0, &temp);
	cout << "temp的值: " << temp << endl;

	//获取指定元素位置
	cout << "temp的位置: " << list1->LocateElem(&temp) << endl;
	cout << "--------------------" << endl;

	//指定元素的前驱
	list1->PriorElem(&e4, &temp);
	cout << "e4的前驱值: " << temp << endl;

	//指定元素的后继
	list1->NextElem(&e4, &temp);
	cout << "e4的后继值: " << temp << endl;


	delete list1;

	cin.get();
	return 0;
}

运行结果

算法与数据结构(10): 线性表(1)——顺序表(数组)_第4张图片



3 链表的基本操作

4 链表应用——通讯录




参考资料

[1] 数据结构探险之线性表篇

你可能感兴趣的:(算法与数据结构专栏)