线性表的js实现 -- 顺序表、链表（单链表、双链表、循环链表）

线性表及其逻辑结构

线性表的顺序存储结构----顺序表

顺序表的基本实现C++

#include <iostream>
#include <stdlib.h>
#define MaxSize 50
using namespace std;

typedef char ElemType;
typedef struct SqList
{
    ElemType data[MaxSize];
    int length;
} SqList;

// 初始化线性表
void InitList(SqList *&L)
{
    L = (SqList *)malloc(sizeof(SqList)); // 分配空间
    L->length = 0;
}

// 摧毁线性表
void DestroyList(SqList *&L)
{
    free(L);
}

// 判断是否为空表
bool ListEmpty(SqList *L)
{
    return (L->length == 0);
}

// 表长度
int ListLength(SqList *L)
{
    return L->length;
}

// 输出线性表
void DispList(SqList *L)
{
    if (ListEmpty(L))
        return;
    for (int i = 0; i < L->length; i++)
    {
        cout << L->data[i] << " ";
    }
    cout << endl;
}

// 求某个元素的值
bool GetElem(SqList *L, int i, ElemType &e)
{
    if (i < 1 || i > L->length)
        return false;
    e = L->data[i - 1];
    return true;
}

// 按元素查找
int LocateElem(SqList *L, ElemType e)
{
    int i = 0;
    while (i < L->length && L->data[i] != e)
        i++;
    if (i >= L->length)
        return 0;
    else
        return i + 1;
}

// 插入数据
bool ListInsert(SqList *&L, int i, ElemType e)
{
    if (i < 1 || i > L->length + 1)
        return false;
    int j;
    i--;
    for (j = L->length; j > i; j--)
        L->data[j] = L->data[j - 1];
    L->data[i] = e;
    L->length++;
    return true;
}

// 删除数据
bool ListDelete(SqList *&L, int i, ElemType &e)
{
    if (i < 1 || i > L->length)
        return false;
    int j;
    i--;
    e = L->data[i];
    for (j = i; j < L->length; j++)
        L->data[j] = L->data[j + 1];
    L->length--;
    return true;
}

int main()
{
    SqList *L;
    ElemType e;
    cout << "1.初始化" << endl;
    InitList(L);
    cout << "2.尾插法:a,b,c,d" << endl;
    ListInsert(L, ListLength(L) + 1, 'a');
    ListInsert(L, ListLength(L) + 1, 'b');
    ListInsert(L, ListLength(L) + 1, 'c');
    ListInsert(L, ListLength(L) + 1, 'd');
    cout << "3.输出：";
    DispList(L);
    cout << "4.长度：" << ListLength(L) << endl;
    cout << "5.是否为空：" << (ListEmpty(L) ? "空" : "非空") << endl;
    GetElem(L, 3, e);
    cout << "6.第3个元素：" << e << endl;
    cout << "7.元素a的位置：" << LocateElem(L, 'a') << endl;
    cout << "8.在第1个位置是插入e：";
    ListInsert(L, 1, 'e');
    DispList(L);
    cout << "9.删除最后一个：";
    ListDelete(L, ListLength(L), e);
    DispList(L);
    cout << "10.释放表";
    DestroyList(L);
    return 0;
}

顺序表的基本实现JavaScript

class SqList {
    constructor() {
        this.data = [];
        this.length = 0;
        // 初始化顺序表
        this.InitList = function () {
            this.length = 0;
        };
        // 销毁线性表
        this.DestroyList = function () {
            delete this.data;
            this.data = [];
            this.length = 0;
        };
        // 判断是否为空
        this.ListEmpty = function () {
            return this.length == 0;
        };
        // 求线性表长度
        this.ListLength = function () {
            return this.length;
        };
        // 输出线性表
        this.DisList = function () {
            if (this.length == 0)
                return;
            let str = "";
            for (let i = 0; i < this.length; i++) {
                str += this.data[i] + " ";
            }
            console.log(str);
        };
        // 获取某个数据元素值
        this.GeElem = function (i) {
            if (i < 0 || i > this.length)
                return false;
            else
                return this.data[i];
        };
        // 插入
        this.ListAppend = function (e) {
            this.data[this.length++] = e;
        };
    }
}

