精华内容
下载资源
问答
  • 指针实现数据结构顺序几种功能。包括插入,判断顺序表是否为空,遍历顺序表,获取指定位置元素,查找元素,获取元素前驱、后继,删除、清空、销毁顺序表。
  • 队列的顺序存储结构队列基本概念顺序队列的实现结构体定义初始化操作入队操作出队操作完整的测试用例 队列基本概念 队列是一种操作受限的线性表,其只允许在一端插入(入队操作),一端删除(出队操作)。顺序存储...

    队列基本概念

    队列是一种操作受限的线性表,其只允许在一端插入(入队操作),一端删除(出队操作)。顺序存储结构使用一块连续的存储结构存储队列,其形式上易于理解,但队大小固定,且每次出队操作都需要移动元素,但这和实际生活非常类似,算法过程非常形象。

    顺序队列的实现

    结构体定义

    这里使用尾指针来表示队尾位置,因为队首位置固定所以可以简化。

    typedef int ElemType;
    typedef struct Queue{
        ElemType data[MAXSIZE+1];
        int rear;   //尾指针 
    };
    

    初始化操作

    这里使用星标位置0号位置,来保存上一个出队的元素,这样可以避免不想要的删除,同时队尾指针的数值大小正好可以表示队列的元素个数,队列从一号下表开始,也便于理解。

    //初始化队列 
    Queue* initQueue(){
        Queue* Q;
        Q = (Queue*)malloc(sizeof(Queue));
        Q->data[0] = 0; //0位置为信标位置保存上一次出队的元素 
        Q->rear = 0;    //尾指针数值可表示队列长度 
        return Q;
    }
    

    入队操作

    因为空间有限所以要判断队是否已经满了

    //入队操作 
    void enQueue(Queue* Q,ElemType e){
        if(Q->rear < MAXSIZE){
            Q->data[++Q->rear] = e;
        }else{
            printf("队列已满");
        }
    }
    

    出队操作

    //出队操作 
    ElemType deQueue(Queue* Q){
        int i;
        if(isEmpty(Q)){
            printf("队列为空");
            return -1;
        }else{
            for(i=0;i<Q->rear;i++){
                Q->data[i] = Q->data[i+1];
            }
            Q->rear--;
            return Q->data[0];;
        }
    }
    

    完整的测试用例

    /*此程序用以使用顺序存储结构实现队列,主函数已作出测试。
    若使用可将整数类型替换为指针来建立广义队列。
    作者:姚帅   未经允许不得用作商业用途*/
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    
    #define MAXSIZE 20  //设置队列大小 
    
    typedef int ElemType;
    typedef struct Queue{
        ElemType data[MAXSIZE+1];
        int rear;   //尾指针 
    };
    
    Queue* initQueue(); //初始化队列 
    bool isEmpty(Queue* Q); //判断是否为空 
    void enQueue(Queue* Q,ElemType e);  //入队操作 
    ElemType deQueue(Queue* Q); //出队操作 
    ElemType getHead(Queue* Q); //获得队首元素 
    int getLong(Queue* Q);  //获得队长 
    void printall(Queue* Q);    //输出队列中所有元素 
    
    int main(){
        Queue* Q = initQueue();
        enQueue(Q,99);
        enQueue(Q,88);
        enQueue(Q,77);
        printf("三个元素入队后:");
        printall(Q); 
        printf("一个元素出队后:");
        deQueue(Q);
        printall(Q);
        getchar();
    }
    
    //初始化队列 
    Queue* initQueue(){
        Queue* Q;
        Q = (Queue*)malloc(sizeof(Queue));
        Q->data[0] = 0; //0位置为信标位置保存上一次出队的元素 
        Q->rear = 0;    //尾指针数值可表示队列长度 
        return Q;
    }
    
    //判断是否为空 
    bool isEmpty(Queue* Q){
        if(Q->rear == 0){
            return true;
        }else{
            return false;
        }
    }
    
    //入队操作 
    void enQueue(Queue* Q,ElemType e){
        if(Q->rear < MAXSIZE){
            Q->data[++Q->rear] = e;
        }else{
            printf("队列已满");
        }
    }
    
    //出队操作 
    ElemType deQueue(Queue* Q){
        int i;
        if(isEmpty(Q)){
            printf("队列为空");
            return -1;
        }else{
            for(i=0;i<Q->rear;i++){
                Q->data[i] = Q->data[i+1];
            }
            Q->rear--;
            return Q->data[0];;
        }
    }
    
    //获得队首元素 
    ElemType getHead(Queue* Q){
        if(isEmpty(Q)){
            printf("队列为空");
            return -1;
        }else{
            return Q->data[1];
        }
    } 
    
    //获得队中元素个数 
    ElemType getLong(Queue* Q){
        return Q->rear;
    }
    
    //输出队中元素 
    void printall(Queue* Q){
        int i;
        for(i=1;i<Q->rear;i++){
            printf("%d--",Q->data[i]);
        }
        printf("%d\n",Q->data[Q->rear]);
    }
    

    测试结果
    测试结果

    展开全文
  • 删除顺序表中重复数据,数据表中有数据重复时, 保留最前面数据,删除后面重复数据。 请注意,本题有预置代码,只需提交所要求函数定义代码即可。 预置代码: ...
  • //有序顺序表中删除值重复元素 void WangDao6DeleteRepeatElement(List list) { int i, j; //i用来储存第一个不相同元素,j为工作指针(即一直往后扫描) if (list->Last==-1) { printf("顺序表为空"); } ...

    一.算法思想

    采用类似于插入排序的思想,将数组的第一个元素视为非重复的有序表,之后依次判断后面的元素是否与前面的元素重复,若不重复则插入到前面非重复有序表的最后,反之则继续往后判断

    二.源代码

    //有序顺序表中删除值重复的元素
    void WangDao6DeleteRepeatElement(List list) {
    	int i, j; //i用来储存第一个不相同的元素,j为工作指针(即一直往后扫描)
    	if (list->Last==-1) {
    		printf("顺序表为空");
    	}
    	for (i = 0, j = 1; j <= list->Last - 1;j++) {
    		//寻找下一个与上个元素值不同的元素,找到后,将元素往前移
    
    		if (list->Data[j]!=list->Data[i]) { 
    			list->Data[++i] = list->Data[j];
    		}
    	}
    	list->Last = i;
    }
    
    展开全文
  • #include <stdio.h> #include <... //指示动态分配数组的指针 int MaxSize; //顺序最大容量 int length; //顺序当前长度 }SeqList; void InitList(SeqList &L){ //用malloc
    #include <stdio.h>
    #include <malloc.h>
    #include <stdlib.h>
    #define InitSize 10	//默认的最大长度 
    typedef struct{
    	int *data;		//指示动态分配数组的指针 
    	int MaxSize;	//顺序表的最大容量 
    	int length;		//顺序表的当前长度 
    }SeqList;
    
    void InitList(SeqList &L){
    	//用malloc函数申请一片连续的存储空间 
    	L.data=(int *)malloc(InitSize*sizeof(int));
    	L.length=0;
    	L.MaxSize=InitSize;
    } 
    
    //增加动态数组的长度 
    void IncreaseSize(SeqList &L ,int len){
    	int *p=L.data;
    	L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));
    	for(int i=0;i<L.length;i++){
    		L.data[i]=p[i];		//将数据复制到新区域 
    	}
    	L.MaxSize=L.MaxSize+len;//顺序表最大长度增加len 
    	free(p); 		//释放原来的内存空间 
    }
    
    //插入操作 
    bool ListInsert(SeqList &L,int i,int e){
    	if(i<1||i>L.length+1){
    		return false;
    	}
    	if(L.length>=L.MaxSize){
    		return false;
    	}
    	for(int j=L.length;j>=i;j--){
    		L.data[j]=L.data[j-1];
    	}
    	L.data[i-1]=e;		//把腾出的空间插入元素e
    	L.length++;
    	return true;
    }
    //删除操作
    bool ListDelete(SeqList &L,int i,int &e) {
    	if(i<1||i>L.length){
    		return false;
    	}
    	e=L.data[i-1];
    	for(int j=i;j<L.length;j++){
    		L.data[j-1]=L.data[j];
    	}
    	L.length--;
    	return true;
    }
    
    //按值查找顺序表,找到第一个元素值等于e的位序并返回其位序
    int LocateElem(SeqList L, int e) {
    	int i;
    	for (i = 0; i < L.length; i++)
    		if (L.data[i]==e)
    			return i + 1;
    		return 0;
    }
    
    int main(){
    	int e;
    	SeqList L;		//声明一个顺序表 
    	InitList(L);	//初始化顺序表 
    	IncreaseSize(L,5);
    	
    	//插入元素 
    	printf("请输入:\n"); 
    	for(int i = 0; i < L.MaxSize; i++){
    		scanf("%d",&e);
    		ListInsert(L,i,e);	//(顺序表,位序,插入值); 
    	}
    	//依次输出顺序表中的元素 
    	for (int i = 0; i < L.length; i++) {
    		printf("data[%d]=%d\n", i, L.data[i]);
    	} 
    		
        //按值查找
    	printf("已找到,6在顺序表中的第:%d位\n", LocateElem(L, 6) );
    	
    	//删除操作 
    	ListDelete(L,3,e);//(顺序表,位序,返回的被删除的元素) 
    	printf("删除元素值为:%d\n",e);
    	
    	
    	return 0;
    	return 0;
    }
    

    输出:
    在这里插入图片描述

    不懂请留言,谢谢!

    展开全文
  • 链表也是一种线性表,区别于顺序表,链表是一种物理上不连续存储结构,数据元素逻辑顺序是通过链表中的指针链接次序实现。头指针链表指不带头节点链表,这样链表在插入时需要考虑空表情况,指定位置删除...

    链表也是一种线性表,区别于顺序表,链表是一种物理上不连续的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。头指针链表指不带头节点的链表,这样的链表在插入时需要考虑空表的情况,指定位置删除插入时也需要考虑是否在第一个节点处。因为头指针链表的很多操作都需要改变头指针。

    下面是关于头指针链表的一些操作的实现。(包括头文件与源文件)

    头文件:LinkList.h

    #ifndef __LINKLIST_H__
    #define __LINKLIST_H__
    #define TRUE 1
    #define FALSE 0
    
    typedef int LinkData;
    typedef struct _node
    {
    	LinkData data;
    	struct _node *next;
    }LinkList;
    
    //头插法
    int	Insert_Head(LinkList **h,LinkData data);
    
    //尾插法
    int	Insert_Last(LinkList **h,LinkData data);
    
    //在第Pos个节点处插入,从1开始,没有第0个节点
    int	Insert_Pos(LinkList **h,int Pos,LinkData data);
    
    //删除第Pos个节点,从1开始,没有第0个节点
    int Delete_Pos(LinkList **h,int Pos);
    
    //逆序链表
    int Reverse_List(LinkList **h);
    
    //打印链表
    void Display(LinkList *h);
    
    #endif
    
    

    源文件:LinkList.c

    #include <stdio.h>
    #include <stdlib.h>
    #include "LinkList.h"
    
    //头插法
    int	Insert_Head(LinkList **h,LinkData data)
    {
    	if (h == NULL)
    	{
    		return FALSE;
    	}
    	LinkList * node = (LinkList *)malloc(sizeof(LinkList)/sizeof(char));
    	if (node == NULL)
    	{
    		return FALSE;
    	}
    	node -> data = data;
    	node -> next = *h;
    	*h = node;
    	return TRUE;
    }
    
    //尾插法
    int	Insert_Last(LinkList **h,LinkData data)
    {
    	if (h == NULL)
    	{
    		return FALSE;
    	}
    	LinkList * node = (LinkList *)malloc(sizeof(LinkList)/sizeof(char));
    	if (node == NULL)
    	{
    		return FALSE;
    	}
    	node -> data = data;
    	node -> next = NULL;
    	LinkList *tmp = *h;
    	if (tmp == NULL)
    	{
    		*h = node;
    	}
    	else
    	{
    		while(tmp -> next)
    		{
    			tmp = tmp -> next;
    		}
    		tmp -> next = node;
    	}
    	return TRUE;
    }
    
    //在第Pos个节点处插入,从1开始,没有第0个节点
    int	Insert_Pos(LinkList **h,int Pos,LinkData data)
    {
    	if(h == NULL || Pos < 1)
    	{
    		printf ("插入失败\n");
    		return FALSE;
    	}
    	LinkList * node = (LinkList *)malloc(sizeof(LinkList)/sizeof(char));
    	if (node == NULL)
    	{
    		return FALSE;
    	}
    	node -> data = data;
    	if (*h == NULL)   //空表
    	{
    		if (Pos != 1)
    		{
    			printf ("当前为空表,无法在第%d个节点位置插入\n",Pos);
    			free (node);
    			return FALSE;
    		}
    		node -> next = NULL;
    		*h = node;
    	}
    	else
    	{
    		if (Pos == 1)
    		{
    			node -> next = *h;
    		    *h = node;
    		}
    		else
    		{
    			LinkList *tmp = *h;
    			int i;
    			for (i = 0;i < Pos - 2;i++)
    			{
    				tmp = tmp -> next;
    				if (tmp == NULL)
    				{
    					printf ("插入越界\n");
    					free (node);
    					return FALSE;
    				}
    			}
    			node ->next = tmp -> next;
    			tmp -> next = node;
    		}
    	}
    	return TRUE;
    }
    
    //删除第Pos个节点,从1开始,没有第0个节点
    int Delete_Pos(LinkList **h,int Pos)
    {
    	if (h == NULL || *h == NULL || Pos < 1)
    	{
    		printf ("删除失败\n");
    		return FALSE;
    	}
    	LinkList *tmp = *h;
    	if (Pos == 1)
    	{
    		*h = (*h) -> next;
    		free(tmp);
    	}
    	else
    	{
    		LinkList *tmp = *h;
    		int i;
    		for (i = 0;i < Pos - 2;i++)
    		{
    			tmp = tmp -> next;
    			if (tmp -> next == NULL)
    			{
    				printf ("删除越界\n");
    				return FALSE;
    			}
    		}
    		LinkList *p = tmp -> next;
    		tmp -> next = p -> next;;
    		free (p);
    	}
    	return TRUE;
    }
    
    //逆序链表
    int Reverse_List(LinkList **h)
    {
    	if (h == NULL || *h == NULL || (*h) -> next == NULL)
    	{
    		printf ("逆序失败\n");
    		return FALSE;
    	}
    	LinkList *pre = *h;
    	LinkList *cur = (*h) -> next;
    	LinkList *tmp;
    	while(cur)
    	{
    		tmp = cur -> next;
    		cur -> next = pre;
    		pre = cur;
    		cur = tmp;
    	}
    	(*h) -> next = NULL;
    	(*h) = pre;
    	return TRUE;
    }
    
    //打印链表
    void Display(LinkList *h)
    {
    	if (h == NULL)
    	{
    		return;
    	}
    	int count = 0;
    	while(h)
    	{
    		if(count++ % 4 == 0)
    		{
    			printf ("\n");
    			
    		}
    		printf ("%8d",h -> data);
    		h = h -> next;
    	}
    	printf ("\n");
    }
    
    


    关于头指针链表的更多的功能,可以大家一起去实现。



    展开全文
  • 数据结构中线性表初始化,长度,删除等操作实现 //定义SqList类型的指针psqList //初始化psqList指向线性表 //顺序把‘o’,‘l’,‘L’,‘e’,‘e’,'H'六个字符插入到线性表psqList位置1 //判断线性表是否...
  • 【leetcode刷题记#week01】数组,顺序结构,双指针 写在前面 本刷题笔记平台:Leetcode 语言: C++ 【 leetcode# 26】 删除数组重复项 BF解法 建立一个新数组 rs,一个临时变量 temp temp存取前一个元素 ...
  • 数据结构上机课时敲。。之前用C++实现过简单三元组,,但没有用C语言实现。所以试了试,课本上参数传递都是用引用形式,而如果要用C语言实现话就都需要改为指针传递形式。 下面有一个重点就是删除过程...
  • 顺序存储结构和链式存储结构的优缺点比较

    万次阅读 多人点赞 2018-10-09 17:45:34
    顺序存储结构和链式存储结构的比较 优缺点 顺序存储时,相邻数据元素存放地址也相邻(逻辑与物理统一);要求内存中可用存储单元地址必须是连续。 优点:存储密度大(=1),存储空间利用率高。 缺点:...
  • //顺序动态分配创建及其添加、删除、查找等操作 #include<stdio.h> #include<stdlib.h> #define InitSize 10 //表长度初始定义 typedef struct { int *data; //指示动态分配数组的指针(指向第...
  • 2、链式存储适用于在较频繁地插入、删除、更新元素是,而顺序存储结构适用于频繁查询时使用 顺序比链式节约空间,是因为链式结构每一个节点都有一个指针存储域。 顺序支持随机存取,方便操作。 链式要比顺序的...
  • 队列的顺序存储结构

    2010-04-09 19:18:00
    队列的顺序存储结构称为顺序队列,顺序队列实际上是运算受限的顺序表。与顺序栈类似,在队列的顺序存储结构中,用一组地址连续的存储单元一次存放从队列头到队列尾的元素。指针front和rear被分别用来队列头和队列尾...
  • 删除:插入操作:删除操作:查找操作内存空间顺序存储:链式存储:顺序表和单链表选择三个常用操作求最值:逆置:归并: 存取方式 顺序表可以实现顺序存取和随机存取 单链表只能实现顺序存取 逻辑结构和物理结构 ...
  • 一:线性表的顺序存储结构 1.定义 2.顺序存储示意图如下所示: 3.编号地址 4.存储位置公式 5.存取操作时间性能 6.随机存储结构 7.时间复杂度 (1)对于存取操作 (2)对于插入和删除操作 8. 使用场景 二...
  • 栈的构建顺序栈的基本概念栈基本操作...栈基于顺序结构的好处是避免了指针的使用(可用整数来表是栈首的位置)易于理解,但缺点是大小固定(解决方法是动态的分配内存,具体可参见我的动态分配顺序表一文,这里不过...
  • 1. 栈定义栈定义:限定仅在表尾进行插入和删除操作线性表...2. 顺序插入和删除既然栈是线性表,而线性表包括顺序表和链表,那么同样栈也包括顺序栈和链栈。顺序栈中我们定义一个top指针,其实这里只是个游...
  • 我们在《栈的顺序存储结构》中发现,栈操作的top指针在Push时增大而在Pop时减小,栈空间是可以重复利用的,而队列的front、rear指针都在一直增大,虽然前面的元素已经出队了,但它所占的存储空间却不能重复利用。...
  • 栈 何为栈? 栈的定义:仅限在表尾进行插入或删除操作的...顺序栈:栈的顺序存储是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素,同时附设指针top指示栈顶元素在顺序栈中的位置。 顺序栈的结构定...
  • 数据结构 线性表的指针实现

    千次阅读 2018-04-16 16:00:49
    其特点为:优:(1)用数组存储数据元素,操作方法简单,容易实现 (2)无须为表示结点间逻辑关系而增加额外存储开销 (3)存储密度高 (4)顺序表可按元素位序随机存取结点缺:(1)做插入、删除操作时,需...
  • 栈 仅限定在表尾进行插入或删除操作线性表,是一种后进先出数据结构 图1.1 栈 (来源:leetcode) 存储结构 我们通过移动栈顶指针(top)进行相关数据操作,用线性结构(如数组、链表等)存储栈元素 顺序...
  • 数据结构系列-顺序基本操作

    千次阅读 2018-03-15 22:34:06
    栈(Stack)是限定只能在表尾部...对于栈的顺序存储,就是用数组来实现,将下标0的一端作为栈底,因为首元素都在栈底,变化最小。顺序栈的数据结构及基本操作:如果需要改变栈的内容,函数的参数类型为指针,否则是普...
  • 1.(必做题) 设计并验证以下算法:设顺序表L中的数据元素为整数且非递增有序,删除其值相同的多余元素,即顺序表L中相同的元素只保留一个,并逆置删除的顺序表L。 (1) 根据键盘输入数据建立顺序表L。 (2) 输出顺序...
  • 的顺序存储结构

    2021-01-15 16:09:02
    操作栈存储结构一、栈初始化操作二、栈销毁三、栈清空四、单链表的删除五、单链表整表删除六、显示链表中数据总结测试代码及运行实例 栈存储结构 栈是限定仅在表尾进行插入和删除操作线性表 ...
  • 1.栈的顺序存储结构的顺序存储结构是指用一片连续的存储空间来存储栈中的数据元素,这样的栈称为顺序栈(Sequal Stack)。它类似于线性表的顺序存储结构,可用一个足够长度的一维数组来实现。栈底位置通常设置在数组...
  • 线性表链式存储结构顺序存储结构优缺点   顺序存储用一段连续存储单元依次存储线性表数据元素 ...单链表在计算出某位置的指针后,插入和删除时间仅为O(1)   空间性能 顺序存储结构需要

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,465
精华内容 986
关键字:

删除结构指针的顺序