栈的正序逆序插入删除清空操作源代码

合集下载

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法顺序表是一种基本的数据结构,它可以存储线性结构,支持随机访问,具有较好的存储效率。

在实际应用中,我们需要实现顺序表的各种基本运算,包括插入、删除、查找、遍历、排序等操作。

下面介绍一些实现顺序表基本运算的算法。

1.插入算法顺序表插入算法的基本思路是:将插入位置之后的所有元素向后移动一位,然后将待插入元素放入插入位置。

具体实现如下:```void Insert(SqList &L, int pos, int data){if (pos < 1 || pos > L.length + 1) // 插入位置非法return;if (L.length == L.MAXSIZE) // 顺序表已满return;for (int i = L.length; i >= pos; i--) // 将pos以后的元素依次后移,腾出pos位置L.data[i] = L.data[i - 1];L.data[pos - 1] = data; // 将新元素插入pos位置L.length++; // 顺序表长度+1}```2.删除算法顺序表删除算法的基本思路是:将待删除元素之后的所有元素向前移动一位,然后将顺序表长度减1。

具体实现如下:```void Delete(SqList &L, int pos){if (pos < 1 || pos > L.length) // 删除位置非法return;for (int i = pos; i < L.length; i++) // 将pos以后的元素依次前移,覆盖pos位置L.data[i - 1] = L.data[i];L.length--; // 顺序表长度-1}```3.查找算法顺序表查找算法的基本思路是:从表头开始逐个比较元素,直到找到目标元素或者搜索到表尾。

具体实现如下:```int Search(SqList L, int data){for (int i = 0; i < L.length; i++){if (L.data[i] == data) // 找到目标元素,返回其下标return i;}return -1; // 未找到目标元素,返回-1}```4.遍历算法顺序表遍历算法的基本思路是:从表头开始依次输出元素。

数据结构C语言实现顺序表的插入和删除代码

数据结构C语言实现顺序表的插入和删除代码

