数据结构--用Objective-C简单实现的数据结构:栈

前言:最近在学习数据结构,这里用Objective-C简单实现了一下栈。用Objective-C确实好容易,因为我使用了Cocoa框架提供了NSMutableArray作为存储元素的集合,操作集合元素很方便。

只不过,下面这种实现方法可能不是最优化的,因为NSMutableArray不是最轻量级的集合容器。我现在还不知道如何写出最优化的栈实现,同时还需要满足这一个需求:存储的元素是OC对象 。

使用NSMutableArray作为存储元素的集合的优点:类似C语言实现栈的链式存储结构,就不会和C语言数组那样会出现溢出(或者是数组下标越界)的情况。

Objective-C源码:

文件StackForNSObject.h:

 1 #import <Foundation/Foundation.h>
 2
 3 // 只要参数是一个id类型的block
 4 typedef void (^StackBlock)(id objc);
 5
 6 @interface StackForNSObject : NSObject
 7
 8 // 入栈
 9 -(void)push:(id)objet;
10 // 出栈
11 -(id)popTopElement;
12 // 返回栈顶元素
13 -(id)TopElement;
14 // 是否为空
15 -(BOOL)isEmpty;
16 // 栈的长度
17 -(NSInteger)stackLength;
18 // 遍历,从栈底开始遍历
19 -(void)traversalElementFromBottom:(StackBlock)block;
20 // 从顶部开始遍历
21 -(void)traversalElementFromtop:(StackBlock)block;
22 // 所有元素出栈,一边出栈一边返回元素
23 -(void)traversalElementPopStack:(StackBlock)block;
24 // 清空
25 -(void)removeAllObjects;
26 // 返回栈顶元素
27 -(id)topElemet;
28
29 @end

文件:StackForNSObject.m

  1 #import "StackForNSObject.h"
  2
  3 @interface StackForNSObject ()
  4
  5 /** maxSize */
  6 //@property (nonatomic,assign)NSInteger maxSize;
  7
  8 // 有入栈就有出栈的时候,使用强引用,就要记得释放引用
  9 /** NSMutableArray */
 10 @property (nonatomic,strong)NSMutableArray *stackArray;
 11
 12 /** top of stack */
 13 @property (nonatomic,assign)NSInteger top;
 14
 15 /** stack */
 16 //@property (nonatomic,weak)StackBlock stackBlock;
 17
 18 @end
 19
 20 @implementation StackForNSObject
 21
 22 // 初始化
 23
 24 // 入栈
 25 -(void)push:(id)objet{
 26     [self.stackArray addObject:objet];
 27 }
 28
 29 // 出栈
 30 -(id)popTopElement{
 31     id objc = [self.stackArray lastObject];
 32     [self.stackArray removeLastObject];
 33     return objc;
 34 }
 35
 36 // 返回栈顶元素
 37 -(id)TopElement{
 38     return [self.stackArray lastObject];
 39 }
 40
 41 // 是否为空
 42 -(BOOL)isEmpty{
 43     return self.stackArray.count;
 44 }
 45
 46 // 栈的长度
 47 -(NSInteger)stackLength{
 48     return self.stackArray.count;
 49 }
 50
 51 // 从底部开始遍历
 52 -(void)traversalElementFromBottom:(StackBlock)block{
 53     NSEnumerator *objc = [self.stackArray objectEnumerator];
 54     for (id element in objc) {
 55         block(element);
 56     }
 57 }
 58
 59 // 从顶部开始遍历
 60 -(void)traversalElementFromtop:(StackBlock)block{
 61     // 先获取存储元素的个数
 62     NSInteger count = self.stackArray.count;
 63     for (NSInteger i = count; i > 0; i --) {
 64         // 处理最后一个元素
 65         block([self.stackArray objectAtIndex:i]);
 66     }
 67 }
 68
 69 // 所有元素出栈,同时遍历
 70 -(void)traversalElementPopStack:(StackBlock)block{
 71     // 先获取存储元素的个数
 72     NSInteger count = self.stackArray.count;
 73     for (NSInteger i = count; i > 0; i --) {
 74         // 处理最后一个元素
 75         block(self.stackArray.lastObject);
 76         [self.stackArray removeLastObject];
 77     }
 78 }
 79
 80 // 返回栈顶元素
 81 -(id)topElemet{
 82     return self.stackArray.lastObject;
 83 }
 84
 85 // 清空
 86 -(void)removeAllObjects{
 87     [self.stackArray removeAllObjects];
 88 }
 89
 90 #pragma mark - 懒加载
 91 -(NSMutableArray*)stackArray{
 92     if (_stackArray == nil) {
 93         _stackArray = [NSMutableArray array];
 94     }
 95     return _stackArray;
 96 }
 97 -(NSInteger)top{
 98     _top = self.stackArray.count;
 99     return _top;
100 }
101
102 #pragma mark - 不存在该对象的时候,自动清空
103 - (void)dealloc{
104     [self.stackArray removeAllObjects];
105 }
106
107 @end