let l = new SqList();
l.InitList();
l.ListAppend("abc");
l.ListAppend("000");
l.DisList();
let o = new Object();
console.log(l.GeElem(-1));

例题1:以第一个元素为分界线，小于它的放前面，大于它的放后面

void move1(SqList *&L)
{
    int i = 1, j = L->length - 1;
    ElemType firstNum = L->data[0];
    ElemType temp;
    while (i < j)
    {
        while (i < j && L->data[j] > firstNum)
            j--;
        while (i < j && L->data[i] <= firstNum)
            i++;
        if (i < j)
        {
            temp = L->data[i];
            L->data[i] = L->data[j];
            L->data[j] = temp;
        }
    }

    temp = L->data[0];
    L->data[0] = L->data[i];
    L->data[i] = temp;
}

void move2(SqList *&L)
{
    int firstNum = L->data[0];
    int i = 0, j = L->length - 1;
    while (i < j)
    {
        while (i < j && L->data[j] > firstNum)
            j--;
        L->data[i] = L->data[j];
        i++;
        while (i < j && L->data[i] <= firstNum)
            i++;
        L->data[j] = L->data[i];
        j--;
    }
    L->data[i] = firstNum;
}

例题2：删除重复元素 时间复杂度O（n） 空间复杂度O（1）

// 删除重复的元素e 方法一
void DeleteNode1(SqList *&L, ElemType e)
{
    int k = 0;
    for (int i = 0; i < L->length; i++)
    {
        if (L->data[i] != e)
        {
            L->data[k++] = L->data[i];
        }
    }
    L->length = k;
}

// 删除重复元素e 方法二
void DeleteNode2(SqList *&L, ElemType e)
{
    int k = 0;
    for (int i = 0; i < L->length; i++)
    {
        if (L->data[i] != e)
        {
            L->data[i - k] = L->data[i];
        }
        else
        {
            k++;
        }
    }
    L->length -= k;
}
// 删除重复元素e 方法三
void DeleteNode3(SqList *&L, ElemType e)
{
    int i = 0, j = L->length - 1;
    while (i < j)
    {
        while (i < j && L->data[i] != e)
            i++;
        while (i < j && L->data[j] == e)
        {
            j--;
            L->length--;
        }
        if (i < j)
        {
            L->data[i] = L->data[j];
            j--;
            L->length--;
        }
    }
}

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

1.单链表

单链表的基本实现C++

#include <iostream>
#include <stdlib.h>
using namespace std;
typedef char ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LinkList;

// 头插法建表
void CreateListF(LinkList *&L, ElemType a[], int n)
{
    L = (LinkList *)malloc(sizeof(LinkList));
    L->next = NULL;
    LinkList *s;
    for (int i = 0; i < n; i++)
    {
        s = (LinkList *)malloc(sizeof(LinkList));
        s->data = a[i];
        s->next = L->next;
        L->next = s;
    }
    cout << "头插法：";
}

