## 对几个常见的线性数据结构做一个简单的分析和自定义的实现
1.顺序表
按照顺序存储方式存储的线性表，在计算机的一组连续的存储单元中，因此在查找的时候由于地址连续性，cpu寻址时是按照顺序往下，这样在寻找时会非常迅速，这就导致了顺序存储方式的查找非常高效。同时，由于地址连续性，在中间删除或者增加一个节点时，会影响到后面节点在物理内存中的地址都要往前或往后移动，因此当插入或删除时效率较低，而且随操作影响的节点的数量越多，效率越低。这里用Java实现一个自定义的顺序表
package baseDataStructure;
import java.util.Scanner;
/**
* 顺序表结构
* 即按照顺序存储方式的线性表类似数组
* 每个节点的长度相同，在物理内存中连续存在，一个整的空间存放顺序表
* 便于查询，增删效率低
*/
public class SequentialList {
static final int MAXLEN = 100; //定义顺序表的最大长度
DataList[] listData = new DataList[MAXLEN+1]; //保存顺序表的结构数组
int ListLen; //顺序表已经存的节点的数量
/**
* 初始化为空表，将位置指向0，这样在写入时如果有数据会直接覆盖，而不用先将数据清空
* @param sequentialList
*/
void init(SequentialList sequentialList){
sequentialList.ListLen=0;
}
/**
* 返回顺序表的节点数量
* @param sequentialList
* @return
*/
int getListLength(SequentialList sequentialList){
return sequentialList.ListLen;
}
/**
* 插入节点
* @param sequentialList 顺序表
* @param n 插入的位置
* @param dataList 节点对象
* @return 1表示成功，0表示失败
*/
int insertSequentialList(SequentialList sequentialList,int n,DataList dataList){
int i;
if (sequentialList.ListLen >= MAXLEN){
System.out.println("顺序表已满，无法插入节点");
return 0;
}else if (n<1||n>sequentialList.ListLen-1){
System.out.println("位置有误:当前指定位置没有存储元素，无法插入");
return 0;
}
for (i = sequentialList.ListLen; i >=n ; i--) {
//将插入位置后面的所有元素下标向后移动一位，空出插入位置节点
sequentialList.listData[i+1] = sequentialList.listData[i];
}
sequentialList.listData[n]=dataList;
sequentialList.ListLen++;
return 1;
}
/**
* 在顺序表末尾加上元素
* @param sequentialList
* @param dataList
* @return 1表示成功，0表示失败
*/
int addSequentialList(SequentialList sequentialList,DataList dataList){
if (sequentialList.ListLen>=MAXLEN){
System.out.println("顺序表已满，无法插入节点");
return 0;
}
sequentialList.listData[++sequentialList.ListLen]=dataList;
return 1;
}
/**
* 删除节点位置元素
* @param sequentialList
* @param n
* @return 1表示成功，0表示失败
*/
int delSequentialList(SequentialList sequentialList,int n){
if (n<1||n>sequentialList.ListLen+1){
System.out.println("位置错误:删除节点的位置没有存有元素，无法删除");
return 0;
}
for (int i = n; i<sequentialList.ListLen ; i++) {
//将所有n位置后面的元素都向前挪动一位，然后删除最后一个
sequentialList.listData[i]=sequentialList.listData[i+1];
}
sequentialList.ListLen--;
return 1;
}
/**
* 通过下标位置查找元素
* @param sequentialList
* @param n
* @return
*/
DataList findSequentialList(SequentialList sequentialList,int n){
if (n<1||n>sequentialList.ListLen+1){
System.out.println("位置错误:查找节点的位置没有存有元素,无法查询");
return null;
}else {
return sequentialList.listData[n];
}
}
/**
* 通过关键词（节点类里定义好的key）查询节点的位置返回下标
* @param sequentialList
* @param key
* @return 成功返回下标位置，失败返回0
*/
int findSequentialListByKey(SequentialList sequentialList,String key){
for (int i = 1; i <=sequentialList.ListLen ; i++) {
//compareTo 相等返回0，小于返回-1，大于返回1
if (sequentialList.listData[i].key.compareTo(key)==0){
return i;
}
}
return 0;
}
/**
* 显示当前顺序表所有节点内容
* @param sequentialList
*/
void showAllSequentialList(SequentialList sequentialList){
for (int i = 1; i <=sequentialList.ListLen ; i++) {
System.out.println("第 "+i+" 个元素节点内容是\n"+sequentialList.listData[i].toString());
}
}
/**
* 使用实例
* @param args
*/
public static void main(String[] args) {
SequentialList sequentialList = new SequentialList(); //定义顺序表
DataList dataList; //定义节点引用的变量类型
String key; //定义查询时的关键词
sequentialList.init(sequentialList); //初始化表
Scanner sc = new Scanner(System.in);
//循环添加节点内容
do {
System.out.println("请输入 关键词 姓名 年龄");
DataList tmpData = new DataList();
tmpData.key = sc.next();
tmpData.name = sc.next();
tmpData.age = sc.nextInt();
if (tmpData.age!=0){
if (sequentialList.addSequentialList(sequentialList,tmpData)==0){
break;
}
}else {
break;
}
}while (true);
System.out.println("显示顺序表中的节点顺序");
sequentialList.showAllSequentialList(sequentialList);
System.out.println("要取出的节点号码为:");
int i = sc.nextInt();
dataList = sequentialList.findSequentialList(sequentialList,i);
if (dataList!=null){
System.out.println("第"+i+"个元素内容是"+dataList.toString());
}
System.out.println("输入关键词");
key = sc.next();
i = sequentialList.findSequentialListByKey(sequentialList,key);
dataList = sequentialList.findSequentialList(sequentialList,i);
if (dataList!=null){
System.out.println("关键词为"+key +"的元素内容是"+dataList.toString());
}
}
}
/**
* 定义节点元素内容类，可以是一个任意的实体类
* 类似数组就是一个int 下标和一个Object value的实体类
*/
class DataList{
String key; //节点关键词
String name;
int age;
@Override
public String toString() {
return "DataList{" +
"key='" + key + '\'' +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}2.链表
链表结构是一种动态存储分配的结构形式，一般链表有两个部分，数据部分和地址部分。数据部分用于存储节点内的数据模型等，地址部分则保存下一个节点的地址。在定义链表时，需要定义一个头引用变量(head)，这个head指向链表的第一个节点，第一个节点的地址部分指向第二个节点，直到最后一个节点的地址部分指向null 则表示链表完成。因此在物理内存中基本上都是非连续存在的，比如一个8G的内存区，第一个节点在3G的位置，第二个在7G的位置，而CPU需要挨个寻址，会导致查询的效率极低。（一般情况下不会出现，因为系统会给每个进程分配一定的空间 32位系统好像是在4G,前2G作为进程私有空间，后2G作为公用空间，同时在堆空间内，因此一般不会相距太远）但是在增删时只影响上一个节点的地址部分，而不用其他的节点内容，因此效率非常高。
package baseDataStructure;
import java.util.Scanner;
/**
* 链表自定义
* 每个节点包括两个部分，数据部分和地址部分，地址部分指向下一个节点的地址
* 如果是双向链表，地址部分还包含指向上一个节点的地址
* 链表不同于顺序表，在物理内存中不连续
* 便于增删而不便于查找
*/
public class LinkList {
LinkListData nodeData = new LinkListData();
LinkList nextNode;
/**
* 在链表末尾添加节点
* @param linkList 被添加的链表对象
* @param data 需要添加的节点对象
* @return 返回添加完成的节点
*/
LinkList addLinkListAtEnd(LinkList linkList,LinkListData data){
//node 表示需要添加的末尾对象
// headTemp用于存储临时赋值变量
LinkList node,headTemp;
node = new LinkList(); //申请保存节点数据的内存空间
if (node==null){
System.out.println("内存申请失败，节点为空");
return null;
}else {
node.nodeData = data; //将需要添加的数据对象赋值给申请的节点
node.nextNode = null; //将引用节点设置为空，表示这是末尾节点
if (linkList==null){ //如果当前链表还没有存储对象
linkList = node ;
return linkList;
}else {
headTemp = linkList; //将当前链表赋值给headTemp
while (headTemp.nextNode!=null){ //查找链表尾节点
headTemp=headTemp.nextNode;
}
headTemp.nextNode = node;
return linkList;
}
}
}
/**
* 在链表头部添加节点
* @param linkList
* @param data
* @return
*/
LinkList addLinkListAtHead(LinkList linkList,LinkListData data){
LinkList node = new LinkList();
if (node==null){
System.out.println("内存申请失败，节点为空");
return null;
}else {
node.nodeData = data;
node.nextNode = linkList;
linkList = node;
return linkList;
}
}
/**
* 通过关键词查询链表
* @param linkList
* @param key
* @return
*/
LinkList findLinkListByKey(LinkList linkList,String key){
LinkList tmpLinkList = linkList; //保存头节点引用
while (tmpLinkList!=null){
if (tmpLinkList.nodeData.key.compareTo(key)==0){
return tmpLinkList;
}else {
tmpLinkList = tmpLinkList.nextNode;
}
}
return null;
}
/**
* 插入节点，找到关键节点并排其后面
* @param linkList
* @param findKey 插入节点需要找到对应位置，链表查找位置的条件,
* @param data
* @return
*/
LinkList insertLinkList(LinkList linkList,String findKey,LinkListData data){
LinkList node,nodeTemp;
node = new LinkList();
if (node==null){
System.out.println("内存申请失败，节点为空");
return null;
}else {
node.nodeData = data;
nodeTemp = findLinkListByKey(linkList,findKey);
if (nodeTemp!=null){
node.nextNode = nodeTemp.nextNode;
nodeTemp.nextNode = node;
}else {
System.out.println("没有找到插入的位置");
}
return linkList;
}
}
/**
* 删除节点
* @param linkList
* @param findKey
* @return 成功返回1 失败返回0
*/
int delLinkList(LinkList linkList,String findKey){
LinkList node=linkList,nodeTemp=linkList;
while (nodeTemp!=null){
/**
* 具体操作如下
* 假如链表为 1——> 2 ——> 3 ——> 4 需要删除3
* node 第一轮为 1——> 2 ——> 3 ——> 4
* nodeTemp 第一轮为 2 ——> 3 ——> 4
* node 第二轮为 2 ——> 3 ——> 4
* nodeTemp 第二轮为 3 ——> 4
* 第三轮时 nodeTemp 的 头节点关键词为3 执行if 操作
* 此时 node.nextNode ==> 3 ,nodeTemp.nextNode ==> 4
* 将 node.nextNode = nodeTemp.nextNode;
*那么得到的 node 的链表全结果为 1 ——> 2 ——> 3 ——> 4
*
*/
if (nodeTemp.nodeData.key.compareTo(findKey)==0){
node.nextNode = nodeTemp.nextNode;
nodeTemp = null; //释放内存
return 1;
}else {
node = nodeTemp;
nodeTemp=nodeTemp.nextNode;
}
}
return 0;
}
/**
* 得到链表长度
* @param linkList
* @return
*/
int getLengthLinkList(LinkList linkList){
LinkList tmpLinkList = linkList;
int l = 0;
while (tmpLinkList!=null){
l++;
tmpLinkList=tmpLinkList.nextNode;
}
return l;
}
/**
* 显示所有节点内容
* @param linkList
*/
void showAllLinkListNodes(LinkList linkList){
int i= 0;
LinkList tmpLinkList = linkList;
LinkListData data;
while (tmpLinkList!=null){
i++;
data = tmpLinkList.nodeData;
System.out.println("第 "+i+" 个节点内容为 "+data.toString());
tmpLinkList = tmpLinkList.nextNode;
}
}
public static void main(String[] args) {
LinkList linkList ;
LinkList headNode = null;
LinkList LINK = new LinkList();
String key;
Scanner sc = new Scanner(System.in);
System.out.println("输入数据，关键词，姓名，年龄");
do {
LinkListData data = new LinkListData();
data.key = sc.next();
if (data.key.equals("0")){
break;
}else {
data.name = sc.next();
data.age = sc.nextInt();
headNode = LINK.addLinkListAtEnd(headNode,data); //向headNode中添加节点
}
}while (true);
//显示
LINK.showAllLinkListNodes(headNode);
System.out.println("删除节点关键词");
key = sc.next();
LINK.delLinkList(headNode,key);
LINK.showAllLinkListNodes(headNode);
System.out.println("查询关键词");
key = sc.next();
linkList = LINK.findLinkListByKey(headNode,key);
if (linkList!=null){
System.out.println(key+" 查询结果为："+linkList.nodeData.toString());
}else {
System.out.println(key+" 无此结果");
}
}
}
class LinkListData{
String key;
String name;
int age;
@Override
public String toString() {
return "LinkListData{" +
"key='" + key + '\'' +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
3.栈
从数据的运算分类上看为栈，先进后出。从数据的逻辑结构看是一种线性结构。这里主要说的是顺序栈，即在物理内存中连续存在。链式栈是链式结构存储在内存中的。栈的先进后出机制即先入栈的必须在其他节点弹出后才能取出，在栈中，只能访问当前栈顶的元素，当弹出后才能访问下一个。一般有两个操作，入栈和出栈。
入栈即将数据保存到栈顶，出栈即修改栈顶的引用使其指向下一个元素。
这里可以想象为一个特殊的数组形式，里面存放的是节点保存的数据类型可以是一个封装好的实体类等。而这个数组在添加时按照一定顺序，下标为0的保存栈底的节点，以此类推，当有n个节点保存后，栈顶的指向为n-1。在访问时，首先只能访问第n-1个，访问后将指向改为n-2，以此类推访问至最后一个节点。
package baseDataStructure;
import java.util.Scanner;
/**
* 自定义顺序栈的实现
* 栈是一个先入后出的线性表
* 一般拥有入栈(push) 出栈(pop)两个操作
*/
public class SequenceStack {
static final int MAXLEN = 50;
SequenceStackData[] data = new SequenceStackData[MAXLEN+1];
int top;
/**
* 栈的初始化
* @return
*/
SequenceStack init(){
SequenceStack stack = new SequenceStack();
if (stack!=null){
stack.top = 0; //申请成功后申请栈顶为0
return stack;
}
return null;
}
/**
* 判断是否为空栈，当栈顶top引用为0时，栈为空
* @param stack
* @return 为空返回true
*/
boolean stackIsEmpty(SequenceStack stack){
return stack.top==0;
}
/**
* 判断栈是否已经满了，当栈顶top达到最大值时，栈满
* @param stack
* @return 满了返回true
*/
boolean stackIsFull(SequenceStack stack){
if (stack.top==MAXLEN){
return true;
}else {
return false;
}
}
/**
* 设置栈为空，将top引用置为0
* @param stack
*/
void stackClear(SequenceStack stack){
stack.top = 0;
}
/**
* 释放栈空间
* @param stack
*/
void stackFree(SequenceStack stack){
if (stack!=null){
stack = null;
}
}
/**
* 入栈操作
* @param stack
* @param data
* @return
*/
int stackPush(SequenceStack stack,SequenceStackData data){
if (stack.top>=MAXLEN){
System.out.println("栈已满，无法入栈");
return 0;
}else {
stack.data[++stack.top]=data; //元素入栈
return 1;
}
}
/**
* 出栈操作
* @param stack
* @return
*/
SequenceStackData stackPop(SequenceStack stack){
if (stack.top==0){
System.out.println("栈内没有元素内容");
return null;
}else {
return stack.data[stack.top--];
}
}
/**
* 读取节点数据
* @param stack
* @return
*/
SequenceStackData getStackData(SequenceStack stack){
if (stack.top==0){
System.out.println("没有数据在栈内");
System.exit(0);
}
return stack.data[stack.top];
}
/**
* 测试实例
* @param args
*/
public static void main(String[] args) {
SequenceStack stack = new SequenceStack();
SequenceStackData data = new SequenceStackData();
stack = stack.init(); //初始化
Scanner sc = new Scanner(System.in);
System.out.println("入栈，输入姓名，年龄");
do {
SequenceStackData tmpData = new SequenceStackData();
tmpData.name = sc.next();
if (tmpData.name.equals("0")){
break;
}else {
tmpData.age = sc.nextInt();
stack.stackPush(stack,tmpData);
}
}while (true);
String temp = "1";
System.out.println("出栈：任意非0键进行出栈操作");
temp = sc.next();
while (!temp.equals("0")){
data = stack.stackPop(stack);
System.out.println(data.toString());
temp = sc.next();
}
System.out.println("释放空间");
stack.stackFree(stack);
}
}
/**
* 简单定义栈内节点数据封装类
*/
class SequenceStackData{
String name;
int age;
@Override
public String toString() {
return "SequenceStackData{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
'}';
}
}4.队列
队列从数据的逻辑结构上讲也是一种线性结构，这里也主要讲顺序队列结构，还有一种链式队列结构。队列是先进先出的规则。一般有两种操作。入队操作，将节点添加到队尾。出队操作：从队头取出节点并删除，使下一个节点成为队头。
package baseDataStructure;
import java.util.Scanner;
/**
* 自定义顺序队列结构
* 先进先出
*
*/
public class SequentialQueue {
static final int QUEUELEN = 15;
QueueData[] data = new QueueData[QUEUELEN];
int head;
int tail; //定义队头和队尾
SequentialQueue queueInit(){
SequentialQueue queue; //申请内存
if ((queue=new SequentialQueue())!=null){
queue.head = 0; //设置队头为0
queue.tail = 0; //设置队尾为0
return queue;
}else {
return null;
}
}
/**
* 判断队列是否为空
* @param queue
* @return 返回0为空
*/
int queueIsEmpty(SequentialQueue queue){
if (queue.head==queue.tail){
return 0;
}else {
return 1;
}
}
/**
* 判断队列是否已满
* @param queue
* @return 返回0为满
*/
int queueIsFull(SequentialQueue queue){
if (queue.tail>=QUEUELEN){
return 0;
}else {
return 1;
}
}
/**
* 清空队列
* @param queue
*/
void queueSetClear(SequentialQueue queue){
queue.head = 0;
queue.tail = 0;
}
/**
* 释放内存
* @param queue
*/
void queueSetFull(SequentialQueue queue){
if (queue!=null){
queue = null;
}
}
/**
* 入队操作
* @param queue
* @param data
* @return 返回1成功 0失败
*/
int queueIn(SequentialQueue queue,QueueData data){
if (queue.tail==QUEUELEN){
System.out.println("队列已满");
return(0);
}else {
queue.data[queue.tail++]=data;
return(1);
}
}
/**
* 出队操作
* @param queue
* @return
*/
QueueData queueOut(SequentialQueue queue){
if (queue.head==queue.tail){
System.out.println("出对操作：队列已空");
System.exit(0);
}else {
return queue.data[queue.head++];
}
return null;
}
/**
* 读取队列数据操作
* @param queue
* @return
*/
QueueData queueGet(SequentialQueue queue){
if (queueIsEmpty(queue)==0){
System.out.println("队列已空");
return null;
}else {
return queue.data[queue.head];
}
}
/**
* 计算队列长度
* @param queue
* @return
*/
int queueLen(SequentialQueue queue){
return (queue.tail-queue.head);
}
/**
* 测试实例
* @param args
*/
public static void main(String[] args) {
SequentialQueue queue = new SequentialQueue();
QueueData data;
Scanner sc = new Scanner(System.in);
queue = queue.queueInit();
System.out.println("进行入队操作:输入姓名，年龄");
do {
QueueData queueData = new QueueData();
queueData.name = sc.next();
queueData.age = sc.nextInt();
if (queueData.name.equals("0")){
break;
}else {
queue.queueIn(queue,queueData);
}
}while (true);
String temp = "1";
System.out.println("出队列操作，输入任何非0键位");
temp = sc.next();
while (!temp.equals("0")){
data = queue.queueOut(queue);
System.out.println("队列内容为 "+data.toString());
temp = sc.next();
}
System.out.println("释放内存");
queue.queueSetFull(queue);
}
}
/**
* 简单队列节点对象数据封装
*/
class QueueData{
String name;
int age;
@Override
public String toString() {
return "QueueData{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