printf("Please In Put The Number To Insert:\n"); scanf("%d",&m); p=&(L->elem[i-1]); for(q=L->elem+L->length-1;p<=q;--q) *(q+1)=*q; *p=m; ++L->length; printf("The New List Is:\n"); for(p=L->elem;p<=L->elem+L->length-1;p++) printf("%-4d",*p); printf("\n"); return OK; } Status ListDelete_Sq(SqList *L) { int i; int e; int *p; int *q; printf("Please In Put The Location To Delete:\n"); scanf("%d",&i); p=&(L->elem[i-1]); e=*p; q=L->elem+L->length-1; for(++p;p<=q;++p) *(p-1)=*p; --L->length; printf("The Delete Number Is %d\n",e); printf("The New List Is:\n"); for(p=L->elem;p<=L->elem+L->length-1;p++) printf("%-4d",*p); printf("\n"); return OK; } main() { int n,i; InitList_Sq(&L); printf("Please In Put Length:\n"); scanf("%d",&n); CreateList_Sq(&L,n); InsertList_Sq(&L); ListDelete_Sq(&L); printf("\n");

java顺序表的基本操作代码

java顺序表的基本操作代码

java顺序表的基本操作代码Java顺序表是一种基于数组实现的线性结构,具有随机访问、元素插入和删除等基本操作。

在Java中,我们可以通过定义一个数组来创建一个顺序表,并通过编写一些基本操作代码来实现对该顺序表的操作。

一、顺序表的定义和初始化在Java中,我们可以通过定义一个数组来创建一个顺序表。

下面是一个简单的代码示例:```public class SeqList<T> {private Object[] elementData; // 存储元素的数组private int size; // 当前元素个数// 构造函数public SeqList(int capacity) {elementData = new Object[capacity];size = 0;}}```在上述代码中,我们定义了一个SeqList类,其中包含了存储元素的数组elementData和当前元素个数size两个成员变量。

构造函数SeqList(int capacity)用于创建指定长度为capacity的数组,并将当前元素个数初始化为0。

二、顺序表的插入操作1. 在指定位置插入元素在Java中,我们可以通过下标来访问数组中的元素。

因此,在进行插入操作时,需要先将要插入位置之后的所有元素向后移动一位,然后再将新元素插入到指定位置上。

下面是一个简单的代码示例:```// 在指定位置插入元素public void insert(int index, T element) {if (index < 0 || index > size) {throw new IndexOutOfBoundsException("插入位置越界"); }// 判断数组是否已满,若已满则扩容if (size == elementData.length) {ensureCapacity(size * 2);}// 将要插入位置之后的所有元素向后移动一位for (int i = size - 1; i >= index; i--) {elementData[i + 1] = elementData[i];}// 插入新元素elementData[index] = element;size++;}// 扩容方法private void ensureCapacity(int minCapacity) {if (minCapacity > elementData.length) {Object[] newArray = new Object[minCapacity];System.arraycopy(elementData, 0, newArray, 0, size);elementData = newArray;}}```在上述代码中,我们首先判断要插入的位置是否越界。

c语言数据结构第3章栈和队列自测卷答案

c语言数据结构第3章栈和队列自测卷答案

head 第3章 栈和队列 自测卷答案 姓名 班级一、填空题〔每空1分,共15分〕1. 【李春葆】向量、栈和队列都是 线性 构造,可以在向量的 任何 位置插入和删除元素;对于栈只能在 栈顶 插入和删除元素;对于队列只能在 队尾 插入和 队首 删除元素。

2. 栈是一种特殊的线性表,允许插入和删除运算的一端称为 栈顶 。

不允许插入和删除运算的一端称为 栈底 。

3. 队列 是被限定为只能在表的一端进展插入运算,在表的另一端进展删除运算的线性表。

4. 在一个循环队列中,队首指针指向队首元素的 前一个 位置。

5. 在具有n 个单元的循环队列中,队满时共有 n-1 个元素。

6. 向栈中压入元素的操作是先 挪动栈顶指针 ,后 存入元素 。

7. 从循环队列中删除一个元素时,其操作是 先 挪动队首指针 ,后 取出元素 。

8. 〖00年统考题〗带表头结点的空循环双向链表的长度等于 0 。

解:二、判断正误〔判断以下概念的正确性,并作出简要的说明。

〕〔每题1分,共10分〕 〔 × 〕1. 线性表的每个结点只能是一个简单类型,而链表的每个结点可以是一个复杂类型。

错,线性表是逻辑构造概念,可以顺序存储或链式存储,与元素数据类型无关。

〔 × 〕2. 在表构造中最常用的是线性表,栈和队列不太常用。

错,不一定吧?调用子程序或函数常用,CPU 中也用队列。

〔 √ 〕3. 栈是一种对所有插入、删除操作限于在表的一端进展的线性表,是一种后进先出型构造。

〔 √ 〕4. 对于不同的使用者,一个表构造既可以是栈,也可以是队列,也可以是线性表。

正确,都是线性逻辑构造,栈和队列其实是特殊的线性表,对运算的定义略有不同而已。

〔 × 〕5. 栈和链表是两种不同的数据构造。

错,栈是逻辑构造的概念,是特殊殊线性表,而链表是存储构造概念,二者不是同类项。

〔 × 〕6. 栈和队列是一种非线性数据构造。

错,他们都是线性逻辑构造,栈和队列其实是特殊的线性表,对运算的定义略有不同而已。

C语言顺序表的实现代码

C语言顺序表的实现代码

C语⾔顺序表的实现代码本⽂实例为⼤家分享了C语⾔实现顺序表的具体代码,供⼤家参考,具体内容如下seqlist.h#ifndef __SEQLIST_H__#define __SEQLIST_H__#include<cstdio>#include<malloc.h>#include<assert.h>#define SEQLIST_INIT_SIZE 8#define INC_SIZE 3 //空间增量的⼤⼩typedef int ElemType;typedef struct Seqlist {ElemType *base;int capacity; //顺序表容量int size; //表的⼤⼩}Seqlist;bool Inc(Seqlist *list);//增加顺序表的容量void InitSeqlist(Seqlist *list); //初始化顺序表void push_back(Seqlist *list, ElemType x); //在顺序表的末尾插⼊元素void push_front(Seqlist *list, ElemType x); //在顺序表的头部插⼊元素void show_list(Seqlist *list); //显⽰顺序表中的元素void pop_back(Seqlist *list); //删除顺序表最后⼀个元素void pop_front(Seqlist *list); //删除顺序表第⼀个元素void insert_pos(Seqlist *list, int pos, ElemType x);//在顺序表的选定位置上插⼊数据int find(Seqlist *list, ElemType key); //在顺序表中查找元素key的下标int length(Seqlist *list);//求顺序表的长度void delete_pos(Seqlist *list, int pos); //删除顺序表中特定位置的数据元素void delete_val(Seqlist *list, int key);//删除顺序表中值为key的数据元素void sort(Seqlist *list);//冒泡排序void reverse(Seqlist *list);//逆置顺序列表void clear(Seqlist *list);//清除顺序表中的所有元素void destroy(Seqlist *list);//摧毁顺序表void merge(Seqlist *lt, Seqlist *la, Seqlist *lb);//合并两个顺序列表#endif //__SEQLIST_H__seqlist.cpp#include"seqlist.h"bool Inc(Seqlist *list) {ElemType *newbase = (ElemType*)realloc(list, sizeof(ElemType)*(list->capacity + INC_SIZE)); //重新分配内存空间if (newbase == NULL) {printf("内存空间已满,⽆法再分配内存空间!\n");return false;}list->base = newbase;list->capacity += INC_SIZE;return true;}void InitSeqlist(Seqlist *list) {list->base = (ElemType*)malloc(sizeof(ElemType)*SEQLIST_INIT_SIZE);assert(list->base != NULL);list->capacity = SEQLIST_INIT_SIZE;list->size = 0;}void push_back(Seqlist *list, ElemType x) {if (list->size >= list->capacity && !Inc(list)) { //Inc(list)⽤来判断增加顺序表容量是否成功,只有在失败的情况下才会进⼊if语句中 printf("顺序表容量已满,⽆法再在表尾继续插⼊新元素!\n");return;}list->base[list->size] = x;list->size++;}void push_front(Seqlist *list, ElemType x) {if (list->size >= list->capacity && !Inc(list)) {printf("顺序表容量已满,⽆法再在表头插⼊新元素!\n"); return;}for (int i = list->size;i > 0;i--) {list->base[i] = list->base[i - 1];}list->base[0] = x;list->size++;}void show_list(Seqlist *list) {for (int i = 0;i < list->size;i++) {printf("%d ", list->base[i]);}printf("\n");}void pop_back(Seqlist *list) {if (list->size == 0) {printf("顺序表已空,⽆法再在表尾删除元素!\n");return;}list->size--;}void pop_front(Seqlist *list) {if (list->size == 0) {printf("顺序表已空,⽆法再在表头删除元素!\n");return;}for (int i = 0;i < list->size - 1;i++) {list->base[i] = list->base[i + 1];}list->size--;}void insert_pos(Seqlist *list, int pos, ElemType x) {if (pos<0 || pos>list->size) {printf("插⼊位置不合法,⽆法插⼊元素!\n");return;}if (list->size >= list->capacity && !Inc(list)) {printf("顺序表容量已满,⽆法在插⼊新的元素!\n");return;}for (int i = list->size;i > pos;i--) {list->base[i] = list->base[i - 1];}list->base[pos] = x;list->size++;}int find(Seqlist *list, ElemType key) {for (int i = 0;i < list->size;i++) {if (list->base[i] == key)return i;}return -1;}int length(Seqlist *list) {return list->size;}void delete_pos(Seqlist *list, int pos) {if (pos < 0 || pos >= list->size) {printf("删除位置不合法,⽆法删除元素!\n");return;}for (int i = pos;i < list->size - 1;i++) {list->base[i] = list->base[i + 1];}list->size--;}void delete_val(Seqlist *list, int key) {int pos = find(list, key);if (pos == -1) {printf("顺序表中没有这个元素!\n");return;}delete_pos(list, pos);}void sort(Seqlist *list) {for (int i = 0;i < list->size - 1;i++) {//排序的趟数(例如5个数据需要⽐较4趟)for (int j = 0;j < list->size - 1 - i;j++) {//每⼀趟⽐较中的⽐较次数(例如5个数据在第0趟需要⽐较4次) if (list->base[j] > list->base[j + 1]) {ElemType temp = list->base[j];list->base[j] = list->base[j + 1];list->base[j + 1] = temp;}}}}void reverse(Seqlist *list) {if (list->size == 0 || list->size == 1) return;int low = 0, high = list->size - 1;while (low < high) {ElemType temp = list->base[low];list->base[low] = list->base[high];list->base[high] = temp;low++;high--;}}void clear(Seqlist *list) {list->size = 0;}void destroy(Seqlist *list) {free(list->base);list->base = NULL;list->capacity = 0;list->size = 0;}void merge(Seqlist *lt, Seqlist *la, Seqlist *lb) {lt->capacity = la->size + lb->size;lt->base = (ElemType*)malloc(sizeof(ElemType)*lt->capacity);assert(lt->base != NULL);int ia = 0, ib = 0, ic = 0;while (ia < la->size&&ib < lb->size) {if (la->base[ia] < lb->base[ib]) {lt->base[ic++] = la->base[ia++];}else {lt->base[ic++] = lb->base[ib++];}}while (ia < la->size) {lt->base[ic++] = la->base[ia++];}while (ib < lb->size) {lt->base[ic++] = lb->base[ib++];}lt->size = la->size + lb->size;show_list(lt);}main.cpp#include"seqlist.h"void main() {Seqlist list;InitSeqlist(&list);ElemType item;int select = 1;while (select) {printf("*******************************************\n");printf("*[1] push_back [2] push_front *\n");printf("*[3] show_list [4] pop_back *\n");printf("*[5] pop_front [6] insert_pos *\n");printf("*[7] find [8] length *\n");printf("*[9] delete_pos [10] delete_value *\n");printf("*[11] sort [12] reverse *\n");printf("*[13] clear [14] merge *\n");printf("*[0] quit_system *\n");printf("*******************************************\n");printf("请选择:>>");scanf("%d", &select);if (select == 0) break;switch (select) {case 1:printf("请输⼊要插⼊的数据(-1结束):>");while (scanf("%d", &item), item != -1) {//先输⼊item的值,只要item不等于-1就接着循环 push_back(&list, item);}break;case 2:printf("请输⼊要插⼊的数据(-1结束):>");while (scanf("%d", &item), item != -1) {push_front(&list, item);}break;case 3:show_list(&list);break;case 4:pop_back(&list);break;case 5:pop_front(&list);break;case 6:printf("请输⼊要插⼊的数据:>");scanf("%d", &item);printf("请输⼊要插⼊的位置:>");scanf("%d", &pos);insert_pos(&list, pos, item);break;case 7:printf("请输⼊要查找的数据:>");scanf("%d", &item);pos = find(&list, item);if (pos == -1)printf("查找的数据元素不在顺序表中!\n");elseprintf("查找的数据元素在顺序表中的下标位置为%d\n", pos);break;case 8:printf("顺序表的长度为%d\n", length(&list));break;case 9:printf("请输⼊要删除数据在顺序表中的下标位置:>");scanf("%d", &pos);delete_pos(&list, pos);break;case 10:printf("请输⼊要删除数据的值:>");scanf("%d", &item);delete_val(&list, item);break;case 11:sort(&list);break;case 12:reverse(&list);break;case 13:clear(&list);break;Seqlist mylist, yourlist;ElemType item1, item2;InitSeqlist(&mylist);InitSeqlist(&yourlist);printf("请输⼊顺序表1中的元素值(-1结束):>");while (scanf("%d", &item1), item1 != -1) {push_back(&mylist, item1);}printf("请输⼊顺序表2中的元素值(-1结束):>");while (scanf("%d", &item2), item2 != -1) {push_back(&yourlist, item2);}merge(&list, &mylist, &yourlist);destroy(&mylist);destroy(&yourlist);break;default:printf("输⼊的选择错误!请重新输⼊!\n");break;}}destroy(&list);}以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。

c语言实现顺序表的增删查改逆置简单代码

c语言实现顺序表的增删查改逆置简单代码

c语言实现顺序表的增删查改逆置简单代码1. 顺序表的定义顺序表是一种线性表,其元素在内存中按顺序存储,每个元素占用连续的存储单元。

顺序表的特点是存取速度快,但插入和删除元素时需要移动大量的元素。

顺序表可以用结构体来表示,其定义如下:typedef struct_SeqList {int*data; // 指向数据元素的指针int size; // 顺序表的长度int capacity; // 顺序表的容量} SeqList;2. 顺序表的初始化顺序表的初始化需要分配内存空间来存放数据元素。

可以使用以下代码来初始化顺序表:SeqList*init_seq_list(int capacity) {SeqList*list= (SeqList*)malloc(sizeof(SeqList));if (list==NULL) {return NULL;}list->data= (int*)malloc(sizeof(int) *capacity);if (list->data==NULL) {free(list);return NULL;}list->size=0;list->capacity=capacity;return list;}3. 顺序表的插入在顺序表中插入元素需要移动后面的元素,以保证元素的顺序性。

可以使用以下代码在顺序表中插入元素:int insert_seq_list(SeqList*list, int index, int value) {if (index<0||index>list->size) {return-1;}if (list->size==list->capacity) {// 扩容顺序表int*new_data= (int*)realloc(list->data, sizeof(int) *list->capacity*2);if (new_data==NULL) {return-1;}list->data=new_data;list->capacity*=2;}// 移动后面的元素for (int i=list->size; i>index; i--) {list->data[i] =list->data[i-1];}// 插入元素list->data[index] =value;list->size++;return0;}4. 顺序表的删除从顺序表中删除元素需要移动后面的元素,以保证元素的顺序性。

栈的基本操作代码

栈的基本操作代码引言栈(Stack)是一种常见的数据结构,具有后进先出(Last In First Out,LIFO)的特性。

栈的基本操作包括入栈(Push)、出栈(Pop)、获取栈顶元素(Top)和判断栈是否为空(IsEmpty)。

本文将详细介绍栈的基本操作代码及其实现。

一、栈的定义栈是一种线性数据结构,仅允许在一端进行插入和删除操作。

这一端被称为栈顶,另一端称为栈底。

栈的插入操作叫做入栈,删除操作叫做出栈。

栈的特性决定了最后插入的元素最先删除。

二、栈的基本操作2.1 入栈(Push)入栈操作将一个元素添加到栈的栈顶。

具体实现如下:class Stack:def __init__(self):self.stack = []def push(self, item):self.stack.append(item)2.2 出栈(Pop)出栈操作将栈顶元素删除并返回。

具体实现如下:class Stack:def __init__(self):self.stack = []def push(self, item):self.stack.append(item)def pop(self):if not self.is_empty():return self.stack.pop()else:return None2.3 获取栈顶元素(Top)获取栈顶元素操作不改变栈的结构,仅返回栈顶元素的值。

具体实现如下:class Stack:def __init__(self):self.stack = []def push(self, item):self.stack.append(item)def pop(self):if not self.is_empty():return self.stack.pop()else:return Nonedef top(self):if not self.is_empty():return self.stack[-1]else:return None2.4 判断栈是否为空(IsEmpty)判断栈是否为空操作用于检测栈内是否还有元素。

顺序栈的实现代码

顺序栈的实现代码顺序栈是一种基于数组实现的栈结构,它具有后进先出(LIFO)的特点。

在顺序栈中,元素的插入和删除操作只能在栈顶进行,即只能在栈顶进行入栈和出栈操作。

下面我们将介绍顺序栈的实现代码。

我们需要定义一个顺序栈的结构体,包含两个主要的成员变量:一个数组用于存储栈中的元素,一个整数用于记录栈顶的位置。

```#include <stdio.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} SeqStack;```在顺序栈的初始化函数中,我们将栈顶位置初始化为-1,表示栈为空。

```void init(SeqStack *stack) {stack->top = -1;}```接下来,我们实现入栈操作。

入栈操作是将一个元素插入到栈顶的过程。

首先,我们需要判断栈是否已满,如果栈已满则无法插入元素;如果栈未满,则将栈顶位置加1,并将要插入的元素放入栈顶位置。

```void push(SeqStack *stack, int element) {if (stack->top == MAX_SIZE - 1) {printf("Stack is full, cannot push element.\n");return;}stack->top++;stack->data[stack->top] = element;}```然后,我们实现出栈操作。

出栈操作是将栈顶元素删除的过程。

首先,我们需要判断栈是否为空,如果栈为空则无法删除元素;如果栈不为空,则将栈顶位置减1,并返回栈顶元素的值。

```int pop(SeqStack *stack) {if (stack->top == -1) {printf("Stack is empty, cannot pop element.\n");return -1;}int element = stack->data[stack->top];stack->top--;return element;}```接下来,我们实现获取栈顶元素的操作。

插入排序法C语言代码

插入排序法C语言代码插入排序法是一种简单且常用的排序算法,它的原理是将未排序的元素逐个插入到已排序的序列中。

下面,我们来介绍一下插入排序法的C语言代码实现。

1. 基本思路插入排序法先将第一个元素视为已排序的序列,然后从第二个元素开始,逐个将未排序的元素插入到已排序的序列中。

具体地,我们用一个循环来遍历所有待排序的元素,将当前元素与已排序的元素进行比较,直到找到合适的位置插入。

2. C语言代码实现下面是插入排序法的C语言代码实现:void insertionSort(int arr[], int n){int i, j, key;for (i = 1; i < n; i++) {key = arr[i];j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j = j - 1;}arr[j + 1] = key;}}在这个代码中,我们使用了两个循环。

外层循环遍历所有待排序的元素,内层循环将当前元素和已排序的元素进行比较,找到合适的位置插入。

具体地,我们使用key变量保存当前元素的值,并从当前元素的前一个元素开始,逐个和已排序的元素进行比较,直到找到比当前元素小的元素或者已经到达已排序序列的起始位置。

然后,我们将已排序序列中所有比当前元素大的元素往后移动一个位置,为当前元素腾出空间。

最后,我们将当前元素插入合适的位置,这一步操作使得序列中的元素数量加一。

3. 性能分析插入排序法时间复杂度为O(n^2),其中n是待排序的序列长度。

具体地,我们可以发现,外层循环需要执行n次,内层循环最坏情况下需要执行n次,因此总的时间复杂度为O(n^2)。

此外,插入排序法还需要进行数据移动,因此其空间复杂度为O(1),即仅需一个辅助变量。

综上所述,插入排序法是一种简单且高效的排序算法。

它可以用于大多数情况,并且易于实现。

大学《数据结构》第三章:栈和队列-第一节-栈

第一节栈
一、栈的定义及其运算
1、栈的定义
栈(Stack):是限定在表的一端进行插入和删除运算的线性表,通常将插入、删除的一端称为栈项(top),另一端称为栈底(bottom)。

不含元素的空表称为空栈。

栈的修改是按后进先出的原则进行的,因此,栈又称为后进先出(Last In First Out)的线性表,简称为LIFO表。

真题选解
(例题·填空题)1、如图所示,设输入元素的顺序是(A,B,C,D),通过栈的变换,在输出端可得到各种排列。

若输出序列的第一个元素为D,则输出序列为。

隐藏答案
【答案】DCBA
【解析】根据堆栈"先进后出"的原则,若输出序列的第一个元素为D,则ABCD入栈,输出序列为DCBA
2、栈的基本运算
(1)置空栈InitStack(&S):构造一个空栈S。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

#include<stdio.h>
#include<string.h>
#include<ctype.h>//作用的函数??????????
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit( )
#include<iostream.h> // cout,cin
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int SElemType;
typedef int Status;
#define STACK_INIT_SIZE 100// 存储空间初始分配量
#define STACKINCREMENT 10 // 存储空间分配增量
typedef struct {
SElemType *base; // base的初值为NULL
SElemType *top; // 栈顶指针
int stacksize; // 当前已分配的存储空间,以元素为单位
}SqStack;
Status InitStack(SqStack &S){
// 构造一个空栈S
S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base) exit(OVERFLOW);
S.top =S.base;
S.stacksize= STACK_INIT_SIZE;
return OK;
}// STACK_INIT_SIZE
Status StackEmpty (SqStack S){
// 若栈S为空栈,则返回TRUE,否则返回FALSE
if(S.top-S.base)
return FALSE;
return TRUE;
}
Status Push(SqStack &S, SElemType e){
// 插入元素e为新的栈顶元素
int *Newbase;
if(S.top-S.base>=S.stacksize){//栈满,追加存储
Newbase=(SElemType*)realloc(S.base,(S.stacksize+ STACKINCREMENT)*sizeof(SElemType));
if(!Newbase)exit(OVERFLOW);//存储分配失败
S.base=Newbase;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}//push
Status Pop (SqStack &S,SElemType &e){
// 若栈不空,则删除S的栈顶元素,用e返回其值,
// 并返回OK;否则返回ERROR
if(S.top==S.base)
return ERROR;
e=*--S.top;
return OK;
}//Pop
Status ClearStack (SqStack &S){
// 把S置为空栈
S.top=S.base;
return OK;
}// ClearStack
//正序输出
void PrintL(SqStack &S)
{
int *p,n;
p=S.base;
for(n=S.top-S.base;n>0;n--)
{
printf("%d\t",*p);
p++;
}
//逆序输出
/*void PrintL(SqStack &S)
{
int *p,n;
p=S.top;
for(n=0;n<S.top-S.base;n++)
{
printf("%d\t",*--p);//为啥不可以替换--p???
}
}*/
void main()
{
int k,e;//为了区别下边变量的用法不同这里用k区别开n的作用//int n,e;
SqStack S;
InitStack (S);
printf("空栈已经为您创建成功啦!*_* \n");
printf("请您输入入栈的元素:^_^ \n"); //$$
while(e!=0) //这里的0是输入入栈元素结束的标志
{
scanf("%d",&e); //输入栈中元素
Push(S,e); //进栈操作
if(e==0){ //$$
Pop (S, e); //$$在打印出来之前删掉栈尾部元素^_^
PrintL(S); //$$输出栈
break; //$$结束
}
}
// PrintL(S);这里会出现反复输出的现象
printf("\n1.插入\t\n2.删除\t\n3.清空\t\n0.退出\t\n请选择您需要的操作序号~_~ \n");
while(k){//主函数中定义的k可以用了
int n;
scanf("%d",&n);
switch(n){ //switch(k){
case 1:
printf("请输入您要插入的数字@_@ --->\t");
scanf("%d",&e);
printf("\n");//添加
Push (S,e);
printf("插入栈顶元素后栈的情况如下所示~_~\n");//要清楚地告诉
PrintL(S);
printf("\n请选择您还需要的操作序号*_*\n");//可删除
break;
case 2:
printf("删除栈尾元素后栈的情况如下所示#_#\n");
Pop (S, e);
// printf("删除栈顶元素%d \t",e);//输出不好看不用
PrintL(S);
printf("\n");
printf("\n请选择您还需要的操作序号*_*\n");//可删除
break;
case 3:
ClearStack(S);
printf("栈已清空!_! !_!");
printf("\n请选择您还需要的操作序号*_*\n");//可删除
break;
case 0:
exit(0);break;
default: exit(0);
}
}
}
总结:
这是关于栈的基本操作的程序,我自己调试了一个晚上。

里面好多代码都是心血呀。

程序主要实现的是:
栈的逆序和正序输出。

栈的插入,删除,清空,进栈,入栈。

相关文档
最新文档