复习——线性表

最新推荐文章于 2023-07-20 15:02:33 发布
最新推荐文章于 2023-07-20 15:02:33 发布
阅读量519 收藏 1
点赞数
分类专栏： 数据结构期末复习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Phenixfate/article/details/42317781
版权

快要考试了，所以准备这几天把数据结构都过一遍，也就是对那些基本算法进行一次温习吧，加油！！！

——————————————————————————————————————————————


首先先从线性表开始，线性表有2种存储方式，顺序存储和链式存储。


顺序存储：

l 顺序存储方法： 用 一组地址连续 的存储单元依次存储线性表的元素，可通过 数组 来实现。

代码：

<pre name="code" class="cpp">#define MAXSIZE 100
#define OK 1
#define ERROR -1
#include <iostream>
#include<stdio.h>
using namespace std;

typedef int ElemType;
typedef struct
{
	ElemType data[MAXSIZE];
	int lenbgth;
}SqList;

//初始化
void InitList(SqList &L)
{
	L.lenbgth = 0;
}

//奖励一个顺序存储的线性表
void CreatSqlist(SqList &L, int n)
{

	for (int i = 0; i<n; i++)
		cin >> L.data[i];
	L.lenbgth = n;
}

//输出顺序表
void Output(SqList L)
{

	for (int i = 0; i<L.lenbgth; i++)
		cout << L.data[i] << " ";
}

//判断是否为空
bool IsEmpty(SqList L)
{
	if (L.lenbgth = 0)
		return true;
	else
		return false;
}

//取表中第i个元素
int GetElem(SqList L, int i)
{
	if (i<0 && i >= L.lenbgth)
		return ERROR;
	else
		return L.data[i - 1];
}

//定位，返回L中第一个与x相等的数据元素位置
int LocateElem(SqList L, ElemType x)
{
	int k = 0;
	while (k<L.lenbgth && L.data[k] != x)
	{
		k++;
	}
	if (k<L.lenbgth)
		return k;
	else
		return ERROR;
}

//在第i个元素之前插入元素x
int Insert(SqList &L, ElemType x, int i)
{
	int k = 0;
	if (k<0 || i>L.lenbgth || L.lenbgth == MAXSIZE)
		return ERROR;
	else
	{
		for (k = L.lenbgth; k >= i; k--)
			L.data[k] = L.data[k - 1];
		L.data[i] = x;
		L.lenbgth += 1;
	}
	return OK;
}

//删除第i个数据元素
int Delete(SqList &L, int i)
{
	int k;
	if (i<0 || i >= L.lenbgth)
		return ERROR;
	else
	{
		for (k = i; k<L.lenbgth; k++)
			L.data[k] = L.data[k + 1];
		L.lenbgth--;
	}
	return OK;
}

//清空线性表
void Clear(SqList &L)
{
	InitList(L);
}

//合并有序表la和lb到表lc
void MergeList(SqList la, SqList lb, SqList &lc)
{
	int i = 0, j = 0, k = 0;
	while (i<la.lenbgth && j<lb.lenbgth)
	{
		if (la.data[i]<lb.data[j])
			lc.data[k++] = la.data[i++];
		else
			if (la.data[i]>lb.data[j])
				lc.data[k++] = lb.data[j++];
			else
			{
				lc.data[k++] = lb.data[j++];
				i++;
			}
	}
	while (i<la.lenbgth)
	{
		lc.data[k++] = lb.data[i++];
	}
	while (j<lb.lenbgth)
	{
		lc.data[k++] = la.data[j++];
	}
	lc.lenbgth = k;
}

void output()
{
	int i;
	for (i = 0; i<10; i++)
		cout << " ";
	for (i = 0; i<32; i++)
		cout << '*';
	cout << endl;
}