测试代码:

该源码本人备份在百度云上了:链接: http://pan.baidu.com/s/1pKPrnsR 密码: eug9

时间: 2024-10-12 16:00:26

数据结构--用Objective-C简单实现的数据结构:栈的相关文章

数据结构与算法分析之简单排序算法

在排序算法中,简单排序主要有三种,分别为冒泡排序.选择排序.插入排序,学习理解好这三种排序算法有助于进一步研究数据结构与算法分析.下面,简单地谈一谈冒泡排序.选择排序.插入排序的原理及区别. 冒泡排序原理: 1.比较相邻的元素.如果前一个比后一个大,它们就交换. 2.每对元素都要进行同样的动作,从后往前比较. 3.每趟都会确定一个位置的元素,因此n个元素,需要n-1趟才能确定各个元素的位置. 例如:对23,4,56,11四个数进行冒泡排序. 第一趟 4,23,11,56 第二趟 4,11,23,

数据库的最简单实现与数据结构

原文:http://www.ruanyifeng.com/blog/2014/07/database_implementation.html 数据库的最简单实现 作者: 阮一峰 日期: 2014年7月 4日 所有应用软件之中,数据库可能是最复杂的. MySQL的手册有3000多页,PostgreSQL的手册有2000多页,Oracle的手册更是比它们相加还要厚. 但是,自己写一个最简单的数据库,做起来并不难.Reddit上面有一个帖子,只用了几百个字,就把原理讲清楚了.下面是我根据这个帖子整理的

数据结构:稀疏矩阵的简单运算

最近专业课比较多,没怎么看数据结构了.今天有点时间写了一下数据结构中稀疏矩阵的运算.写过之后感觉代码的构思不太好.这里先发一下, 假期的时候再重新实现一下. SpMatrix头文件 1 //The sparse matrix's header file 2 //the class SpMatrix 3 //Author: 'Karllen' 4 //Date:05/28/2014 5 6 #ifndef _SpMatrix_H_ 7 #define _SPMatrix_H_ 8 #include

Java数据结构和算法(三)——简单排序

单单有数据还不够,对于数据的展现,经常要按照一定的顺序进行排列,越高要求的排序越复杂,这篇只介绍三种大小的简单排序. 1)冒泡排序 模拟:有数组,1,4,2,5,7,3. (1)首先从1开始冒泡,1比4小,不冒,4大于2,冒上去,与2交换位置,4比5小,不冒,7比3大,冒,结果:1,2,4,5,3,7 (2)接下来从2开始,因为第一个元素冒过了,重复(1),结果:1,2,4,3,5,7 (3)从第三位4开始,结果1,2,3,4,5,7 (4)虽然看起来已经排好序,但是还是要继续冒,接下来就是从第

算法与数据结构基础3:简单单链表List类的实现

简单的单链表实现,数据类型定义成了int,如果要通用,需要改成模板类,然后稍微修改下就可以了. // List.h #include <cstdio> #include <cassert> #include <iostream> using namespace std; class List { public: // ************************************************************************** //

Redis数据结构(一)简单动态字符串

Redis的字符串采用的是自定义的struct,名字叫做简单动态字符串(simple dynamic string,SDS). 结构如下: struct sdshdr{ int len; int free; char buf[]; }; 采用如此结构的好处是: [1]获取length的时候复杂度为O(1),不需要O(n): [2]动态分配空间,避免缓冲区溢出,避免每次修改或者append都重新分配: [3]二进制安全: 关于第一点显而易见,第二点,为了减少修改字符串带来的内存重分配次数,redi

数据结构和算法之简单选择排序

/// <summary> /// 简单选择排序 /// 给定数组:int[] arr={里面n个数据}: /// 第1趟排序,在待排序数据arr[1]~arr[n]中选出最小的数据,将它与arrr[1]交换: /// 第2趟,在待排序数据arr[2]~arr[n]中选出最小的数据,将它与r[2]交换: /// 以此类推,第i趟在待排序数据arr[i]~arr[n]中选出最小的数据,将它与r[i]交换,直到全部排序完成. /// </summary> /// <param n

数据结构One_Vector(向量的简单实现)

1 #include <iostream> 2 using namespace std; 3 4 template<typename Object> 5 class Vector 6 { 7 private: 8 int theSize; //实际数据大小 9 int theCapacity; //实际容器容量大小 10 Object *objects; //基本数组 11 public: 12 enum { SPACE_CAPACITY = 16 }; //默认容量大小 13 1

数据结构之选择排序--简单选择排序

排序思路:在要排序的一组数中,选出最小的一个数与第一个位置的数交换:然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环.算法实现: public static void selectSort(int arr[]){ int temp; for(int i = 0;i < arr.length-1; i ++){//有N个元素只需比较N-1次 int min = i;//记住初始位置 for(int j = i+1; j < arr.length; j ++){//在 [i+1,arr.