数组单链表

在那个久远的没有指针的年代,,据说伟大的先人们都是用数组来实现单链表

#define MAXSIZE 20
typedef struct
{
    int cursor;
    int data;
}Component;

void cursor_init(Component list[], int *len)
{
    int i =  0;
    for(i=0; i<MAXSIZE; i++)
    {
        list[i].cursor = i + 1;
    }
    list[MAXSIZE-1].cursor = 0;
    *len = 0;
}

void cursor_print1(Component list[])
{
    int start = list[MAXSIZE-1].cursor;
    int i = start;
    if(start == 0) {
        printf("kong -----\n");
        return;
    }
    while(i)
    {
        printf("%d ", list[i].data);
        i = list[i].cursor;
    }
    printf("\n");
}

void cursor_print2(Component list[], int *len)
{
    int start = list[MAXSIZE-1].cursor;
    int i = 0;
    for(i=0;i<*len;i++) {
        printf("%d ", list[start].data);
        start = list[start].cursor;
    }
    printf("\n");
 } 

void cursor_insert(Component list[], int position, int data, int *len)
{
    int i = 0;
    int start = list[MAXSIZE-1].cursor;
    int j = start;
    int p;
    if(position<1 || position > *len+1) {
        printf("no----\n");
        return;
    }

    p = list[0].cursor;
    list[p].data = data;
    list[0].cursor = list[p].cursor;

    if(start == 0) {
        list[MAXSIZE-1].cursor = p;
        list[p].cursor = 0;
    }else if( position==1 ){
        list[MAXSIZE-1].cursor = p;
        list[p].cursor = start;
    }else {
        for(i=1; i<position-1;i++)
        {
            j = list[j].cursor;
        }

        list[p].cursor = list[j].cursor;
        list[j].cursor = p;
    }

    *len += 1;

}

int main()
{
    Component list[MAXSIZE];
    int len;
    cursor_init(list, &len);

    cursor_insert(list, 1, 1, &len);
    cursor_insert(list, 2, 2, &len);
    cursor_insert(list, 3, 3, &len);
    cursor_insert(list, 4, 4, &len);
    cursor_insert(list, 5, 5, &len);
    cursor_insert(list, 3, 3, &len);
    cursor_insert(list, 4, 4, &len);
    cursor_insert(list, 5, 5, &len);
    cursor_insert(list, 3, 7, &len);
    cursor_insert(list, 4, 8, &len);
    cursor_insert(list, 1, 9, &len);

    cursor_print1(list);
    cursor_print2(list, &len);
    return 0;
}

删除跟插入类似,就不写了。。。。

时间: 2024-09-29 21:36:28

数组单链表的相关文章

Java 1.8 HashMap源码解析 桶数组+单链表+红黑树

1 // 非线程安全 2 // 继承了AbstractMap 3 // 实现了Map.Cloneable.Serializable接口 4 // 后面2个接口是标记接口,没有抽象方法. 5 // 表示HashMap可以浅复制.序列化和反序列化. 6 public class HashMap<K,V> extends AbstractMap<K,V> 7 implements Map<K,V>, Cloneable, Serializable 1 // 序列化版本唯一标识

基于数组实现的单链表(兼具Boost单元测试)

对于单链表,我们大多时候会用指针来实现(可参考基于指针实现的单链表).现在我们就来看看怎么用数组来实现单链表. 1. 定义单链表中结点的数据结构 1 typedef int ElementType; 2 class NodeType 3 { 4 public: 5 ElementType data; 6 int next; 7 }; 该结点包括了两个元素,其一是数据,另一个是指向下一个结点的"指针"(在这篇文章中实际上是指用于实现单链表的数组的下标.)  2. 定义一个的数组 1 co

63.如何对单链表进行快排?和数组快排的分析与对比[quicksort of array and linked list]

[本文链接] http://www.cnblogs.com/hellogiser/p/quick-sort-of-array-and-linked-list.html [题目] 单链表的特点是:单向.设头结点位head,则最后一个节点的next指向NULL.如果只知道头结点head,请问怎么将该链表排序? [分析] 对于数组的快排:有2种方式. (1)指针相向移动:一个指针i指向头,一个指针j指向尾,然后两个指针相向运动并按一定规律交换值,最后找到一个支点p使得支点左边的值小于支点,支点右边的值

给定数组,创建(带头节点)的单链表(头插法、尾插法)

一般有两种常用的方法来建立单链表:头插法与尾插法. (1)头插法:每次将新申请的节点插在头节点的后面: 简单来说,就是把新加进的元素放在表头后的第一个位置: 首先,让新节点的next指向头节点之后:然后,让表头的next指向新节点. (2)尾插法:每次将新申请的节点插在终端节点的后面. #include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node *next; } NODE; /

深度解析(三)数组、单链表和双链表

数组.单链表和双链表介绍 以及 双向链表的C/C++/Java实现 概要 线性表是一种线性结构,它是具有相同类型的n(n≥0)个数据元素组成的有限序列.本章先介绍线性表的几个基本组成部分:数组.单向链表.双向链表:随后给出双向链表的C.C++和Java三种语言的实现.内容包括:数组单向链表双向链表1. C实现双链表2. C++实现双链表3. Java实现双链表 数组 数组有上界和下界,数组的元素在上下界内是连续的. 存储10,20,30,40,50的数组的示意图如下: 数组的特点是:数据是连续的

日常学习随笔-数组、单链表、双链表三种形式实现栈结构的基本操作

一.栈结构 栈(stack)是限制插入和删除只能在一个位置上的表,该位置是 表的末端,叫做栈的顶(Top).对栈的基本操作有push(进栈),pop(出栈),peak(栈顶元素),size(栈容量)等. 栈的核心思想:"先进后出". 二.案例一:数组实现"栈" 1 package com.xfwl.algorithmAnalysis.stack; 2 3 import java.util.Arrays; 4 5 /** 6 * 自定义栈结构(基于数组的形式) 7 *

数据结构单链表,双链表,数组的底层实现原理

单链表: 链表是动态分配内存在内存中不连续,单链表只有一个向下的指针,指向下一个节点,单链表的定位时间复杂度是O(n),插入删除的时间复杂度是O(1) 双链表: 链表是动态分配内容在内存中不连续,单双链表一致,双链表有两个指针prov,next ,prov指向上一个节点,next指向下一个节点,理论上同样的数据量双向链表的查询速度比单链表快,双向链表可以使用二分查找法,最多查找一半的元素就可得到目标,单链表需要遍历整个链表对象. 数组: 数组静态分配内存,在内存中连续 数组的优点 随机访问性强(

快速排序,归并排序,堆排序的数组和单链表实现

原文链接:https://www.cnblogs.com/DarrenChan/p/8807112.html 这三个排序的时间复杂度都是O(nlogn),所以这里放到一起说. 回到顶部 1. 快速排序# 快速排序(英语:Quicksort),又称划分交换排序(partition-exchange sort),通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成

数据结构 线性结构(数组[列表] ,链表 单链表的增删改查**, 线性结构的应用 队列 栈[函数的调用**]),非线性结构 树

数据结构 参考:http://lupython.gitee.io/ 线性结构 就是能够用一根线串起来的数据结构 数组 (列表) 问:申请数组的前提条件是啥? a[12]?内存需要满足的条件? 答:内存必须有一块连续的内存空间 int a[7] : 声明一个数组,这个数组的数组名是 a, 数组的大小是 7, 数组元素的类型是整型. int a[7] = array(1,2,3,4,5,6,7) 问:如何申请内存? 答:C,C++语言,申请:mallco (28).释放:free(28) 问:int