您的位置：首页 > 理论基础 > 数据结构算法

数据结构基础

2016-03-04 10:21 309 查看
1.线性表存取效率为O(1)

2.线性表部分操作
1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47
#defineOK1

#defineERROR0

#defineTRUE1

#defineFALSE0

typedef
int
Status;


StatusGetElem(SqListL,
int
i,ElemType*e)

{

if
(L.length==0||i<1||i>L.length)

return
ERROR;

*e=L.data[i-1];

return
OK;

}


StatusListInsert(SqList*L,
int
i,ElemTypee)

{

if
(L->length==MAXSIZE)
//顺序线性表已满

return
ERROR;

if
(i<1||i>L->length+1)
//插入位置不合理因为是插入所以i可以等于length+1即插入到表最末位

return
ERROR;

if
(i<=L->lenth)
//若插入位置不在表尾即i不等于length+1的情况

{

for
(
int
k=L->length-1;k>i;k--)
//将第i+1到第length-1个元素分别往后移动一位

{

L->data[k+1]=L->data[k];

}

}

L->data[i-1]=e;
//插入新元素

L->length++;

return
OK;

}


StatusListDelete(SqList*L,
int
i,ElemTypee)

{

if
(L->length==0)
//顺序线性表为空

return
ERROR;

if
(i<1||i>L->length)
//删除位置不正确

return
ERROR;

*e=L->data[i-1];

if
(i<L->lenth)
//如果删除不是最后位置

{

for
(
int
k=i;k<L->length;k++)
//将删除位置后继元素前移

L->data[k-1]=L->data[k];

}

L->length--;

}



3.线性表存、读数据时时间复杂度O(1)；插入或删除是时间复杂度为O(n).

1.单链表的存储结构

1

2

3

4

5

6

7
typedef
struct
Node

{

ElemTypedata;

struct
Node*next;

}Node;

typedef
struct
Node*LinkList;


2.单链表访问第i个节点

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15
StatusGetElem(LinkList
L,
int
i,ElemType*e)

{

LinkListp;

p=L->next;

while
(p||j<i)

{

p=p->next;

j++;

}

if
(!p&&j>i)

return
ERROR;

*e=p->data;

return
OK;

}



由于单链表的结构中没有定义表厂，所以事先不知道要循环多少次，因此通常用while而不是for来控制循环

3.单链表插入节点

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18
StatusListInsert(LinkListL,
int
i,ElemTypee)

{

LinkList
*p,*s;

p=L->next;

int
j=1;

while
(p||j<i)

{

p=p->next;

j++;

}

if
(!p||j>i)

return
ERROR;

s=(LinkList)
malloc
(
sizeof
(Node));

s->data=e;

s->next=p->next;

p->next=s;

}



4.单链表删除节点

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17
StatusListDel(LinkNode*L,
int
n)

{

LinkNode*p=L->pNext;

int
j=0;

while
(!p&&j<n)

{

p=p->pNext;

j++;

}

if
(!p)

return
ERROR;

LinkNode*q=p->pNext;

p->pNext=q->pNext;

delete
[]q;

return
OK;

}

1.顺序栈的构造入栈出栈及两栈共享空间

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66
#defineMAXSIZE100

typedef
int
SElemType;

typedef
struct

{

SElemTypedata[MAXSIZE];

int
top;

}SqStack;


int
Push(SqStack*S,SElemTypee)

{

if
(S->top==MAXSIZE-1)

return
-1;

S->top++;

S->data[S->top]=e;

return
0;

}


int
Pop(SqStack*S)

{

if
(S->top==-1)

return
-1;

S->top--;

return
0;

}


typedef
struct

{

SElemTypedata[MAXSIZE];

int
top1;

int
top2;

}SqDoubleStack;


int
Push2(SqDoubleStack*S,SElemTypee,
int
stackNumber)

{

if
(S->top1+1==S->top2)

return
-1;

if
(stackNumber==1)

{

S->top1++;

S->data[top1]=e;

}

if
(stackNumber==2)

{

S->top2--;

S->data[top2]=e;

}

return
0;

}


int
Pop2(SqDoubleStack*S,
int
stackNumber)

{

if
(stackNumber==1)

{

if
(S->top1==-1)

return
-1;

S->top1--;

}

else
if
(stackNumber==2)

{

if
(S->top2==MAXSIZE)

return
-1;

S->top2++;

}

return
0;

}



2.链栈的构造入栈和出栈

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38
#defineMAXSIZE100

typedef
int
SElemType;


typedef
struct
StackNode

{

SElemTypedata;

struct
StackNode*next;

}StackNode,*LinkStackPtr;


typedef
struct
LinkStack

{

LinkStackPtrtop;

int
count;

}LinkStack;


int
Push(LinkStack*L,SElemTypee)

{

LinkStackPtrp=(LinkStackPtr)
malloc
(
sizeof
(StackNode));

p->data=e;

p->next=L->top;

L->top=p;

L->count++;

return
0;

}


int
Pop(LinkStack*L,SElemType*e)

{

LinkStackPtrp=NULL;

if
(StackEmpty(L))

return
-1;

*e=L->top->data;

p=L->top;

L->top=L->top->next;

free
(p);

L->count--;

return
0;


如果栈的使用过程中元素变化不可预料，有时很小有时很大，最好用链栈；反之，如果它的变化在可控范围内，建议用顺序栈。

3.队列：插入数据只能在队尾进行，删除数据只能在对头进行。
front指针指向对头元素，rear指针指向队尾元素的下一位置。当front==rear时说明队列为空。

4.循环队列满的条件是(rear+1)%QueueSize==front;
通用的计算队列长度公式：(rear-front+QueueSize)%QueueSize;


                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航