void mainpp()
{
	int i;
	output();
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*    ";
	cout << "1.建立一个顺序表";
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*" << endl;
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*    ";
	cout << "2.输出一个顺序表";
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*" << endl;
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*    ";
	cout << "3.在顺序表中查找";
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*" << endl;
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*    ";
	cout << "4.向顺序表中插入一个元素";
	for (i = 0; i<2; i++)
		cout << " ";
	cout << "*" << endl;
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*    ";
	cout << "5.删除顺序表中的一个元素";
	for (i = 0; i<2; i++)
		cout << " ";
	cout << "*" << endl;
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*    ";
	cout << "6.从顺序表中取出一个元素";
	for (i = 0; i<2; i++)
		cout << " ";
	cout << "*" << endl;
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*    ";
	cout << "7.将两个顺序表合并";
	for (i = 0; i<8; i++)
		cout << " ";
	cout << "*" << endl;
	for (i = 0; i<10; i++)
		cout << " ";
	cout << "*    ";
	cout << "0.退            出";
	for (i = 0; i<8; i++)
		cout << " ";
	cout << "*" << endl;
	output();
}
int main()
{
	int n, i, k = 1, m, x;
	SqList l, la, lc;
	mainpp();
	while (k)
	{
		cout << "请选择0--7：";
		cin >> m;
		getchar();
		switch (m)
		{
		case 0:return 0;
		case 1:
		{
			cout << "输入元素值，构建顺序表：\n";
			cout << "请输入元素的个数：";
			cin >> n;
			cout << "请输入元素的值： ";
			CreatSqlist(l, n);
			Output(l);
			break;
		}
		case 2:
		{
			Output(l);
			cout << endl;
			break;
		}
		case 3:
		{
			cout << "请输入要查找的元素值： ";
			cin >> x;
			k = LocateElem(l, x);
			cout << "要输入的元素的定位:\n" << k << endl;
			break;
		}
		case 4:
		{
			cout << "输入要插入元素的位置和值： ";
			cin >> i;
			cin >> x;
			Insert(l, x, i);
			Output(l);
			cout << endl;
			break;
		}
		case 5:
		{
			cout << "输入要删除位置的位置： ";
			cin >> i;
			Delete(l, i);
			Output(l);
			break;
		}
		case 6:
		{
			cout << "请输入要取出元素的序号： ";
			cin >> i;
			k = GetElem(l, i);
			cout << "取出第" << i << "个元素为: " << k << endl;
			break;
		}
		case 7:
		{
			InitList(la);
			cout << "输入第二个顺序表元素的个数： ";
			cin >> m;
			CreatSqlist(la, m);
			Output(la);
			MergeList(l, la, lc);
			cout << "输出合并后的顺序表中德元素：\n";
			Output(lc);
			break;
		}
		default:
			return 0;
		}
		cout << "继续运行Y(1)/N(0): ";
		cin >> k;
		if (!k)
			return 0;
	}
}


 

 

 


 
 

链式存储：结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻 
 

实现代码：
 
 

 

//这一次补上链表的注释，代码是空闲的时候敲出来的，如果有错，希望帮忙纠正
//部分给出了详细说明，这里只选取了基本操作，因为更复杂的链表操作太繁琐，这里就不写了
//如果有什么不懂的地方，可以随时询问
#include <iostream>
using namespace std;
typedef int Elemtype;

struct Node
{
	Elemtype data;
	Node *prior;
	Node *next;
};

void Init(Node *L)  //主函数里面定义Node型指针变量plist，储存单链表的头指针
{
	//Node *L;
	//	L=new Node;
	//	*L=NULL；
	L = NULL;
	cout << "初始化成功!\n";
}
//这里有两种方式表达，
//1.初始化函数形参要给二级指针，相应的主函数里面实参则是对头指针的引用
//2.初始化函数形参直接给头指针，主函数里的实参就是头指针
void Clear_List(Node *head)  //清空函数
{
	Node *flag;
	if (head == NULL)
	{
		cout << "链表为空!\n";
		return;
	}
	while (head->next != NULL)
	{
		flag = head->next;
		delete(head);
		head = flag;
	}
	cout << "链表已经清空!\n";
}
//加一个标记，移动头指针后赋值flag保存下一个位置，然后删除当前节点

