顺序表 有序表

template <typename T>
class SeqList
{
protected:
    T *data;
    int maxSize;
    int last;

    void reSize(int newSize)    //ok
    {
        maxSize = newSize;
        T *temp = new T[maxSize];

        for (int i = 0; i <= last; i++)
            temp[i] = data[i];
        delete[] data;
        data = temp;
    }

public:
    SeqList(int sz = defaultSize) : maxSize(sz), last(-1) //ok
    {
        data = new T[maxSize];
    }

    SeqList(SeqList<T> &L)    //ok
    {
        maxSize = L.maxSize;
        last = L.last;
        data = new T[maxSize];
        for (int i = 0; i <= last; i++)
            data[i] = L.data[i];
    }

    ~SeqList() { delete[] data; }    //ok

    int Size() const { return maxSize; } //ok

    int Length() const { return last + 1; }    //ok

    int Search(T &x, int l = 0, int r = -1) const    //ok
    {
        if(r == -1) r = last;

        int p = (l + r) >> 1;
        if(l == r) return data[l] == x ? l + 1 : 0;
        else if(data[p] >= x) return Search(x, l, p);
        else if(data[p] < x) return Search(x, p + 1, r);
    }

    int Locate(int i) const // ok
    {
        if(i >= 1 && i <= last + 1) return i;
        return -1;
    }

    bool getDate(int i, T &x) const    //ok
    {
        if (i > 0 && i <= last + 1)
        {
            x = data[i - 1];
            return true;
        }
        else return false;
    }

    void setData(int i, T &x)    //ok
    {
        if (i > 0 && i <= last + 1) data[i - 1] = x;
    }

    bool Insert(T &x) //ok
    {
        int p = ++last;
        while(p && data[p - 1] > x) data[p] = data[p-- - 1];
        data[p] = x;
        return true;
    }

    bool Remove(T &x)    //ok
    {
        int t = Search(x);
        if(t != -1)
            for(int i = t; i < last; i++)
                data[i] = data[i + 1];
        last--;
    }

    bool IsEmpty() { return (last == -1) ? true : false; }    //ok

    bool IsFull() { return (last + 1 == maxSize) ? true : false; }    //ok

    void input()    //ok
    {
        int n, x;
        cin >> n;
        for (int i = 0; i < n; i++)
        {
            cin >> x;
            Insert(x);
        }
    }

    void output()    //ok
    {
        cout << "{";
        for (int i = 0; i < last; i++)
            cout << data[i] << ", ";
        cout << data[last] << "}" << endl;
    }

    SeqList<T> operator = (SeqList<T> &L)    //ok
    {
        if (L.last >= maxSize) reSize(L.maxSize);
        last = L.last;
        for (int i = 0; i <= last; i++)
            data[i] = L.data[i];
    }
};

自己瞎写的(毕竟没怎么听过课...)改进的话等下次老师讲评时注意一下

时间: 2024-11-04 06:10:31

顺序表 有序表的相关文章

顺序表查找和有序表查找

查找里面顺比表查找和有序表查找(包括二分查找,插值查找,斐波那契查找)比较简单,直接贴代码,代码里面有详细注释. 1 #include <iostream> 2 using namespace std; 3 4 //顺序表查找(线性查找.静态表查找) 时间复杂度为O(n) 5 int Seq_Search(int *s,int n,int key) 6 { 7 s[0] = key; //设置了一个哨兵,避免了每次比较一次过后都要判断查找位置是否越界 8 int i = n; 9 while

大话数据结构—顺序表、有序表、线性索引查找

查找 根据给定的某个值,在查找表中确定一个其关键字(唯一的标识一个记录)等于给定值的数据元素或数据记录. 静态查找:只查找,不修改元素[线性表.顺序查找.二分查找] 动态查找:查找时,插入或者删除元素[二叉排序树] 顺序表查找 顺序查找(针对静态查找表),也叫线性查找O(n),从头开始遍历,直到最后一个记录. 优化:添加哨兵 //有哨兵的顺序查找 int foo(int *a,int n,int key) { int i; a[0]=key;//哨兵 i=n; while(a[i]!=key)

lua 表: 将一个有序表的顺序打乱

需求:将一个按顺序排放的表的顺序打乱 注意:该函数会修改掉原始表的数据,因为lua里表是传引用的 function Table_Rand(t) if t == nil then return end local tRet = {} local Total = table.getn(t) while Total > 0 do local i = math.random(1,Total) table.insert(tRet,t[i]) t[i] = t[Total] Total = Total -1

15.有序表查找与线索索引查找

转载请表明出处:http://blog.csdn.net/u012637501 一.有序表查找 1.折半查找/二分查找算法 (1)基本思想:在顺序存储的有序表中,取中间纪录(a[mid]=key)作为比较对象,若给定值与中间纪录的关键字相等,则查找成功:若给定值小于中间纪录的关键字,则在中间纪录的左半区继续查找:若给定值大于中间纪录的关键字,则在中间纪录的右半边.不断重复上述过程,直到查找成功,或所有查找区域无记录,查找失败为止. (2)使用条件:线性表中的纪录是关键码有序的(通常是从小到大有序

算法学习之查找算法:静态查找表(2)有序表查找

如果静态查找表是一个有序表,则可以使用折半查找. 折半查找的过程是:先确定待查记录所在的范围(区间),然后逐步缩小范围直到找到或找不到该记录为止.折半查找过程是以处于区间中间位置记录的关键字和给定值比较,若相等,则查找成功,若不等,则缩小范围,直至新的区间中间位置记录的关键字等于给定值或者查找区间的大小小于零时(表明查找不成功)为止. 关键字key与表中某一元素array[i]比较,有3种情况: 1.key==array[i],查找成功 2.key > array[i],待查找元素可能的范围是a

java模拟实现有序表操作

import java.util.Scanner; class DATA{//创建一个数据类型,用来作为有序表的每一个单元 String key; String name; int age; } class SLType{//创建一个有序表类,他包含一个data类型的数组,和一个固定长度 static final int MAXLEN=100; DATA[] ListData=new DATA[MAXLEN+1]; int ListLen; void SLInit(SLType SL){//有序

数据结构例程——合并有序表

本文针对数据结构基础系列网络课程(2):线性表中第15课时有序表. 问题:有两个有序表LA和LB,将它们合并成一个有序表LC.要求不破坏原有表LA和LB 算法思想: 解法1:用顺序表实现(支持的算法库,及list.h文件,请点击链接-) #include "list.h" void UnionList(SqList *LA,SqList *LB,SqList *&LC) { int i=0,j=0,k=0; //i.j.k分别作为LA.LB.LC的下标 LC=(SqList *

有序表的实现

所谓的有序表表,顾名思意啊,有序表应该就是数据是有一定顺序排列的,准确定义为:线性表中全部元素以递增或递减方式排列,并规定有序表中不存在不存在元素值同样的元素. 他是逻辑上的概念,不是物理上的. 逻辑结构类型有,线性结构,树形结构,图形结构,表示每一个节点之间的组织结构.物理上的结构有顺序存储结构,链式存储结构, 索引存储和哈希散列,表示逻辑上的数据结构以什么样的方式存储在存储设备上. 顺序表跟单链表都逻辑上都属于线性结构,可是顺序表是顺序存储在内存上,单链表是链式存储在内存上.而有序表则是一种

队列链表实现以及有序表的合并

#include<iostream> #include<algorithm> using namespace std; typedef struct Node{ int data; Node *next; }LNode, *LinkList; void Creat(LinkList &L){ L = new Node; L->next = NULL; cout << "你已经成功创建了一个队列" << endl; } voi