// 尾插法
void CreateListR(LinkList *&L, ElemType a[], int n)
{
    L = (LinkList *)malloc(sizeof(LinkList));
    L->next = NULL;
    LinkList *r, *s;
    r = L;
    for (int i = 0; i < n; i++)
    {
        s = (LinkList *)malloc(sizeof(LinkList));
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
    cout << "尾插法：";
}

// 初始化单链表
void InitList(LinkList *&L)
{
    L = (LinkList *)malloc(sizeof(LinkList));
    L->next = NULL;
}

// 销毁单链表
void DestoryList(LinkList *&L)
{
    LinkList *pre = L, *q = pre->next;
    while (q != NULL)
    {
        free(pre);
        pre = q;
        q = pre->next;
    }
    free(pre);
}

//  判断是否为空链表
bool ListEmpty(LinkList *L)
{
    return (L->next == NULL);
}

// 获取链表长度
int ListLength(LinkList *L)
{
    LinkList *p = L;
    int n = 0;
    while (p->next != NULL)
    {
        n++;
        p = p->next;
    }
    return n;
}

// 输出单链表
void DispList(LinkList *L)
{
    LinkList *p = L->next;
    while (p != NULL)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

// 获取某个元素
bool GetElem(LinkList *L, int i, ElemType &e)
{
    int j = 0;
    LinkList *p = L;
    while (j < i && p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else
    {
        e = p->data;
        return true;
    }
}

// 查找元素位置
int LocateList(LinkList *L, ElemType e)
{
    int i = 1;
    LinkList *p = L->next;
    while (p != NULL && p->data != e)
    {
        p = p->next;
        i++;
    }
    if (p == NULL)
        return 0;
    else
        return i;
}

// 插入元素
bool ListInsert(LinkList *&L, int i, ElemType e)
{
    int j = 0;
    LinkList *p = L, *s;
    while (j < i - 1 && p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else
    {
        s = (LinkList *)malloc(sizeof(LinkList));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}

// 删除元素
bool ListDelete(LinkList *&L, int i, ElemType &e)
{
    int j = 0;
    LinkList *p = L, *q;
    while (j < i - 1 && p != NULL)
    {
        j++;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else
    {
        q = p->next;
        if (q == NULL)
        {
            return false;
        }
        e = q->data;
        p->next = p->next->next;
        free(q);
        return true;
    }
}

int main()
{
    LinkList *L;
    ElemType e;
    char list[5] = {'a', 'b', 'c', 'd', 'e'};
    // CreateListF(L, list, 5);
    CreateListF(L, list, 5);
    DispList(L);
    ListInsert(L, ListLength(L) + 1, 'f');
    DispList(L);
    cout << ListLength(L) << endl;
    ListDelete(L, 1, e);
    cout << e << endl;
    cout << (ListEmpty(L) ? "yes" : "no") << endl;
    DispList(L);
    GetElem(L, 2, e);
    cout << e << endl;
    int l = LocateList(L, 'f');
    cout << l << endl;
    return 0;
}

单链表实现JavaScript

//创建一个Node
辅助类，用来生成节点
function Node(value) {
    this.value = value;
    this.next = null;
}

//链表类
function LinkedList() {
    this.head = null;
    this.length = 0;
    //向链表尾部追加元素
    this.push = push;
    //从链表中查找某个元素
    this.find = find;
    //在链表中任意一个元素之后插入一个元素
    this.insertAfter = insertAfter;
    //从链表中查找任意元素节点的前一个节点
    this.findPrevious = findPrevious;
    //从链表中删除值为value的元素
    this.remove = remove;
    //返回当前链表的长度
    this.size = size;
    //查找某个元素在链表中的索引值
    this.indexof = indexof;
    //删除链表中第pos个元素
    this.removeAt = removeAt;
    //获取链表中第一个元素
    this.getHead = getHead;
    //打印当前的链表，供测试用
    this.print = print;
}

function push(value) {
    var node = new Node(value);
    if (this.head == null) {
        this.head = node;
    } else {
        var current = this.head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = node;
    }
    this.length++;
}

function insertAfter(value, item) {
    var node = new Node(value);
    var current = this.find(item);
    if (current == null) {
        return console.log('找不到元素');
    }
    node.next = current.next;
    current.next = node;
    length++;
}

function remove(value) {
    var previous = this.findPrevious(value);
    var current = this.find(value);
    if (previous == null) {
        return console.log('链表中找不到被删除的元素');
    }
    previous.next = current.next;
    length--;
}

function removeAt(pos) {
    if (pos > -1 && pos < length) {
        var current = this.head;
        var index = 0;
        if (pos === 0) {
            this.head = current.next;
        } else {
            while (index < pos) {
                var previous = current;
                current = current.next;
                index++;
            }
            previous.next = current.next;
        }
        length--;
    } else {
        return null;
    }
}

function find(value) {
    var currentNode = this.head;
    if (currentNode == null) {
        console.log("这是一个空链表！！！");
        return null;
    }
    if (currentNode.value === value) {
        return currentNode;
    }
    while (currentNode.next) {
        currentNode = currentNode.next;
        if (currentNode.value === value) {
            return currentNode
        }
    }
    console.log("没有找到该元素！！！");
    return null;
}

function findPrevious(value) {
    var current = this.head;
    if (current == null) {
        console.log('这是一个空链表');
        return null;
    }
    while (current.next) {
        current = current.next;
        if (current.next.value === value) {
            return current;
        }
    }
    console.log('找不到该元素的前一个元素');
    return null;
}

function indexof(value) {
    var current = this.head;
    var index = 0;
    if (current == null) {
        return null;
    } else {
        while (current) {
            if (current.value === value) {
                return index;
            }
            index++;
            current = current.next;
        }
    }
    return -1;
}

function size() {
    return length;
}

function getHead() {
    return this.head;
}

function print() {
    var current = this.head;
    while (current != null) {
        console.log(current.value);
        current = current.next;
    }
}

var list1 = new LinkedList();
console.log(list1);

list1.push(2);
list1.push(4);
list1.push(3);
var list2 = new LinkedList();
list2.push(5);
list2.push(6);
list2.push(4);

例题1：两数相加

//C++
ListNode *addTwoNumbers(ListNode *l1, ListNode *l2)
{
    if (l1->next != NULL && l2->next == NULL)
        return l1;
    if (l1->next == NULL && l2->next != NULL)
        return l2;

    ListNode *l;
    ListNode *p1 = l1->next, *p2 = l2->next;
    l = (ListNode *)malloc(sizeof(ListNode));
    l->next = NULL;
    int len1 = ListLength(l1);
    int len2 = ListLength(l2);
    int len = len1 > len2 ? len1 : len2;
    int i = 0;
    bool flag = false;
    while (i < len)
    {
        int num1 = (p1 == NULL) ? 0 : p1->val;
        int num2 = (p2 == NULL) ? 0 : p2->val;
        int total = num1 + num2;
        int num = total % 10;
        int val = num + (flag ? 1 : 0);
        InsertFirst(l, val);
        flag = total >= 10 ? true : false;
        i++;
        p1 = p1->next;
        p2 = p2->next;
    }
    return l;
}

// js
var addTwoNumbers = function (l1, l2) {
    let res = new ListNode(null);
    let p1 = l1,
        p2 = l2,
        q = res;
    let flag = false;
    while (p1 != null || p2 != null) {
        let num1 = (p1 != null) ? p1.val : 0;
        let num2 = (p2 != null) ? p2.val : 0;

        let val = (num1 + num2 + (flag ? 1 : 0)) % 10;
        flag = (num1 + num2 + (flag ? 1 : 0)) >= 10 ? true : false;
        q.next = new ListNode(val);
        q = q.next;

        if (p1 != null)
            p1 = p1.next;
        if (p2 != null)
            p2 = p2.next;

    }
    if (flag)
        q.next = new ListNode(1);
    return res.next;
};

2.双链表

// 头插法
void CreatListF(DLinkList *&L,ELemType a[],int n)
{
    DLinkList *s;
    int i;
    L = (DLinkList *)malloc(sizeof(DLinkList));
    L->prior = L->next = NULL;
    for(i=0;i<n;i++){
        s = (DLinkList *)malloc(sizeof(DLinkList));
        s->data = a[i];
        s->next = L->next;
        if(L->next!=NULL)
            L->next->prior = s;
        L->next = s;
        s->prior = L;
    }
}

// 尾插法

void CreatListR(DLinkList *&L,ELemType a[],int n)
{
    DLinkList *s,*r;
    int i;
    L = (DLinkList *)malloc(sizeof(DLinkList));
    r=L;
    for(i=0;i<n;i++){
        s = (DLinkList *)malloc(sizeof(DLinkList));
        s->data = a[i];
        r->next=s;s->prior=r;
        r=s;
    }
    r->next=NULL;
}

// s插入p之后
s->next = p->next;
p->next->prior = s;
s->prior = p;
p->next = s;

// 删除p的后继节点q
p->next = q->next;
p->next->prior = p;

3.循环链表

判断尾节点p的条件是p->next==L

有序表—归并算法

function UnionList(l1, l2) {
    let arr = [],
        i = 0,
        j = 0;
    let len1 = l1.length,
        len2 = l2.length;
    while (i < len1 && j < len2) {
        if (l1[i] < l2[j]) {
            arr.push(l1[i]);
            i++;
        } else {
            arr.push(l2[j]);
            j++;
        }
    }
    while (i < len1) {
        arr.push(l1[i]);
        i++;
    }
    while (j < len2) {
        arr.push(l2[j]);
        j++;
    }
    return arr;
}