Node *Creat_list(Node *head)  //赋值函数
{
	//int n=0;
	Node *p1, *p2;
	p1 = new Node;
	p2 = new Node;
	//head=NULL;
	cout << "请输入链表元素(10个元素，便于测试)，以0结束输入：" << endl;
	cin >> p1->data;       //先输入一个数据
	p1->next = NULL;
	head = p1;
	while (p1->data != 0)   //这个是控制输出的
	{
		//n=n+1;
		//if(n==1)
		//if(head==NULL)   当头指针为NULL的时候，也就是第一次插入数据的时候，
		// 使head=p1；

		//else
		p2->next = p1;//后面的输入全部执行这里
		p2 = p1;        //p2暂时保存p1
		p1 = new Node;  //p1更新
		cin >> p1->data;
		p1->next = NULL;
	}
	//cout<<head->data;
	return head;
}
//后来想了想p2还是不能删，如果删了虽然不会报错，但是显示程序停止，所以我觉得p2的作用应该是保存之前的节点
//可以想一下，如果删除p2，那么程序首先读入p1，在判断p1数据域非0后，要用p2保存下p1节点，然后p1在向后更新，如此反复。。。

//读入链表元素，在while循环里面每次将当前指针保存下来，然后不断向后更新


void List_length(Node *head)
{
	int i = 0;
	while (head != NULL)
	{
		i++;
		head = head->next;
	}
	cout << "链表长度length: " << i << endl;
}

void Out_list(Node *head)
{
	//	cout<<head->data;
	if (head == NULL)
		cout << "链表为空!\n";
	else
	{
		while (head != NULL)
		{
			cout << head->data << " ";
			head = head->next;
		}
		cout << endl;
	}
}

Elemtype Get_elem(int index, Node *head) //给定下标，求节点元素
{
	int j = 0;
	//Node *p;
	while (head != NULL)
	{
		j++;
		if (j == index)
			break;
		head = head->next;
	}
	if (j<index)
	{
		cout << "选取的范围超出链表长度!\n";
		return 0;
	}
	return head->data;
}
//给定的下标index，只需遍历链表，当节点数符合要求时即可


int locate_elem(Node *head, Elemtype _First) //给定节点元素，求第一个下标（也可以扩展求多个点的下标或者地址）
{
	int n = 1;
	while (head != NULL)
	{
		if (head->data == _First)
			return n;
		else
			n++;
		head = head->next;
	}
	cout << "单链表里不存在 " << _First << " 这个元素" << "!\n";
	return 0;
}
//同理，遍历查找出给定元素，然后直接返回下标

bool Insert_elem(Node *head, Elemtype insert_elem, int index)
{
	Node *p, *q;
	if (index<1)
	{
		cout << "输入下标有误!\n";
		return false;
	}
	int i = 1;
	while (head != NULL)
	{
		i++;
		head = head->next;
		if (i == index - 1)
		{
			p = q = new Node;
			q = head;
			//head=head->next;
			(*p).data = insert_elem;
			//这里调试了好久。。。开始我是想定义一个节点和一个指针的，输出的时候会报错
			//最后还是觉得都定义指针吧，p那里不加括号的话也会报错
			(*p).next = head->next;
			q->next = p;
			//p->next=head->next;
			//p->data=insert_elem;
			return true;
		}
	}
	return false;
}
//插入步骤稍微多些，要另外定义两个指针，思路就是遍历到给定下标的前一个下标，同时指针q记录下位置
//而另外一个指针p储存节点数据，并且使它指向头指针下一个点的地址,最后使q指向p即可



bool delete_Node(Node *head, int index)
{
	int i = 1;
	if (index<1)
	{
		cout << "输入下标值有误!\n";
		return false;
	}
	while (head != NULL)
	{
		i++;
		head = head->next;
		if (i == index - 1)
		{
			Node *p;
			p = new Node;
			p = head;
			head = head->next;
			p->next = head->next;
			return true;
		}
	}
	return false;
}
//操作类似于插入，不多说

bool Change_Node_Elem(Node *head, int index, Elemtype Example3)
{
	int i = 1;
	if (head == NULL || index<1)
	{
		cout << "输入错误或链表为空!\n";
		return false;
	}
	while (head != NULL)
	{
		i++;
		head = head->next;
		if (i == index)
		{
			head->data = Example3;
			return true;
		}
	}
	return false;
}
//也是遍历链表找到给定位置，然后更新数据

int main()
{
	Node *plist=NULL;
	//Node *plist;
	Elemtype Example1 = 5, Example2 = 7, Example3 = 9;
	cout << "创建一个单链表(plist)：\n";
	Init(plist);     //初始化
	plist = Creat_list(plist);  //创建单链表，给单链表赋值，返回头指针

	cout << "打印原始链表：\n";
	Out_list(plist);
	cout << endl;

	cout << "链表第三个节点的元素值为： " << Get_elem(3, plist) << endl;
	cout << endl;
	//调用Get_elem函数，返回链表第三个节点内元素值

	//cout<<"输出链表长度:\n";
	List_length(plist);
	cout << endl;
	if (locate_elem(plist, Example1))
		cout << "链表plist第一次出现 " << Example1 << " 值的下标：" << locate_elem(plist, Example1) << endl;
	cout << endl;
	//调用locate_elem函数，返回链表内第一个出现Example1元素的节点数


	cout << "将元素 " << Example2 << " 插入链表第四个节点上：" << endl;
	if (Insert_elem(plist, Example2, 4))
	{
		cout << "Insert is OK!\n";
		cout << "改变后的链表为：" << endl;
		Out_list(plist);
	}
	else
		cout << "Insert is not OK!\n";
	cout << endl;

	cout << "将链表第七个节点删除：" << endl;
	if (delete_Node(plist, 7))
	{
		cout << "Delete is OK!\n";
		cout << "改变后的链表为：" << endl;
		Out_list(plist);
	}
	else
		cout << "Delete is not OK!\n";

	cout << endl;


	cout << "将链表plist中第三个节点的元素换成 " << Example3 << endl;
	if (Change_Node_Elem(plist, 3, Example3))
	{
		cout << "改变后的链表为：\n";
		Out_list(plist);
	}
	else
		cout << "数值改变失败!\n";
	cout << endl;

	cout << "执行清空函数：" << endl;
	Clear_List(plist);
	return 0;
}
 

 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  Phenixfate
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
期末复习——线性表的概念及顺序存储

				
			

			

				

					ChanCherry的博客
				

				

					06-09
					
					847
					
				

			

		

		

			
				
之前学的时候没太在意，现在期末复习的时候还是做一下笔记吧，不然内心有点不安φ(．．)

线性表的概念
定义：线性表是由n(n≥0)个类型相同的数据元素a1,a2,…,an组成的有限序列，记作（a1,a2,…,an）。
数据元素之间是一对一的关系，即每个数据元素最多有一个直接前驱和一个直接后驱。
特点：


同一性：线性表由同类数据元素组成，每一个ai必须属于同一数据对象。


有穷性：线性表由有限个数据元素组成，表长度就是表中数据元素的个数。


有序性：线性表中相邻元素之间存在着序偶关系<ai,a.

			
		

	



                

              
                



	

		

			

				
					
考研数据结构复习——线性表(顺序结构)

				
			

			

				

					lxfHaHaHa的博客
				

				

					09-21
					
					533
					
				

			

		

		

			
				
线性表（顺序结构）
/**
***@Title   ：考研数据结构复习
***@Subject ：线性表（顺序结构）
***@Author  ：lxfhahaha
***@language： C语言
***@Time    ： 2018/9/21 19：09
*****/
#include &amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;gt;
#include &amp;amp;amp;amp

			
		

	



                


  
              

                


	

		

			

				
					
数据结构-线性表详解（类C语言版）

				
			

			

				

					秃了也弱了
				

				

					03-31
					
					2116
					
				

			

		

		

			
				
线性表的定义和特点

线性表是具有相同特性的数据元素的一个有限序列。




























			
		

	





	

		

			

				
					
链表

				
			

			

				

					打烂碗的博客
				

				

					11-23
					
					294
					
				

			

		

		

			
				
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多...

			
		

	



		

			
		



	

		

			

				
					
线性表的链式存储结构-----链表

				
			

			

				

					weixin_30872157的博客
				

				

					06-13
					
					115
					
				

			

		

		

			
				
链表：实现存储空间的动态管理的链式的方式；
单向链表的类型：
typedef struct Lnode
{
 ElemType data;	struct Lnode *next;
}LinkList;
销毁单链表
void Destroylist(LinkList *&L){
	LinkList *p=L,*q=p->next;	while (q!=NULL)	{	...

			
		

	





	

		

			

				
					
线性表

				
			

			

				

					王帆的专栏
				

				

					02-10
					
					1502
					
				

			

		

		

			
				
寒假还有将近一个星期啦，前期学习了腩哥的新闻发布系统，很有感触，发现原来代码可以整理得这么规范，以前自己做的东西完全就是想到什么就做什么，完全没有一个整体的思路，学习了之后对开发的整个流程以及代码的规范有了质的提升，真的学得很过瘾，，，以后说不定还会在网页这方面继续深造的！！！多的不想，现在离考研将近一年的时间就是一心一意地好好准备!
          数据结构的整体框架如下:

			
		

	





	

		

			

				
					
数据结构知识点【第二章线性表】

					
最新发布

				
			

			

				

					m0_72681036的博客
				

				

					07-20
					
					355
					
				

			

		

		

			
				
2.1线性表的定义和特点线性表是具有相同特性的数据元素的一个有限序列n = 0空表2.3 线性表的类型定义InitList(&L) 构造一个空的线性表GetElem(L,i,&e) e返回L中第i个元组值LocateElem(L,e,compare()) 返回第一个与e满足比较的位序PriorElem(L,cur_e,&pre_e) 返回cur_e的前驱ListInsert(&L,i,e) 在i位置插入eListDelete(&L,i,&e) 删除第i个元素，e返回其值。

			
		

	





	

		

			

				
					
数据结构——线性表学习总结1（顺序表）

				
			

			

				

					Star_jiang的博客
				

				

					03-08
					
					748
					
				

			

		

		

			
				
前言：我是为了考研来学习的数据结构，作为计算机专业基础课，它是当值无愧的一块难啃的硬骨头，对于我这个跨专业的考生学起来非常的难受；前面发的C学习的博客是为了学习这里的铺垫，毕竟不熟悉结构体、指针、还有malloc()等函数简直就不是到那些代码写的啥。下面的总结笔记主要来自于小甲鱼老师的视频教程，我边看边暂停记笔记写代码，在博客里做一个归拢，当作一个回顾和复习（其实和预习差不多）。
一、线性表定义及...

			
		

	





	

		

			

				
					
数据结构——线性表的顺序存储结构(C/C++语言描述）

				
			

			

				

					学到的就要教人  赚到的就要给人
				

				

					05-13
					
					1984
					
				

			

		

		

			
				
最近复习数据结构，在读数据结构的经典作《大话数据结构》(程杰），以下是近期对于线性表的顺序存储结构的整理，后期尽量持续更新。

一、顺序存储定义

  线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。

二、顺序存储方式

1. 顺序存储的结构代码为：


#include<stdio.h>
#include<stdlib.h>...

			
		

	





	

		

			

				
					
《数据结构和算法 python语言描述》学习笔记（三）————线性表

				
			

			

				

					qq_42056492的博客
				

				

					10-19
					
					1314
					
				

			

		

		

			
				
第一部分：内容概述

线性表的概念和表的抽象数据类型
顺序表的实现
链接表
链表的变形和操作
表的应用

第二部分：学习笔记

线性表的概念和表的抽象数据类型
   1. 在一个非空的线性表里，存在着唯一的一个首元素和唯一的一个尾元素（末元素）。除首元素之外，表的每个元素e都有且仅有一个前驱元素；除了尾元素之外的每个元素都有且仅有一个后继元素。
   2. 线性表的操作
    ① 首先，作为抽象...

			
		

	





	

		

			

				
					
数据结构--单链表的基本操作 (C/C++)

				
			

			

				

					weixin_51775646的博客
				

				

					11-09
					
					4610
					
				

			

		

		

			
				
实现单链表的创建、插入、删除、查找、取值五种操作




typedef  int Status;
typedef  int ElemType;


解释1.：
定义不同的数据类型名称是为了程序的可读性.
而且一旦你需要将类型变换比如使用double型的了,只要写:
typedef double elemtype;
一下子就全改了,如果没有定义的话就要一个个的把int改成double
解释2：
typedef int status;是个自定义类型的语句
typedef用来定义类型的别名
status i;.

			
		

	





	

		

			

				
					
数据结构——单链表代码总结

				
			

			

				

					Acc222222的博客
				

				

					08-02
					
					2755
					
				

			

		

		

			
				
1.单链表结点的定义




			
		

	





	

		

			

				
					
线性表的基本操作及其应用

				
			

			

				

					梦想还是要有的
				

				

					12-05
					
					6609
					
				

			

		

		

			
				
线性表的基本操作及其应用

一、实验目的
1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。
 
二、实验内容
本次实验提供4个题目，每个题目都标有难度系数，*越多难度越大，学生可以根据自己的情况选做！
题目一：单链表的基本操作（*）
[问题描述]
实现带头结点的单链表的建立

			
		

	





	

		

			

				
					
C++:cin、cin.getline()、getline()的用法

				
			

			

				

					weixin_33901641的博客
				

				

					07-02
					
					6797
					
				

			

		

		

			
				
主要内容：
1、cin用法
2、cin.getline()用法
3、getline()用法
3、注意的问题
 
一、cin&gt;&gt;
用法1：输入一个数字或字符
#include &lt;iostream&gt;using namespace std;main (){int a,b;cin&gt;&gt;a&gt;&gt;b;cout&lt;&lt;a+b&lt;&lt;en...

			
		

	





	

		

			

				
					
数据结构——单链表的输出——我的学习之路

				
			

			

				

					qq_43923446的博客
				

				

					04-17
					
					4043
					
				

			

		

		

			
				
#include
using namespace std;
typedef struct node{
int data;
struct node *next;
}node,*linklist;
node *Create()//链表创建函数
{
linklist head,p,tail;
cout<<“请输入链表数据，以0结束！！！”<<endl;
head=p=tail=n...

			
		

	





	

		

			

				
					
cin的个人理解

				
			

			

				

					
				

				

					08-09
					
					4293
					
				

			

		

		

			
				
标准输入设备cin是指从键盘输入数据 , 而我们知道从键盘输入的时候是使用了缓冲的(windows中是行缓冲) ，系统将输入数据放到程序的缓存内存中是以Enter键为标志的。
也就是说 我们输入了一行数据（可以只一个字符或者N个字符时)时，这些数据先是被系统检测到后存放在系统的

			
		

	





	

		

			

				
					
【转】C语言中 -＞ 是什么意思？

					
热门推荐

				
			

			

				

					littesss的博客
				

				

					05-04
					
					21万+
					
				

			

		

		

			
				
-&gt;是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“-&gt;”.
举个例子：
struct Data
{
   int a,b,c;
};              /*定义结构体*/
struct Data * p;/*定义结构......

			
		

	





	

		

			

				
					
第二章 线性表

				
			

			

				

					ccnuacmhdu的博客
				

				

					09-14
					
					308
					
				

			

		

		

			
				
Microsoft Visual Studio 2012实现： 
头文件：顺序表基本操作函数.h 
源文件：顺序表.cpp顺序表基本操作函数.h#include<iostream>using namespace std;const int LIST_INIT_SIZE=100;
const int LIST_INCREMENT=100;typedef struct{
    int *elem;

			
		

	





	

		

			

				
					
Java数据结构复习：线性表实现与应用

				
			

			

				

					
				

			

		

		

			
				
这篇复习笔记主要涵盖了Java中的数据结构——线性表。线性表是一种基本的数据结构，它包含了一组有序的元素，每个元素都有一个唯一的索引。在Java中，线性表可以由数组或链表来实现。  1. 数组 数组是最简单的线性...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值